我正在浏览 C++ 标准 n4713.pdf。考虑以下代码:

#include <iostream>
#include <type_traits>

enum UEn
{
    EN_0,
    EN_1,
    EN_L = 0x7FFFFFFFFFFFFFFF            // EN_L has type "long int"
};                                       // UEn has underlying type "unsigned long int"

int main()
{
    long lng = 0x7FFFFFFFFFFFFFFF;

    std::cout << std::boolalpha;
    std::cout << "typeof(unsigned long == UEn):" << std::is_same<unsigned long, std::underlying_type<UEn>::type>::value << std::endl;  // Outputs "true"
    std::cout << "sizeof(EN_L):" << sizeof(EN_L) << std::endl;
    std::cout << "sizeof(unsigned):" << sizeof(unsigned) << std::endl;
    std::cout << "sizeof(unsigned long):" << sizeof(unsigned long) << std::endl;
    std::cout << "sizeof(unsigned long):" << sizeof(unsigned long long) << std::endl;

    lng = EN_L + 1;                      // Invokes UB as EN_L is 0x7FFFFFFFFFFFFFFF and has type "long int"

    return 0;
}

以上代码输出(在g++-8.1, Clang上测试):

typeof(unsigned long == UEn):true sizeof(EN_L):8 sizeof(unsigned):4 sizeof(unsigned long):8 sizeof(unsigned long):8

根据第 10.2p5 节(10.2 枚举声明):

Following the closing brace of an enum-specifier, each enumerator has the type of its enumeration...If the underlying type is not fixed, the type of each enumerator prior to the closing brace is determined as follows:

• If an initializer is specified for an enumerator, the constant-expression shall be an integral constant expression (8.6). If the expression has unscoped enumeration type, the enumerator has the underlying type of that enumeration type, otherwise it has the same type as the expression.

• If no initializer is specified for the first enumerator, its type is an unspecified signed integral type.

• Otherwise the type of the enumerator is the same as that of the preceding enumerator unless the incremented value is not representable in that type, in which case the type is an unspecified integral type sufficient to contain the incremented value. If no such type exists, the program is ill-formed.

此外，第 10.2p7 节指出:

For an enumeration whose underlying type is not fixed, the underlying type is an integral type that can represent all the enumerator values defined in the enumeration. If no integral type can represent all the enumerator values, the enumeration is ill-formed. It is implementation-defined which integral type is used as the underlying type except that the underlying type shall not be larger than int unless the value of an enumerator cannot fit in an int or unsigned int.

因此我有以下问题:

1. 为什么枚举的底层类型是UEn一个unsigned long什么时候0x7FFFFFFFFFFFFFFF是 long int 类型的整型常量因此类型为 EN_L也是long int .这是编译器错误还是明确定义的行为？
2. 当标准说 each enumerator has the type of its enumeration ，难道不是暗示枚举数和枚举的整数类型也要匹配吗？这两者彼此不同的原因可能是什么？

最佳答案

底层类型是实现定义的。它只需要能够表示每个枚举器，并且不能大于 int 除非需要。根据 dcl.enum.7，对签名没有要求(除了基本类型必须能够代表每个枚举器) ，正如您已经发现的那样。这比您想象的更能限制枚举器类型的反向传播。值得注意的是，它没有在任何地方说明枚举的基类型必须是任何枚举器的初始值设定项的类型。

Clang 更喜欢无符号整数作为枚举基数而不是有符号整数；这里的所有都是它的。重要的是，枚举的类型不必匹配任何特定枚举器的类型:它只需要能够代表每个枚举器。这在其他情况下是相当正常且易于理解的。例如，如果您有 EN_1 = 1，您不会对枚举的基类型不是 int 或 unsigned int 感到惊讶，即使 1 是 int。

你说 0x7fffffffffffffff 的类型是 long 也是正确的。 Clang 同意你的看法，但是它 implicitly casts the constant to unsigned long :

TranslationUnitDecl
`-EnumDecl <line:1:1, line:5:1> line:1:6 Foo
  |-EnumConstantDecl <line:2:5> col:5 Frob 'Foo'
  |-EnumConstantDecl <line:3:5> col:5 Bar 'Foo'
  `-EnumConstantDecl <line:4:5, col:11> col:5 Baz 'Foo'
    `-ImplicitCastExpr <col:11> 'unsigned long' <IntegralCast>
      `-IntegerLiteral <col:11> 'long' 576460752303423487

这是允许的，因为正如我们之前所说，枚举的基类型不需要是任何枚举器的逐字类型。

当标准说每个枚举器都有枚举的类型时，这意味着 EN_1 的类型是枚举右括号后的 enum UEn。请注意“在右大括号之后”和“在右大括号之前”的提及。

在右大括号之前，如果枚举没有固定类型，那么每个枚举器的类型都是它的初始化表达式类型，但这只是暂时的。例如，这允许您在不强制转换 EN_1 的情况下编写 EN_2 = EN_1 + 1，即使在 enum class 的范围内也是如此。在右大括号之后不再如此。您可以通过检查错误消息或查看反汇编来欺骗编译器向您显示:

template<typename T>
T tell_me(const T&& value);

enum Foo {
    Baz = 0x7ffffffffffffff,
    Frob = tell_me(Baz)
    // non-constexpr function 'tell_me<long>' cannot be used in a constant expression
};

请注意，在这种情况下，T 被推断为 long，但在右大括号之后，它被推断为 Foo:

template<typename T>
T tell_me(const T&& value);

enum Foo {
    Baz = 0x7ffffffffffffff
};

int main() {
    tell_me(Baz);
    // call    Foo tell_me<Foo>(Foo const&&)
}

如果您希望使用 Clang 对您的枚举类型进行签名，您需要使用 : base_type 语法指定它，或者您需要一个负枚举器。

关于c++ - C++ 中的无范围枚举、枚举器和底层类型歧义，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54295922/