C++11 之 scoped enum

企鹅博客
企鹅博客
企鹅博客
25193
文章
0
评论
2020年8月31日01:36:37 评论 29 views

C++11 枚举类型是“域化的” (scoped enum),相比 C++98 枚举类型的“非域化” (unscoped enum),具有如下优点:

1  命名空间污染 

  一般来说,声明在花括号内的名字,其可见性限制在由花括号定义的作用域内,但是非域化枚举 (unscoped enum) 却是例外

enum Color { black, white, red }; // black, white, red are in same scope as Color

auto white = false; // error! white already declared in this scope

    C++11 域化枚举 (scoped enum),关键字为 enum class,可视为一个 "class",故能防止“命名空间污染” (namespace pollution)

 

enum class Color { black, white, red }; // black, white, red are scoped to Color

auto white = false; // fine, no other "white" in scope

Color c = white; // error! no enumerator named "white" is in this scope

Color c = Color::white; // fine

auto c = Color::white; // also fine

2  强类型枚举

  非域化的枚举成员,可以隐式的转换为广义整型 (integral types),如下所示:

enum Color { black, white, red }; // unscoped enum
std::vector<std::size_t> primeFactors(std::size_t x); // func. 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 (!)
    …
}

  域化的枚举成员,却不可以隐式的转换为广义整型

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 = primeFactors(c); // error! can't pass Color to function expecting std::size_t 
    …
}

  正确的方式是使用 C++ 的类型转换符 (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
    …
}

3  前置声明

  域化枚举支持前置声明 (forward-declared),也即可以不用初始化枚举成员而声明一个枚举类型

enum class Color;

3.1 新增枚举成员

  非域化枚举(unscoped enum) 在声明时,编译器会选择占用内存最小的一种潜在类型 (underlying types),来代表每一个枚举成员

enum Color { black, white, red };  // compiler may choose char type

  下面的例子中,编译器可能会选择更大的能够包含 0 ~ 0xFFFFFFFF 范围的潜在类型

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

  非前置声明的缺点在于,当增加一个新的枚举成员时 (如下例的 audited ),整个系统将会被重新编译一遍,即使只有一个很简单的函数使用了新的枚举成员 (audited)

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

  而使用前置声明,当新增枚举成员时,包含这些声明的头文件并不需要重新编译,源文件则根据新枚举成员的使用情况来决定是否重新编译

  如下例,Status 中新增枚举成员 audited,如果函数 continuteProcesing 没有使用 audited,则函数 continuteProcesing 的实现并不需要重新编译

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

3.2 潜在类型

  域化枚举的潜在类型 (underlying type),缺省为 int 型,当然也可以自行定义潜在类型。不管哪种方式,编译器都会预先知道枚举成员的大小

enum class Status; // underlying type is int

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

enum class Status: std::uint32_t  // specify underlying type on enum's definition
{ good
= 0, failed = 1, incomplete = 100, corrupt = 200, audited = 500, indeterminate = 0xFFFFFFFF }; 

4  std::tuple

  一般而言,使用 C++11 域化枚举 (scoped enum) 是比较好的选择,但 C++98 非域化枚举 (unscoped enum) 也并非一无是处

4.1  非域化枚举

  当涉及到 std::tuple 时,使用 C++98 非域化枚举反而会有优势,如下例所示

  假定一个社交网站中,每一位用户,都使用一种模板类型 - 元组 (tuple) 来包含名字、邮箱、声望值 (name, email, reputation value)

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

  当以下代码在另一个不同的源文件里时 (source file),很有可能忘了元组 (tuple) 的第一个成员到底是名字还是邮箱 (name or email)

UserInfo uInfo; // object of tuple type
 ...

auto val = std::get<1>(uInfo); // get value of field 1

  但是,使用非域化枚举 (unscoped enum),可以不用担心忘记了元组内的成员顺序

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

4.2  域化枚举 

  上例中,假如使用域化枚举 (scoped enum),则会用到类型转换,看起来比较繁琐

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

  可以使用一个模板函数,将枚举成员 UserInfoFields::uiEmail 和 std::size_t 类型联系起来

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

 这样,便可以稍微缩减了代码的复杂度。但是相比于非域化枚举,看起来还是有些繁琐

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

小结:

1)  C++98 枚举类型是“非域化的”;而C++11 枚举类型是“域化的”,枚举成员只在域内可见

2)  域化枚举的缺省潜在类型 (underlying type) 是 int 型,而非域化枚举没有缺省潜在类型

3)  域化枚举一般总是前置声明,而非域化枚举只有在指定了潜在类型时才可以是前置声明

参考资料:

继续阅读
企鹅博客
  • 本文由 发表于 2020年8月31日01:36:37
  • 转载请务必保留本文链接:https://www.qieseo.com/133585.html
Android短信应用——短信信息实时获取 Linux编程

Android短信应用——短信信息实时获取

我们知道,只需通过代码就可以读到收件箱中的短信,发件箱中的短信;但是却没办法在短信发来的瞬间获取;如果我们在短信发来的一瞬间能得到相应的信息内容,那么我们就可以依次来展开很多应用了——也就是通过短信去...
LRU缓存设计 Linux编程

LRU缓存设计

缓存的数据结构采用哈希表,key到value的映射。 网上有些资料采用记录数据的使用时刻 实现LRU策略,此处采用双向链表 实现LRU策略。LRU Least Recently Used,MRUMos...
R 语言 简单介绍 Linux编程

R 语言 简单介绍

一.统计分析软件说明  统计分析软件有:SPSS, SAS、R语言,Matlab,S-PLUS,S-Miner。 SPSS: 最简单的,都是菜单操作,不过不利于二次程序开发。 SAS: 需要...
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: