用户定义的 C++11 枚举类默认构造函数

An 只是一个强类型;它不是.C++11 只是重用了现有的关键字，以避免引入会破坏与旧版 C++ 代码兼容性的新关键字。enum classenumclassclass

至于你的问题，没有办法确保在编译时强制转换涉及适当的候选人。考虑：

int x;
std::cin >> x;
auto p = static_cast<PinID>(x);

这是完全合法的，没有办法静态地确保控制台用户做了正确的事情。

相反，您需要在运行时检查该值是否有效。为了以自动化的方式解决这个问题，我的一位同事创建了一个生成器，用于构建这些检查以及其他有用的例程，给定一个带有枚举值的文件。您将需要找到适合您的解决方案。enum

使用 或不是类定义的类型，而是作用域内枚举，并且不能定义默认构造函数。C++11 标准定义您的语句将给出零初始化。其中定义为 .它还允许枚举类型通常保存枚举器常量以外的值。enum classenum structPinID pid = PinID();PinIDenum class

要了解 PinID（） 给出零初始化，需要同时阅读标准部分 3.9.9、8.5.5、8.5.7 和 8.5.10：

8.5.10 - An object whose initializer is an empty set of parentheses, i.e., (), shall be value-initialized

8.5.7 - ...To value-initialize an object of type T means:otherwise, the object is zero-initialized.

8.5.5 - To zero-initialize an object or reference of type T means: — if T is a scalar type (3.9), the object is set to the value 0 (zero), taken as an integral constant expression, converted to T;

3.9.9 - 声明枚举类型是称为标量类型的类型集的一部分。

可能的解决方案：

为了满足第 1 点到第 5 点，您可以按照以下方式编写一个类：

class PinID
{
private:
    PinID(int val)
    : m_value(val)
    {}

    int m_value;

public:
    static const PinID N4;
    static const PinID N17;
    /* ...etc... */ 

    PinID() 
    : m_value(N4.getValue())
    {}

    PinID(const PinID &id)
    : m_value(id.getValue())
    {}

    PinID &operator = (const PinID &rhs)
    {
        m_value = rhs.getValue();
        return *this;
    }

    int getValue() const
    {
        return m_value;
    }

    // Attempts to create from int and throw on failure.
    static PinID createFromInt(int i);

    friend std::istream& operator>>(std::istream &is, PinID &v)
    {
        int candidateVal(0);
        is >> candidateVal;
        v = PinID::createFromInt(candidateVal);
        return is;
    }
};

const PinID PinID::N4 = PinID(4);
/* ...etc... */

这可以给你一些东西，你必须做出具体的努力才能获得无效的值。默认构造函数和流运算符应允许它与lexical_cast一起使用。

似乎这取决于 PinID 创建后对 PinID 的操作有多重要，是否值得编写类或只是在使用值时处理无处不在的无效值。

我知道这个问题已经过时了，并且已经有一个公认的答案，但这里有一种技术，在这种情况下可能会对 C++ 的一些新功能有所帮助

您可以声明此类的变量，也可以声明 ，它可以通过支持当前编译器所允许的多种方式来完成。non staticstatic

---

非静态：

#include <iostream>
#include <array>

template<unsigned... IDs>
class PinIDs {
private:
    const std::array<unsigned, sizeof...(IDs)> ids { IDs... };
public:
    PinIDs() = default;
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

---

静态： - 有 3 种方法可以写这个： （第一个 - C++ 11 或 14 或更高版本） 最后 2 个 （C++17）。

不要在 C++11 部分引用我的话;我不太确定可变参数模板或参数包是什么时候首次引入的。

template<unsigned... IDs>
class PinIDs{
private:        
    static const std::array<unsigned, sizeof...(IDs)> ids;
public:    
    PinIDs() = default;    
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

template<unsigned... IDs>
const std::array<unsigned, sizeof...(IDs)> PinIDs<IDs...>::ids { IDs... };

---

template<unsigned... IDs>
class PinIDs{
private:
    static constexpr std::array<unsigned, sizeof...(IDs)> ids { IDs... }; 
public:   
    PinIDs() = default;    
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

---

template<unsigned... IDs>
class PinIDs{
private:
    static inline const std::array<unsigned, sizeof...(IDs)> ids { IDs... };
public:    
    PinIDs() = default;    
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

---

上面的所有示例，无论是非静态的还是静态的，都适用于下面的相同用例，并提供正确的结果：

int main() {
    PinIDs<4, 17, 19> myId;

    std::cout << myId[0] << " ";
    std::cout << myId[1] << " ";
    std::cout << myId[2] << " ";

    std::cout << "\nPress any key and enter to quit." << std::endl;
    char c;
    std::cin >> c;

    return 0;
}

---

输出

4 17 19
Press any key and enter to quit.

---

使用可变参数列表的此类类模板，您不必使用任何构造函数，而使用默认值。我确实在数组中添加了边界检查，以便不会超过其大小的边界;我可以抛出一个错误，但对于类型，我只是简单地返回 -1 作为无效值。operator[]unsigned

对于这种类型，没有默认值，因为您必须通过模板参数列表使用单个或一组值实例化此类对象。如果需要，他们可以使用默认类型的单个参数。实例化此类对象时;它是最终的，因为它不能从其声明中更改。这是一个 const 对象，并且仍然是默认可构造的。specialize this class0