本文翻译自《effective modern C++》,由于水平有限,故无法保证翻译完全正确,欢迎指出错误。谢谢!
一般情况下,在花括号中声明一个name(包括变量名,函数名),这个name的可见性会被限制在花括号的作用域内。对于在C++98风格的enum中声明的enum成员却不是这样。这些enum成员的name属于的作用域是enum所在作用域,这意味着在这个作用域中,不能拥有相同的name:
enum Color { black, white, red }; //black,white,red
//和Color在同一个作用域
auto white = false; //错误!white在这个
//作用域已经声明过了
所以事实上,这些enum成员name泄露到enum所在的作用域中去了,这导致官方对于这种enum给出了一个官方术语:unscoped。新的C++11中有一个与此相对应的版本:scoped enum,不会像这样让name泄露:
enum class Color { black, white, red }; //black,white red
//在Color作用域中
auto white = false; //好的,没其他white
Color c = white; //错误!在这个作用域中没有
//一个叫“white”的enum成员
Color c = Color::white; //对的
auto c = Color::white; //也是对的(而且和Item 5的建议一样)
因为scoped enum通过“enum class”声明,它们有时候也被叫做enum类。
单是减少命名空间的污染就足够作为理由让我们更偏爱scoped enum了,但是scoped enum还有第二个压倒性的优点:它们的成员属于强类型。unscoped enum的成员能隐式转换到数值类型(然后,从数值类型,可以转换到浮点类型)。因此像下面这样,在语义上是扭曲的代码是完全有效的:
enum Color { black, white, red}; //unscoped enum
std::vector<std::size_t> //函数,返回x的素因数
primeFactors(std::size_t x);
Color c = red;
...
if(c < 14.5) { //把Color和double数比较(!)
auto factors = //计算Color的素因数(!)
primeFactors(c);
...
}
然而,在”enum“后面添加一个简单的”class“,就能把unscoped enum转变为scoped enum,并且情况会发生很大的改变。这里没有从enum的成员到任何其它类型的隐式转换:
enum class Color { black, white, red }; //scoped
Color c = Color::red;
...
if (c < 14.5) { //错误,不能把Color和double
//数进行比较
auto factors = //错误,函数需要一个std::size_t
primeFactors(c); //不能传一个Color进去
...
}
如果你真的想要把Color转换到不同的类型,你需要做的就是:使用cast把Color转换成你需要的类型:
if(static_cast<double>(c) < 14.5) { //奇怪的代码,但是有效
auto factors = //可疑的,但是能通过编译
primeFactors(static_cast<std::size_t>(c));
...
}
比起unscoped enum,scoped enum看起来还有第三个优点,因为scoped enum可以前置声明。也就是,他们的name可以在声明的时候不定义(不明确它们的成员):
enum Color; //错误
enum class Color; //对的
这是一个误导。在C++11中,unscoped enum也能前置声明,但是需要做一些额外的工作。这个工作源于一个事实,就是C++中的每个enum都有一个整形的基础类型,这个类型由编译器决定。对于一个unscoped enum,比如Color:
enum Color { black, white, red };
编译器可能选择char来作为基础类型,因为这里只有三个值需要表示。然而,一些enum值的范围会大很多,比如:
enum Status { good = 0,
failed = 1,
incoplete = 100,
corrupt = 200.
indeterminate = 0xFFFFFFFF
};
这里enum值需要表示的范围从0到0xFFFFFFFF。除了一些不寻常的机器(在这些机器中,一个char至少由32bits组成),编译器就必须选择一个大于char的整形类型来表示Status的值。
为了内存的高效利用,只要一个基础类型能成功表示enum中的成员的值的范围,编译器常常会选择这个最小的基础类型,。一些情况下,比起大小,编译器会优先考虑速度,在这种情况下,它们不一定会选择最小的基础类型,但是它们肯定也会在考虑速度的优化后,考虑大小的优化。为了实现这一点,C++98只支持定义(所有的enum成员必须列出来);enum的声明是不被允许的。这样,编译器才能在每个enum使用前,给每个enum选择一个基础类型。
但是“不能前置声明enum”是有缺点的。最需要注意的是,它可能会增加编译依赖性。再次考虑Status enum:
enum Status { good = 0,
failed = 1,
incomplete = 100,
corrupt = 200,
indeterminate = 0xFFFFFFFF
};
这个enum可能需要在某个系统中使用,因此它被包含在头文件中,然后系统的每个部分都需要依赖它。如果一个新的status值被添加进来,
enum Status { good = 0,
failed = 1,
incomplete = 100,
corrupt = 200,
audited = 500,
indeterminate = 0xFFFFFFFF
};
这样很有可能整个系统都需要重新编译,甚至如果只是一个简单的子系统(更甚一个简单的函数)使用了这个enum。这是被人们所讨厌的。这也是在C++11中,enum前置声明消除的事(编译依赖性)。举个例子,这里有一个scoped enum的声明,它是完美有效的。并且一个函数用它作为一个参数:
enum class Status; //前置声明
void continueProcessing(Status s); //使用声明过的enum
如果Status的定义修改了,并且头文件只包含这些声明就不需要重新编译。此外,如果Status修改了(比如,加了一个audited成员),但是continueProcessing的行为没受到影响(比如,因为continueProcessing没有使用audited),continueProcessing的实现也不需要重新编译。
但是如果编译器需要在一个enum使用前知道它的大小,C++11的enum怎么就能使用前置声明而C++98的enum却不行?回答很简单:scoped enum的基础类型总是不变的,并且对于一个unscoped enum,你也能明确它的基础类型。
通常情况下,一个scoped enum的基础类型是int:
enum class Status; //基础类型是int
如果默认的情况不适合你,你可以自己设置:
enum class Status: std::uint32_t; //Status的基础类型是
//std::uint32_t
不管怎么样,编译器都知道scoped enum的大小。
为了明确一个unscoped enum的基础类型,你需要做和scoped enum同样的事,这样就能做到前置声明了:
enum Color: std::uint8_t; //unscoped enum的前置声明
//基础类型是std::uint8_t
基础类型也可以在enum定义的时候明确:
enum class Status: std::uint32_t { good = 0,
failed = 1,
incomplete = 100,
corrupt = 200,
audited = 500,
indeterminate = 0xFFFFFFFF
};
基于scoped enum能避免命名空间的污染,不会进行无意义的隐式类型转换的事实,这可能让你感到奇怪:这里起码有一种情况,unscoped enum比起scoped enum会更有用一些。 比如我们在使用C++11的std::tuple的字段时。举个例子,假设对于一个社交网站的用户,我们想设计一个tuple持有name,email地址,reputation值:
using UserInfo =
std::tuple<std::string, //name
std::string, //email
std::size_t> ; //reputation
只通过注释标明每个字段,那么在碰到分离的源文件时,注释将没有作用:
UserInfo uInfo; //tuple类型的对象
...
auto val = std::get<1>(uInfo); //取字段1的值
作为一个程序员,你有很多方式来记录它。你真的能记住字段1代表的是用户的email地址吗?我想不是这样的。使用一个unscoped enum把名字关联到字段中去:
enum UserInfoFields { uiName, uiEmail, uiReputation };
UserInfo uInfo;
...
auto val = std::get<uiEmail>(uInfo); //获得email字段的值
要让这起作用,必须要有从UserInfoFields到std::size_t(std::get需要的类型)的隐式转换。
用scoped enum实现的相应的代码会变得很繁琐:
enum class UserInfoFields { uiName, uiEmail, uiReputation };
UserInfo uInfo;
...
auto val =
std::get<static_cast<std::size_t>(UserInfoFields::uiEmail)>(uinfo);
繁琐的情况可以通过写一个函数(传入一个enum成员,返回相应的std::size_t值)来减少,但是这里有点微妙。std::get是一个template,并且你提供的值是template参数(注意使用尖括号,不是圆括号),所以转换函数(enum成员到std::size_t)必须在编译期产生结果。就像Item 15解释的,这意味着它必须是constexpr函数。
事实上,它应该是constexpr函数template,因为它应该能在任何enum下工作。并且如果我们让它继续泛化,我们应该把返回类型也泛化掉。比起返回一个std::size_t,我们需要返回enum的基础类型。通过std::underlying_type能做到这一点。(看Item 9中的type traits信息)最后,我们声明它为noexcept(看Item 14),因为我们知道它不会产生任何异常。最后会产生一个编译期const函数template toUType,它需要一个任意类型的enum成员,并且返回它的值(类型是基础类型):
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中,通过用强大的std::underlying_type_t(看Item 9)来替换typename std::underlying_type
template<typename E> // C++14
constexpr std::underlying_type_t<E>
toUType(E enumerator) noexcept
{
return static_cast<std::underlying_type_t<E>>(enumerator);
}
在C++14中,更强大的auto返回类型(看Item 3)也同样有效:
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,这里还是要写很多东西,但是它也避免了命名空间的污染,和你没有意识到的转换。在很多情况下,比起它的陷阱,你可能觉得多写几个字是合理(但是追溯到很久以前我们的数字通信还在用2400波特的调制解调器时,情况会不一样)。
你要记住的事
- C++98风格的enum被称为 unscoped enum
- scoped enum的成员只在enum中可见,它们只有在使用cast时才能转换到其它类型。
- scoped 和unscopedenum都支持自定义基础类型。scoped enum的默认基础类型是int。unscoped enum没有默认基础类型。
- scoped enum一直能前置声明,unscoped enum只有在明确基础类型的情况下才能前置声明。