enumerazioni si estende in C++?

Question

C'è un modo in C++ per estendere/enumerazioni "Eredita"?

cioè:

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

o almeno definire una conversione tra di loro?

Answer 1

No, non c'è.

enum sono davvero la cosa povera in C++, e questo è un peccato, naturalmente.

Anche lo class enum introdotto in C++ 0x non risolve questo problema di estensibilità (sebbene facciano almeno alcune cose per la sicurezza del tipo).

L'unico vantaggio di enum è che non esistono: offrono un certo tipo di sicurezza mentre non impongono alcun sovraccarico di runtime in quanto vengono sostituiti direttamente dal compilatore.

Se si desidera una bestia, si dovrà lavorare da soli:

• creare una classe MyEnum, che contiene un int (sostanzialmente)
• creare costruttori chiamati per ciascuno dei valori interessanti

ora è possibile estendere la classe (l'aggiunta di costruttori di nome) a volontà ...

Questa è una soluzione, però, non ho mai foun da satistifying modo di trattare con un'enumerazione ...

Answer 2

Il seguente codice funziona bene.

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

Answer 3

Se tu fossi in grado di creare una sottoclasse di un enum che avrebbe dovuto lavorare il contrario.

Il set di istanze in una sottoclasse è un sottoinsieme delle istanze nella super-classe. Pensa all'esempio standard "Shape". La classe Shape rappresenta l'insieme di tutte le forme. La classe Circle, la sua sottoclasse, rappresenta il sottoinsieme di forme che sono cerchi.

Quindi, per essere coerente, una sottoclasse di un enum avrebbe dovuto contenere un sottoinsieme degli elementi della enum cui eredita.

(E no, C++ non supporta questa.)

Answer 4

ho risolto in questo modo:

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

Naturalmente, se si aggiunge un nuovo protocollo di rete nel file NetProtocols.def, si deve ricompilare, ma almeno è espandibile.

Answer 5

http://www.codeproject.com/KB/cpp/InheritEnum.aspx passa a un metodo per creare un enum espanso.

Answer 6

Solo un'idea:

Si potrebbe provare a creare una classe vuota per ogni costante (forse metterli tutti nello stesso file per ridurre l'ingombro), creare un'istanza di ogni classe e utilizzare i puntatori a queste istanze come le "costanti".In questo modo, il compilatore comprenderà l'ereditarietà e eseguirà qualsiasi conversione di ChildPointer-to-ParentPointer necessaria quando si utilizzano le chiamate di funzione, E si ottiene comunque controlli di sicurezza del tipo da parte del compilatore per garantire che nessuno passi un valore int non valido alle funzioni (che avrebbe da utilizzare se si utilizza il metodo LAST value per "estendere" l'enum).

Non ho ancora pensato a tutto questo, quindi qualsiasi commento su questo approccio è benvenuto.

E proverò a pubblicare un esempio di cosa intendo appena ho un po 'di tempo.

Answer 7

Ho provato questo, funziona, ma è un po 'noioso:

#include <iostream> 

struct Foo { 
protected: 
    int _v; 
    Foo(int i) : _v(i) {} 

public: 
    operator int() const { return _v; } 

    static Foo FOO() { return 5; }; 
}; 

struct Bar : public Foo { 
    using Foo::Foo; 
    Bar(const Foo &f) : Foo(f) {} 

    static Bar BAR() { return 6; }; 
}; 

int main(int argc, const char *argv[]) { 
    // Bar bar = Bar::BAR(); 
    Foo foo = Foo::FOO(); 
    Bar bar = Bar::BAR(); 

    // 5 
    Bar b = foo; 
    std::cout << (int)b << std::endl; 

    // 6 
    b = bar; 
    std::cout << (int)b << std::endl; 

    // 5 
    b = foo; 
    std::cout << (int)b << std::endl; 

    // Foo err1(5); 
    // Bar err2(5); 
    return 0; 
}