Question

C ++中有没有办法扩展/“继承”枚举？

即：

enum Enum {A,B,C};
enum EnumEx : public Enum {D,E,F};

或者至少定义它们之间的转换？

Answer 1

不，没有。

enum在C ++中真的很糟糕，当然这很不幸。

即使C ++ 0x中引入的class enum也没有解决这个可扩展性问题（尽管它们至少为类型安全做了一些事情）。

enum的唯一优势是它们不存在：它们提供了一些类型安全性，同时不会强加任何运行时开销，因为它们直接由编译器替代。

如果你想要这样的野兽，你必须自己动手：

创建一个包含int（基本上）

MyEnum

为每个有趣的值创建命名构造函数

您现在可以随意扩展您的类（添加命名构造函数）...

这是一种解决方法，但我从来没有找到一种处理枚举的令人满意的方法......

Answer 2

如果你能够创建一个枚举的子类，它必须以相反的方式工作。

子类中的实例集是超类中实例的子集。想想标准的“形状”示例。 Shape类表示所有形状的集合。 Circle类及其子类表示Shacles的Shapes子集。

因此，为了保持一致，枚举的子类必须包含它继承的枚举中的元素的子集。

（不，C ++不支持此。）

Answer 3

我已经用这种方式解决了：

typedef enum
{
    #include "NetProtocols.def"
} eNetProtocols, eNP;

当然，如果在NetProtocols.def文件中添加新的网络协议，则必须重新编译，但至少它是可扩展的。

Answer 4

在我设计的小型硬件设备上运行的某些项目中，我遇到了这个问题。有一个包含许多服务的通用项目。其中一些服务使用枚举作为参数来获得附加的类型检查和安全性。我需要能够在使用这些服务的项目中扩展这些枚举。

正如其他人所提到的，c ++不允许您扩展枚举。但是，您可以使用名称空间和具有 enum class 的所有优点的模板来模拟枚举。

枚举类 具有以下优点：

转换为已知的整数类型。
是值类型
默认情况下为constexpr，在小型处理器上不占用宝贵的RAM
由enum :: value定义范围并可以访问
适用于个案陈述
用作参数时需要提供类型安全性，并且需要显式强制转换

现在，如果您将类定义为 enum ，则无法在类声明中创建 enum 的 constexpr 实例，因为类尚未完成，它会导致编译错误。同样，即使这可行，您以后也无法在另一个文件/子项目中轻松扩展枚举的值集。

现在 命名空间 没有这种问题，但是它们不提供类型安全性。

答案是首先创建一个模板化的基类，该基类允许不同基数的枚举，因此我们不会浪费我们不使用的内容。

template <typename TYPE>
class EnumClass {
  private:
    TYPE value_;
  public:
    explicit constexpr EnumClass(TYPE value) :
        value_(value){
    }
    constexpr EnumClass() = default;
    ~EnumClass() = default;
    constexpr explicit EnumClass(const EnumClass &) = default;
    constexpr EnumClass &operator=(const EnumClass &) = default;

    constexpr operator TYPE() const {return    value_;}
    constexpr TYPE value() const {return value_;}

};

然后为每个要扩展和模拟的 enum类创建一个名称空间和一个Type，如下所示：

namespace EnumName {
   class Type :public Enum<uint8_t> {
     public:
        explicit constexpr Type(uint8_t value): Enum<uint8_t>(value){}
        constexpr Enum() = default;
   }
   constexpr auto Value1 = Type(1); 
   constexpr auto Value2 = Type(2); 
   constexpr auto Value3 = Type(3); 
}

随后在代码中，如果您包含原始EnumName，则可以执行以下操作：

   namespace EnumName {
       constexpr auto Value4 = Type(4U); 
       constexpr auto Value5 = Type(5U); 
       constexpr auto Value6 = Type(6U); 

       constexpr std::array<Type, 6U> Set = {Value1, Value2, Value3, Value4, Value5, Value6};
    }

现在您可以像这样使用 Enum ：

#include <iostream>

void fn(EnumName::Type val){
    if( val != EnumName::Value1 ){
      std::cout << val;
    }
}

int main(){
  for( auto e :EnumName::Set){
    switch(e){
      case EnumName::Value1:  
        std::cout << "a";
        break;
      case EnumName::Value4:  
        std::cout << "b";
        break;
      default:
        fn(e);
    }
  }
}

因此，我们有一个case语句，枚举比较，参数类型安全性及其所有可扩展性。请注意，该集合为 constexpr ，并且最终不会在小型微型计算机上使用有价值的RAM（在Godbolt.org上验证过的位置。：-）。作为奖励，我们可以迭代一组枚举值。

Answer 5

http://www.codeproject.com/KB/cpp/InheritEnum.aspx介绍了创建扩展枚举的方法。

Answer 6

只是一个想法：

您可以尝试为每个常量创建一个空类（可能将它们全部放在同一个文件中以减少混乱），创建每个类的一个实例并使用指向这些实例的指针作为“常量”。这样，编译器将理解继承并将在使用函数调用时执行所需的任何ChildPointer到ParentPointer转换，并且您仍然可以通过编译器进行类型安全检查，以确保没有人将无效的int值传递给函数（这将具有如果您使用最后一个值方法“扩展”枚举，则使用。

虽然没有充分考虑到这一点，所以欢迎任何关于这种方法的评论。

我会尽快发布一个我的意思的例子。

Answer 7

针对此c ++差距的一种简单但有用的解决方法如下：

#define ENUM_BASE_VALS A,B,C
enum Enum {ENUM_BASE_VALS};
enum EnumEx {ENUM_BASE_VALS, D,E,F};

Answer 8

实际上，您可以以某种方式扩展枚举。

C ++标准将有效枚举值定义为基础类型的所有有效值，因此以下是有效的C ++（11+）。它不是不确定的行为，但是非常讨厌-您已经被警告。

#include <cstdint>

    enum Test1:unit8_t {
        Value1 =0,
        Value2 =1
    };

    constexpr auto Value3 = static_cast<Test1>(3);
    constexpr auto Value4 = static_cast<Test1>(4);
    constexpr auto Value5 = static_cast<Test1>(5);


Test1 fn(Test1 val){
  switch(val){
    case Value1:
    case Value2:
    case Value3:
    case Value4:
       return Value1;
    case Value5:
       return Value5; 
  } 
}

int main(){
  return static_cast<uint8_t>(fn(Value5));
}

请注意，大多数编译器不会将附加值视为生成关于switch语句中缺少枚举值的警告的集合的一部分。如果上面的switch语句中缺少Value2，则clang和gcc将发出警告，但如果缺少Value4，则将不执行任何操作。

Answer 9

我这样做 '

'''
    enum OPC_t // frame Operation Codes
    {
      OPC_CVSND = 0 // Send CV value
    , OPC_CVREQ = 1 // Request CV (only valid for master app)
    , OPC_COMND = 2 // Command
    , OPC_HRTBT = 3 // Heart Beat
    };
    enum rxStatus_t     // this extends OPC_t
    {
      RX_CVSND = OPC_CVSND  // Send CV value
    , RX_CVREQ = OPC_CVREQ  // Request CV
    , RX_COMND = OPC_COMND  // Command
    , RX_HRTBT = OPC_HRTBT  // Heart Beat
    , RX_NONE       // No new Rx
    , RX_NEWCHIP        // new chip detected
    };
''''

Answer 10

可以试试这个:)


struct EnumType
{
        enum 
        {
            None = 0,
            Value_1 = 1,
            Value_2 = 2,
            Value_3 = 3
        };

        //For when using the EnumType as a variable type
        int Value { None };
};

struct EnumTypeEx : EnumType
{
        enum
        {
            ExValue_1 = 3,
            ExValue_2 = 4,
            
            //override the value of Value_3
            Value_3 = 3000
        };
};

优点：

类可扩展性
可以覆盖基本标签值

缺点：

写起来很乏味
您必须明确设置每个标签的值(*)

(*) 您可以通过显式写入例如从最后一个基值开始自动值递增。 ExValue_Start = LastBaseValue。

Answer 11

以下代码效果很好。

enum Enum {A,B,C};
enum EnumEx {D=C+1,E,F};

用C ++扩展枚举？

11 个答案: