枚举

对于限定范围的枚举，将在枚举说明符的作用域中声明每个枚举符。 此外，作用域枚举不允许通过整数提升将枚举符 (或枚举类型的对象) 的值转换为整数，但允许显式强制转换为 int， char， float或任何其他标量类型。 例如：

enum class Colour { orange, green, purple };
enum class Fruit { apple, pear, grape, orange };

void functionx(int) {}
void functionx(Colour) {}
void functionx(Fruit) {}

int main()
{
  functionx(green);            // error, green is not introduced into
                               // the global scope
  functionx(Colour::green);    // calls functionx(Colour)
  functionx(Fruit::apple);     // calls functionx(Fruit)
  int i = Colour::orange;      // error, no conversion from Colour to int
  int j = (int)Colour::green;  // valid, explicit cast to integer is allowed
}

type_specifier 明确指定枚举的底层类型。 每个枚举都具有底层类型。 type_说明符 可以是任何整数类型。 请注意，枚举类型不是整数类型。 通过指定枚举的底层类型，可以确保程序正确性并在结构中可靠地使用枚举。 如果未指定 type_说明符 ，那么将按如下所示确定枚举的底层类型:

• 如果枚举具有作用域，那么底层类型具有固定类型 int。
• 如果枚举未限定范围，那么底层类型是可以表示枚举中定义的所有枚举符值的整数类型。

例如：

// the underlying type is "unsigned int"
enum Colour : unsigned int { orange = 0, green = 1, purple = 0x02U }; 

// the underlying type is "unsigned long"
enum class E : unsigned long { E1 = 0, E2 = 1, Emax = 0xFFFFFFF0U };

// if the type_specifier is not specified, the underlying type 
// is "int" for the scoped enumeration
enum class A { A1, A2, A3 = 100, A4 };

// the underlying type is an integer type enough to represent the given
// enumerator values, eg. [signed/unsigned] long long
enum A { A1, A2, A3 = 100000000000000000000, A4 };

nested_name_说明符 是指先前声明枚举的类或名称空间。 例如：

class C{

//Declaration of a scoped enumeration A. 
enum class A;            

};

// C is the nested_name_specifier that refers to the class where
// the enumeration A was declared.
enum class C::A { a, b };  

枚举的正向声明是当前范围内枚举的重新声明或新枚举的声明。 同一枚举的重新声明必须与先前声明匹配。 重新声明枚举的规则如下:

• 稍后不能将限定范围的枚举重新声明为未限定范围或具有其他底层类型。
• 以后不能将未限定范围的枚举重新声明为限定范围的枚举，并且每个重新声明都必须包含指定相同底层类型的 type_说明符 。

例如：

enum E1 : unsigned long;        // valid, forward declaration of an unscoped 
                                // enumeration with the underlying type 
                                // "unsigned long"

enum class E2 : char;           // valid, forward declaration of a scoped 
                                // enumeration with the underlying type 
                                // "char"

enum class E3;                  // valid, forward declaration of a scoped 
                                // enumeration with the implied underlying
                                // type "int" 

enum E4;                        // error, you must specify the underlying type
                                // when you forward declare an unscoped 
                                // enumeration 

enum E1 : unsigned long;        // valid, the redeclaration of E1 matches the
                                // previous declaration of E1

enum class E2 : short;          // error, the previously declared enumeration
                                // E2 had the underlying type "char", and it 
                                // cannot be redeclared with a different 
                                // underlying type

enum E3 : int;                  // error, the previously declared enumeration
                                // E3 was a scoped enumeration, and it cannot
                                // be redeclared as an unscoped enumeration

enum class E3 : int { a, b, c };// valid, definition of E3