enumeration，将一组整型常量组织在一起。和类一样，是一种类类型，属于字面值常量类型。

两种类型：

  • 限定作用域的枚举（C++新标准引入）
  • 不限定作用域的枚举

这两种类型的区别，总的来说前者对类型匹配要求更高，可以使代码更规范，推荐使用限定作用域的枚举。

  2. enum class Fucker {     // 限定作用域，class可以换成struct等价。
  3.                         // 成员类型默认是int
  5.     fucker1,            // 默认从0开始，依次+1，即fucker1 = 0，fucker2 = 1
  6.     fucker2, 
  7.     fucker3 = 4,        // 显示指定值
  8.     fucker4,            // 值默认+1，即5
  10.     // 枚举成员是const的，初始值必须是constexpr表达式
  11.     // 可以作为switch语句的case标签。
  12.     // 可以作为非类型模板形参
  13.     // 可以作为类static成员的初始值
  14. };
  16. enum Fucker {            // 不限定作用域，成员作用域与枚举本身相同，名字Fucker可选。
  17.                         // 成员默认位置，只知道足够大
  18.     fucker1, 
  19.     fucker2, 
  20.     fucker3
  21. };
  23. enum {                    // 未命名的、不限定作用域的枚举类型
  24.     fucker1 = 6,
  25.     fucker2 = 10, 
  26.     fucker3 = 10
  27. };
  29. enum Fucker : unsigned long long{    // 指定成员类型为ull，成员值超出范围则报错。
  30.                                     // 指定类型可以增强可移植性
  31.     fucker1,
  32.     fucker2,
  33.     fucker3
  34. }
  36. // 枚举类型可前置声明，后面定义的时，必须精确匹配（是否限定作用域，成员默认类型）
  37. enum intValues : unsigned long long; // 不限定作用域的，必须指定成员类型
  38. enum class open_modes;                  // 限定作用域的枚举类型可以使用默认成员类型int
  40. enum color {red, yellow, green};             // 不限定作用域的枚举类型
  41. enum stoplight {red, yellow, green};         // 错误：重复定义了枚举成员
  42. enum class peppers {red, yellow , green};     // 正确：枚举成员被隐藏了
  44. color eyes = green;         // 正确：不限定作用域的枚举类型的枚举成员位于有效的作用域中
  45. peppers p  = green;         // 错误：peppers 的枚举成员不在有效的作用域中
  46. color hair = color::red;     // 正确：允许显式地访问枚举成员
  47. peppers p2 = peppers::red;  // 正确：使用 pappers 的 red
  49. color fucker = 2;            // 错误，2不是color类型枚举
  50. fucker = color::red;        // 正确，必须使用枚举成员或者其他枚举对象赋值。
  52. int i = color::red;         // 正确：不限定作用域的会隐式转换成int
  53. int j = peppers::red;         // 错误：限定作用域的不会进行隐式转换

形参匹配

  2. enum Fucker{
  3.     fucker1, 
  4.     fucker2, 
  5.     fucker3
  6. };
  8. void func(Fucker);
  9. void func(int);
  10. void mother(int);
  11. void mother(unsigned char);
  13. Fucker shit = fucker1;
  14. unsigned char bitch = fucker2;
  15. func(128);            // 精确匹配func(int)
  16. func(fucker2);        // 精确匹配func(Fucker)
  17. func(shit);            // 精确匹配func(Fucker)
  19. // 可以将一个不限定作用域的枚举类型的对象或枚举成员传给整型形参。
  20. mother(fucker2);    // 精确匹配mother(int)，类型提升
  21. mother(bitch);        // 精确匹配mother(unsigned char)