ベースのenumクラスの継承

Question

C++の別の列挙型からenumを継承できるパターンはありますか？そのような

何か：

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


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

Answer 1

不可。列挙型の継承はありません。

代わりに、名前付きのconst intでクラスを使用できます。

例：

class Colors 
{ 
public: 
    static const int RED = 1; 
    static const int GREEN = 2; 
}; 

class RGB : public Colors 
{ 
    static const int BLUE = 10; 
}; 


class FourColors : public Colors 
{ 
public: 
    static const int ORANGE = 100; 
    static const int PURPLE = 101; 
}; 

Answer 2

#include <iostream> 
#include <ostream> 

class Enum 
{ 
public: 
    enum 
    { 
     One = 1, 
     Two, 
     Last 
    }; 
}; 

class EnumDeriv : public Enum 
{ 
public: 
    enum 
    { 
     Three = Enum::Last, 
     Four, 
     Five 
    }; 
}; 

int main() 
{ 
    std::cout << EnumDeriv::One << std::endl; 
    std::cout << EnumDeriv::Four << std::endl; 
    return 0; 
} 

Answer 3

インポッシブル。
しかし、クラス内でenumを匿名で定義し、派生クラスにenum定数を追加することができます。

Answer 4

これは直接行うことはできませんが、thisの記事から解決策を試すことができます。

主な考え方は、enum値を保持し、型キャスト演算子を持つヘルパーテンプレートクラスを使用することです。列挙型の基になる型がintであることを考慮すると、列挙型ではなくコードでこのホルダークラスをシームレスに使用できます。

Answer 5

派生クラスに同じ名前のenumを定義し、基底クラスの対応先enumの最後のアイテムから開始すると、ほとんどあなたが欲しいものが得られます - 継承した列挙型。このコードでは ルック：

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

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

Answer 6

baydaで述べたように、ではない（および/またはすべきでない）を行うのをENUMは機能を持っているので、私はMykola Golubyevの応答を適合させることによって、あなたの苦境に次のアプローチを取ってきました：

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

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

Answer 7

残念ながら、C++では不可能です。私は、C++でこのような言語機能を使うことを願っています。あなたの問題に対するいくつかの回避策が既にあるので、私は解決策を提供しません。

私は、文言は「継承」ではなく「拡張」でなければならないことを指摘したいと思います。この拡張ではより多くの値が得られます（例では3から6にジャンプします）。継承とは、与えられた基底クラスにより多くの制約を入れて、可能性のセットが小さくなることを意味します。したがって、潜在的なキャスティングは継承とは正反対に動作します。派生クラスを基底クラスにキャストすることはできますが、クラス継承を使用することはできません。しかし、拡張機能を使用する場合は、基底クラスをその拡張機能にキャストすることができなければなりません。私は「そうすべきだ」と言っているのは、私が言ったように、そのような言語機能はまだ存在しないからです。

Answer 8

これはいかがですか？インスタンスはすべての可能な値に対して作成されますが、それ以外にも非常に柔軟です。不利な点はありますか？

.H：

class BaseEnum 
{ 
public: 
    static const BaseEnum ONE; 
    static const BaseEnum TWO; 

    bool operator==(const BaseEnum& other); 

protected: 
    BaseEnum() : i(maxI++) {} 
    const int i; 
    static int maxI; 
}; 

class DerivedEnum : public BaseEnum 
{ 
public: 
    static const DerivedEnum THREE; 
}; 

。CPP：

int BaseEnum::maxI = 0; 

bool BaseEnum::operator==(const BaseEnum& other) { 
    return i == other.i; 
} 

const BaseEnum BaseEnum::ONE; 
const BaseEnum BaseEnum::TWO; 
const DerivedEnum DerivedEnum::THREE; 

使用法：

BaseEnum e = DerivedEnum::THREE; 

if (e == DerivedEnum::THREE) { 
    std::cerr << "equal" << std::endl; 
} 

Answer 9

あなたが拡張列挙型を作成するために、プロジェクトSuperEnumを使用することができます。

/*** 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