Héritage de la classe de l'enum de base

Question

Existe-t-il un modèle permettant d'hériter d'un enum d'un autre enum en C++ ?

Quelque chose comme ça :

enum eBase 
{
   one=1, two, three
};

enum eDerived: public eBase
{
   four=4, five, six
};

Answer 1

Eh bien, si vous définissez enum avec le même nom dans la classe dérivée et le faire démarrer à partir du dernier élément du correspondant enum dans la classe de base, vous recevrez presque ce que vous voulez - un enum hérité. Regardez ce code :

class Base
{
public:
    enum ErrorType
    {
        GeneralError,
        NoMemory,
        FileNotFound,
        LastItem,
    };
};

class Inherited: public Base
{
public:
    enum ErrorType
    {
        SocketError = Base::LastItem,
        NotEnoughBandwidth,
    };
};

Answer 2

Comme indiqué par bayda Les enums n'ont pas (et/ou ne devraient pas) avoir de fonctionnalité, j'ai donc adopté l'approche suivante pour résoudre votre dilemme en adaptant Mykola Golubyev La réponse de la Commission :

typedef struct
{
    enum
    {
        ONE = 1,
        TWO,
        LAST
    };
}BaseEnum;

typedef struct : public BaseEnum
{
    enum
    {
        THREE = BaseEnum::LAST,
        FOUR,
        FIVE
    };
}DerivedEnum;

Answer 3

Vous pouvez utiliser un projet SuperEnum pour créer des énumérations extensibles.

/*** my_enum.h ***/
class MyEnum: public SuperEnum<MyEnum>
{
public:
    MyEnum() {}
    explicit MyEnum(const int &value): SuperEnum(value) {}

    static const MyEnum element1;
    static const MyEnum element2;
    static const MyEnum element3;
};

/*** my_enum.cpp ***/
const MyEnum MyEnum::element1(1);
const MyEnum MyEnum::element2;
const MyEnum MyEnum::element3;

/*** my_enum2.h ***/
class MyEnum2: public MyEnum
{
public:
    MyEnum2() {}
    explicit MyEnum2(const int &value): MyEnum(value) {}

    static const MyEnum2 element4;
    static const MyEnum2 element5;
};

/*** my_enum2.cpp ***/
const MyEnum2 MyEnum2::element4;
const MyEnum2 MyEnum2::element5;

/*** main.cpp ***/
std::cout << MyEnum2::element3;
// Output: 3

Answer 4

C'est un peu compliqué, mais c'est ce que j'ai trouvé pour les enums à portée :

enum class OriginalType {
   FOO,  // 0
   BAR   // 1
   END   // 2
};

enum class ExtendOriginalType : std::underlying_type_t<OriginalType> {
   EXTENDED_FOO = static_cast<std::underlying_type_t<OriginalType>>
                                           (OriginalType::END), // 2
   EXTENDED_BAR  // 3
};

et ensuite utiliser comme :

OriginalType myOriginalType = (OriginalType)ExtendOriginalType::EXTENDED_BAR;

Answer 5

Cette réponse est une variante de la réponse de Brian R. Bondy. Comme cela a été demandé dans un commentaire, je l'ajoute comme réponse. Je ne sais pas si cela vaut vraiment la peine.

#include <iostream>

class Colors
{
public:
    static Colors RED;
    static Colors GREEN;

    operator int(){ return value; }
    operator int() const{ return value; }

protected:
    Colors(int v) : value{v}{} 

private:
    int value;
};

Colors Colors::RED{1};
Colors Colors::GREEN{2};

class RGB : public Colors
{
public:
    static RGB BLUE;

private:
    RGB(int v) : Colors(v){}
};

RGB RGB::BLUE{10};

int main ()
{
  std::cout << Colors::RED << " " << RGB::RED << std::endl;
}

En direct de Coliru