PROSAGA码农传奇-硬件Safety-为什么枚举类优于普通枚举？

0# 哎？小查查 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  
    C ++有两种
     <code>
 enum
 </code>
    ：
  
  <OL>
    <LI>
       <code>
 enum class
 </code>
      ES
    </LI>
    <LI>
      川
       <code>
 enum
 </code>
      小号
    </LI>
  </醇>
  
    以下是如何声明它们的几个示例：
  
   <pre>
 <code>
 enum class Color { red, green, blue }; // enum class
 enum Animal { dog, cat, bird, human }; // plain enum

</code>
 </pre>
  
    的
      两个有什么区别？
    </强>
  
  <UL>
    <LI>
      
         <code>
 enum class
 </code>
        es - 枚举器名称是
        的
          本地
        </强>
         对于枚举和他们的价值观
        
          不
        
         隐式转换为其他类型（如另一种类型）
         <code>
 enum
 </code>
         要么
         <code>
 int
 </code>
        ）
      
    </LI>
    <LI>
      
        川
         <code>
 enum
 </code>
        s - 枚举器名称与枚举及其对应的范围相同
值隐式转换为整数和其他类型
      
    </LI>
  </UL>
  
    例：
  
   <pre>
 <code>
 enum Color { red, green, blue }; // plain enum 
enum Card { red_card, green_card, yellow_card }; // another plain enum 
enum class Animal { dog, deer, cat, bird, human }; // enum class
enum class Mammal { kangaroo, deer, human }; // another enum class

void fun() {

// examples of bad use of plain enums:
    Color color = Color::red;
    Card card = Card::green_card;

int num = color;    // no problem

if (color == Card::red_card) // no problem (bad)
 cout << "bad" << endl;

if (card == Color::green) // no problem (bad)
 cout << "bad" << endl;

// examples of good use of enum classes (safe)
    Animal a = Animal::deer;
    Mammal m = Mammal::deer;

int num2 = a; // error
 if (m == a) // error (good)
 cout << "bad" << endl;

if (a == Mammal::deer) // error (good)
 cout << "bad" << endl;

}

</code>
 </pre>
  <H2>
    结论：
  </H2>
  
     <code>
 enum class
 </code>
    es应该是首选，因为它们可以减少可能导致错误的意外。
  
</DIV>

1# 冷月如霜·胡狼 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  
    <a href="http://www.stroustrup.com/C++11FAQ.html#enum" rel="nofollow noreferrer">
      C ++ 11常见问题解答
    </A>
     提到以下几点：
  
  
    的
      常规枚举隐式转换为int，当有人不希望枚举充当整数时会导致错误。
    </强>
  
   <pre>
 <code>
 enum color
{
 Red,
 Green,
 Yellow
};

enum class NewColor
{
    Red_1,
    Green_1,
    Yellow_1
};

int main()
{
    //! Implicit conversion is possible
    int i = Red;

//! Need enum class name followed by access specifier. Ex: NewColor::Red_1
    int j = Red_1; // error C2065: 'Red_1': undeclared identifier

//! Implicit converison is not possible. Solution Ex: int k = (int)NewColor::Red_1;
    int k = NewColor::Red_1; // error C2440: 'initializing': cannot convert from 'NewColor' to 'int'

return 0;
}

</code>
 </pre>
  
    的
      常规枚举将其枚举器导出到周围的范围，导致名称冲突。
    </强>
  
   <pre>
 <code>
 // Header.h

enum vehicle
{
    Car,
    Bus,
    Bike,
    Autorickshow
};

enum FourWheeler
{
    Car,        // error C2365: 'Car': redefinition; previous definition was 'enumerator'
    SmallBus
};

enum class Editor
{
    vim,
    eclipes,
    VisualStudio
};

enum class CppEditor
{
    eclipes,       // No error of redefinitions
    VisualStudio,  // No error of redefinitions
    QtCreator
};

</code>
 </pre>
  
    的
      无法指定枚举的基础类型，从而导致混淆，兼容性问题，并且无法进行前向声明。
    </强>
  
   <pre>
 <code>
 // Header1.h
#include <iostream>

using namespace std;

enum class Port : unsigned char; // Forward declare

class MyClass
{
public:
    void PrintPort(enum class Port p);
};

void MyClass::PrintPort(enum class Port p)
{
 cout << (int)p << endl;
}

</code>
 </pre>
  
    。
  
   <pre>
 <code>
 // Header.h
enum class Port : unsigned char // Declare enum type explicitly
{
 PORT_1 = 0x01,
 PORT_2 = 0x02,
 PORT_3 = 0x04
};

</code>
 </pre>
  
    。
  
   <pre>
 <code>
 // Source.cpp
#include "Header1.h"
#include "Header.h"

using namespace std;
int main()
{
    MyClass m;
    m.PrintPort(Port::PORT_1);

return 0;
}

</code>
 </pre>
</DIV>

2# 一瓶泡沫 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  
    从
    <a href="http://www.stroustrup.com/C++11FAQ.html#enum" rel="noreferrer">
      Bjarne Stroustrup的C ++ 11常见问题解答
    </A>
    ：
  
  <BLOCKQUOTE>
    
      该
       <code>
 enum class
 </code>
      es（“new enums”，“strong enums”）解决了三个问题
  使用传统的C ++枚举：
    
    <UL>
      <LI>
        常规枚举隐式转换为int，当有人不希望枚举充当整数时会导致错误。
      </LI>
      <LI>
        常规枚举将其枚举器导出到周围的范围，导致名称冲突。
      </LI>
      <LI>
        一个基础类型
         <code>
 enum
 </code>
         无法指定，造成混淆，兼容性问题，并作出前瞻性声明
  不可能。
      </LI>
    </UL>
    
      新的枚举是“枚举类”，因为它们将传统枚举（名称值）的各个方面与类的方面（作用域成员和缺少转换）结合起来。
    
  </BLOCKQUOTE>
  
    因此，正如其他用户所提到的，“强大的枚举”会使代码更安全。
  
  
    “经典”的基本类型
     <code>
 enum
 </code>
     应该是一个足够大的整数类型，以适应所有的值
     <code>
 enum
 </code>
    ;这通常是一个
     <code>
 int
 </code>
    。每个枚举类型也应兼容
     <code>
 char
 </code>
     或有符号/无符号整数类型。
  
  
    这是对什么的广泛描述
     <code>
 enum
 </code>
     底层类型必须是，因此每个编译器将自己决定经典的基础类型
     <code>
 enum
 </code>
     有时结果可能会令人惊讶。
  
  
    例如，我已经看过这样的代码了很多次：
  
   <pre>
 <code>
 enum E_MY_FAVOURITE_FRUITS
{
 E_APPLE = 0x01,
 E_WATERMELON = 0x02,
 E_COCONUT = 0x04,
 E_STRAWBERRY = 0x08,
 E_CHERRY = 0x10,
 E_PINEAPPLE = 0x20,
 E_BANANA = 0x40,
 E_MANGO = 0x80,
 E_MY_FAVOURITE_FRUITS_FORCE8 = 0xFF // 'Force' 8bits, how can you tell?
};

</code>
 </pre>
  
    在上面的代码中，一些天真的编码器认为编译器会存储
     <code>
 E_MY_FAVOURITE_FRUITS
 </code>
     值为无符号8位类型...但不保证它：编译器可以选择
     <code>
 unsigned char
 </code>
     要么
     <code>
 int
 </code>
     要么
     <code>
 short
 </code>
    ，这些类型中的任何一种都足够大，以适应所见的所有值
     <code>
 enum
 </code>
    。添加字段
     <code>
 E_MY_FAVOURITE_FRUITS_FORCE8
 </code>
     是一种负担，并不会强迫编译器对基础类型做出任何选择
     <code>
 enum
 </code>
    。
  
  
    如果有一些代码依赖于类型大小和/或假设
     <code>
 E_MY_FAVOURITE_FRUITS
 </code>
     将具有某种宽度（例如：序列化例程），这些代码可能会以一些奇怪的方式表现，具体取决于编译器的想法。
  
  
    更糟糕的是，如果一些同事不经意地为我们的人增加了新的价值
     <code>
 enum
 </code>
    ：
  
   <pre>
 <code>
 E_DEVIL_FRUIT = 0x100, // New fruit, with value greater than 8bits

</code>
 </pre>
  
    编译器不会抱怨它！它只是调整类型的大小以适应所有的值
     <code>
 enum
 </code>
     （假设编译器使用的是最小的类型，这是我们不能做的假设）。这种简单而粗心的补充
     <code>
 enum
 </code>
     可能会细微地打破相关代码。
  
  
    由于C ++ 11可以指定基础类型
     <code>
 enum
 </code>
     和
     <code>
 enum class
 </code>
     （谢谢
    <a href="https://stackoverflow.com/users/2135754/rdb">
      RDB
    </A>
    所以这个问题得到了很好的解决：
  
   <pre>
 <code>
 enum class E_MY_FAVOURITE_FRUITS : unsigned char
{
 E_APPLE = 0x01,
 E_WATERMELON = 0x02,
 E_COCONUT = 0x04,
 E_STRAWBERRY = 0x08,
 E_CHERRY = 0x10,
 E_PINEAPPLE = 0x20,
 E_BANANA = 0x40,
 E_MANGO = 0x80,
 E_DEVIL_FRUIT = 0x100, // Warning!: constant value truncated
};

</code>
 </pre>
  
    如果字段的表达式超出此类型的范围，则指定基础类型，编译器将抱怨而不是更改基础类型。
  
  
    我认为这是一个很好的安全改进。
  
  
    所以
    
      为什么枚举类优于普通枚举？
    
    ，如果我们可以选择范围的基础类型（
     <code>
 enum class
 </code>
    ）和无范围（
     <code>
 enum
 </code>
    ）枚举其他什么
     <code>
 enum class
 </code>
     更好的选择？：
  
  <UL>
    <LI>
      它们不会隐式转换为
       <code>
 int
 </code>
      。
    </LI>
    <LI>
      它们不会污染周围的命名空间。
    </LI>
    <LI>
      他们可以向前宣布。
    </LI>
  </UL>
</DIV>

3# 至此 | 2019-08-31 10-32

4# trpnest | 2019-08-31 10-32