枚举类型的名称空间-最佳做法

通常，一个人同时需要几种枚举类型。有时，一个人会发生名字冲突。有两种解决方案：使用名称空间，或使用“较大”的枚举元素名称。命名空间解决方案仍然有两种可能的实现：具有嵌套枚举的虚拟类或完整的命名空间。

我正在寻找这三种方法的利弊。

例：

// oft seen hand-crafted name clash solution
enum eColors { cRed, cColorBlue, cGreen, cYellow, cColorsEnd };
enum eFeelings { cAngry, cFeelingBlue, cHappy, cFeelingsEnd };
void setPenColor( const eColors c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cColorBlue: //...
        //...
    }
 }


// (ab)using a class as a namespace
class Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
class Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
 }


 // a real namespace?
 namespace Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
 namespace Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
 void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
  }

原始C ++ 03答案：

该益处从namespace（在class）是您可以使用using，当你想声明。

使用a 的问题namespace是可以在代码中的其他地方扩展名称空间。在大型项目中，不能保证两个不同的枚举不会同时认为它们被称为eFeelings

对于看起来更简单的代码，我使用了struct，因为您大概希望内容是公开的。

如果您正在执行这些实践中的任何一种，那么您将处于领先地位，并且可能不需要进一步检查。

较新的C ++ 11建议：

如果您使用的是C ++ 11或更高版本，enum class则将枚举值隐式限制在枚举名称内。

这样，enum class您将失去对整数类型的隐式转换和比较，但实际上，这可能会帮助您发现模棱两可或错误的代码。

仅供参考在C ++ 0x中，针对您提到的情况提供了新的语法（请参阅C ++ 0x Wiki页面）

enum class eColors { ... };
enum class eFeelings { ... };

我已经将前面的答案混合成这样的东西：（编辑：这仅对C ++ 11之前的版本有用。如果您使用的是C ++ 11，请使用enum class）

我有一个包含所有项目枚举的大头文件，因为这些枚举在辅助类之间共享，并且将枚举放入辅助类本身没有任何意义。

该struct避免市民：语法糖，以及typedef让你实际上其他工人类中声明这些枚举变量。

我认为使用名称空间根本没有帮助。也许这是因为我是C＃程序员，并且在引用值时必须使用枚举类型名称，所以我已经习惯了。

    struct KeySource {
        typedef enum { 
            None, 
            Efuse, 
            Bbram
        } Type;
    };

    struct Checksum {
        typedef enum {
            None =0,
            MD5 = 1,
            SHA1 = 2,
            SHA2 = 3
        } Type;
    };

    struct Encryption {
        typedef enum {
            Undetermined,
            None,
            AES
        } Type;
    };

    struct File {
        typedef enum {
            Unknown = 0,
            MCS,
            MEM,
            BIN,
            HEX
        } Type;
    };

...

class Worker {
    File::Type fileType;
    void DoIt() {
       switch(fileType) {
       case File::MCS: ... ;
       case File::MEM: ... ;
       case File::HEX: ... ;
    }
}

我绝对会避免为此使用类；改用名称空间。这个问题归结为对于枚举值使用命名空间还是使用唯一的ID。就个人而言，我将使用命名空间，以便我的ID可以更短，并且希望更容易解释。然后，应用程序代码可以使用“ using namespace”指令，并使所有内容更具可读性。

从上面的示例中：

using namespace Colors;

void setPenColor( const e c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cBlue: //...
        //...
    }
}

使用类或名称空间的区别在于，不能像名称空间那样重新打开该类。这避免了将来可能会滥用名称空间的可能性，但是也存在您也无法添加到枚举集的问题。

使用类的可能好处是它们可以用作模板类型参数，而名称空间则不是这样：

class Colors {
public:
  enum TYPE {
    Red,
    Green,
    Blue
  };
};

template <typename T> void foo (T t) {
  typedef typename T::TYPE EnumType;
  // ...
}

就个人而言，我不喜欢使用，我更喜欢使用完全限定的名称，因此我并没有真正将其视为名称空间的加号。但是，这可能不是您要在项目中做出的最重要的决定！

使用类的优点是您可以在其上构建完整的类。

#include <cassert>

class Color
{
public:
    typedef enum
    {
        Red,
        Blue,
        Green,
        Yellow
    } enum_type;

private:
    enum_type _val;

public:
    Color(enum_type val = Blue)
        : _val(val)
    {
        assert(val <= Yellow);
    }

    operator enum_type() const
    {
        return _val;
    }
};

void SetPenColor(const Color c)
{
    switch (c)
    {
        case Color::Red:
            // ...
            break;
    }
}

如以上示例所示，通过使用类，您可以：

1. 禁止（不幸的是，不是编译时）C ++允许从无效值进行强制转换，
2. 为新创建的枚举设置一个（非零）默认值，
3. 添加其他方法，例如返回选择的字符串表示形式。

请注意，您需要声明，operator enum_type()以便C ++知道如何将您的类转换为基础枚举。否则，您将无法将类型传递给switch语句。

由于枚举的作用域仅限于其封闭范围，因此最好将它们包装在某种东西中，以避免污染全局名称空间并有助于避免名称冲突。我更喜欢将名称空间归类，因为namespace感觉就像是一堆东西，而class感觉像是一个健壮的对象（参见structvs. class辩论）。命名空间的一个可能好处是可以在以后进行扩展-如果您正在处理无法修改的第三方代码，则很有用。

当我们使用C ++ 0x获得枚举类时，这当然没有什么意义。

我也倾向于将枚举封装在类中。

正如理查德·科登（Richard Corden）所说，类的好处是它是c ++的类型，因此可以将其与模板一起使用。

我有一个特殊的工具箱:: Enum类，可以满足我的需要，这些类专门针对提供基本功能的每个模板（主要是：将枚举值映射到std :: string，以便于阅读I / O）。

我的小模板还具有真正检查允许值的附加好处。编译器有点松懈，无法检查值是否确实在枚举中：

typedef enum { False: 0, True: 2 } boolean;
   // The classic enum you don't want to see around your code ;)

int main(int argc, char* argv[])
{
  boolean x = static_cast<boolean>(1);
  return (x == False || x == True) ? 0 : 1;
} // main

总是让我感到困扰的是，编译器不会捕捉到这一点，因为您留下的枚举值没有意义（而且您不会期望）。

类似地：

typedef enum { Zero: 0, One: 1, Two: 2 } example;

int main(int argc, char* argv[])
{
  example y = static_cast<example>(3);
  return (y == Zero || y == One || y == Two) ? 0 : 1;
} // main

main再次返回错误。

问题在于，编译器将枚举以可用的最小表示形式进行拟合（此处需要2位），并且适合该表示形式的所有内容均被视为有效值。

还有一个问题是，有时您宁愿在可能的值上循环而不是使用开关，这样就不必在每次向枚举添加值时都修改所有开关。

总而言之，我的小帮手确实为我的枚举简化了工作（当然，这会增加一些开销），并且这是唯一可能的，因为我将每个枚举都嵌套在自己的结构中：）