10.以scoped enums代替unscoped enums

unscoped enum与命名空间污染

 
通常，在大括号内声明某名称会导致该名称可见性仅限于大括号范围之内，但对于C++98中的枚举类型来说并非如此。这些枚举变量名的作用域等价于枚举所存在的作用域，因此直接导致别的变量再也无法使用这些名字：

enum Color { black, white, red }; // black, white, red are in same scope as Color
auto white = false; // error! white already declared in this scope

这种污染命名空间的行为被定义为：unscoped。C++11对此提出了解决方案scoped enums：

enum class Color { black, white, red }; // black, white, red are scoped to Color
auto white = false; // fine, no other
Color c = white; // error! no enumerator named "white" is in this scope
Color c = Color::white; // fine
auto c = Color::white; // also fine (and in accord with Item 5's advice)

这种技法亦被称为enum classes。

---

scoped的强类型保证

 
scoped enum除了不会污染命名空间之外还具备一大优势：其成员均为强类型枚举量。unsoped enum的成员总是可以被隐式转换为int型（并可以藉由此转为浮点型），例如下文的转换是完全有效的：

enum Color { black, white, red }; // unscoped enum
std::vector<std::size_t> primeFactors(std::size_t x); // returning prime factors of x
Color c = red;
…
if (c < 14.5) { // compare Color to double (!)
    auto factors = primeFactors(c);//compute prime factors of a color
    …
}

如果将其转变为scoped enum，上述问题都将不复存在：

enum class Color { black, white, red }; // enum is now scoped
Color c = Color::red; // as before, but with scope qualifier
if (c < 14.5) { // error! can't compare Color and double
    auto factors = // error! can't pass Color to
    primeFactors(c); // function expecting std::size_t
    …
}

如果你非要进行转换也不是不可以，只要你使用static_cast:

if (static_cast<double>(c) < 14.5) { // odd code, but it's valid
    auto factors = primeFactors(static_cast<std::size_t>(c)); // // suspect, but it compiles
    …
}

---

forward—declartion

 
scoped enum似乎还有一大优点在于可以完成forward—declartion,即可以在不具备定义的情况下直接声明枚举类型：

enum Color; // error!
enum class Color; // fine

但事实并非如此。在C++11中，unscoped enum亦可完成forward—declartion，但是需要一点点额外的工作。由于在C++语言中每一个枚举量都具备一个由编译器决定的整形底层类型，对于下述这个枚举量：

enum Color { black, white, red };

编译器可能会选择char作为其底层类型，因为只有三个值可以表示。但也有可能会出现枚举值范围很大的情况：

enum Status { good = 0,failed = 1,incomplete = 100,corrupt = 200,indeterminate = 0xFFFFFFFF};

此时编译器将会选择一个大于char的类型作为底层类型。

为了保证高效使用内存，编译器通常会选择最合适（最小）的数据类型作为底层类型。但在某些情况下，编译器会倾向于在保证速度的前提下使用较小内存。为了保证这种实现的可行性，C++98仅支持枚举定义而不支持枚举声明，这一特性使得编译器可以在使用枚举之前为每个枚举选择底层类型。

无法forward—declartion存在一定的缺陷，其中最显著的缺陷即在于编译依存性被显著提升。仍以Status enum为例：

enum Status { good = 0,failed = 1,incomplete = 100,corrupt = 200,indeterminate = 0xFFFFFFFF};

如果该枚举被定义于某个头文件中并且被#include多次，那么如果我们想要向其中增加一个新的状态，整个系统都需要被重新编译。C++11修复了这个问题，例如以下则是一个枚举声明以及将枚举类型作为参数的函数：

enum class Status; // forward declaration
void continueProcessing(Status s); // use of fwd-declared enum

如果Status的定义发生了改变，那么包含这个声明的头文件无需重新编译。此外，只要continueProcessing保持行为一致，continueProcessing的实现亦不需要重新编译。

---

手动指定enum底层类型

 
如果编译器需要在使用enum前了解其大小，C++11是如何做到完成forward—declartion的？答案十分简单：scoped enum的底层类型总是已知的，而unscoped enum则可以手动指定。

在默认情况下，scoped enum的底层类型是int：

enum class Status; // underlying type is int

当然你也可以手动地指定其类型：

enum class Status: std::uint32_t; // underlying type for is std::uint32_t(from <cstdint>)

无论如何，编译器总是在声明时即明确了scoped enum的底层类型。

unscoped enum也可以这样操作：

enum Color: std::uint8_t; // fwd decl for unscoped enum;

甚至我们还可以在定义时指定其底层类型：

enum class Status: std::uint32_t { good = 0,
                                   failed = 1,
                                   incomplete = 100,
                                   corrupt = 200,
                                   audited = 500,
                                   indeterminate = 0xFFFFFFFF
};

---

unscoped enum的可取之处

 
scoped enum可以避免污染命名空间，并且不易受到无意义隐式类型转换的影响，但它并非毫无可取之处：在C++11的std::tuple中起到了一定的作用。举例而言，我们现有一个tuple，它持有社交网站用户的姓名、电子邮件地址与信誉值：

using UserInfo = std::tuple<std::string,std::string,std::size_t>;// type alias;

作为一名开发者，我们需要关注很多东西，但这其中可能并不包括记住tuple的字段1对应着用户email。使用unscoped enum可以将名称与字段号关联，从此不必费心记忆：

enum UserInfoFields { uiName, uiEmail, uiReputation };
UserInfo uInfo; // as before
…
auto val = std::get<uiEmail>(uInfo); // ah, get value of email field

通过隐式类型转换，我们将enum变为了std::get所需要的类型。如果你坚持使用scoped enum，那么效果可能会非常惨烈：

enum class UserInfoFields { uiName, uiEmail, uiReputation };
UserInfo uInfo; // as before
…
auto val = std::get<static_cast<std::size_t>(UserInfoFields::uiEmail)>(uInfo);

当然，我们也可以编写一个形参为eunm且返回值为std::size_t的函数来降低语句复杂程度，但这稍微有点麻烦。std::get是一个模板，因此你所需要提供的值是一个模板参数（必须在编译期确定），那也就是说，该函数必须是一个constexpr函数。
实际上光是constexpr函数还不够，这个转换必须得是一个constexpr函数模板，因为它必须能够支持所有类型的enum，同样地，我们也需要对返回值进行泛型化处理。在泛型设计中我们将不再返回std::size_t，而是返回enum的底层类型（该操作通过std::underlying_type实现)。最后，我们将其声明为noexcept，因为它永远不会抛出异常，最终转换函数实现如下所示：

template<typename E>
constexpr typename std::underlying_type<E>::type
toUType(E enumerator) noexcept{
    return static_cast<typename std::underlying_type<E>::type>(enumerator);
}

在C++14中，toUType可以简化为：

template<typename E> // C++14
constexpr std::underlying_type_t<E>
toUType(E enumerator) noexcept{
    return static_cast<std::underlying_type_t<E>>(enumerator);
}

当然我们也可以通过使用auto来更进一步地简化它：

template<typename E> // C++14
constexpr auto toUType(E enumerator) noexcept{
    return static_cast<std::underlying_type_t<E>>(enumerator);
}

在具备了toUType后，tuple的使用如下所示：

auto val = std::get<toUType(UserInfoFields::uiEmail)>(uInfo);

看起来还是比使用unscoped enum麻烦多了，但至少它避免了命名空间污染与无意义的转换，这二者的破坏力都十分巨大，因此最好还是心甘情愿地多写几个字符吧。

---

总结

 

1. C++98中的enum被称为unscoped enum。
2. scoped enum不会污染命名空间，仅在cast下才能完成转换。
3. scoped enum 与 unscoped enum都支持底层类型指定，scoped enum默认为int类型。
4. scoped enum支持forward declaration，unscoped enum需要指定其底层类型方可。