¿Extensiones extendidas en C++?

Question

¿Hay alguna manera en C++ de extender/"heredar" enumeraciones?

I.E:

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

o al menos definir una conversión entre ellos?

Answer 1

No, no lo hay.

enum son realmente lo malo en C++, y eso es desafortunado por supuesto.

Incluso el class enum introducido en C++ 0x no resuelve este problema de extensibilidad (aunque al menos hacen algunas cosas para la seguridad del tipo).

La única ventaja de enum es que no existen: ofrecen algún tipo de seguridad sin imponer ninguna sobrecarga de tiempo de ejecución ya que son sustituidas por el compilador directamente.

Si desea una bestia, que tendrá que trabajar a sí mismo:

• crear una clase MyEnum, que contiene un int (básicamente)
• crear constructores llevan el nombre de cada uno de los valores interesantes

ahora se puede extender su clase (la adición de constructores con nombre) a voluntad ...

Esa es una solución, sin embargo, nunca he foun da satistifying manera de tratar con una enumeración ...

Answer 2

El siguiente código funciona bien.

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

Answer 3

Si fueron capaces de crear una subclase de una enumeración que tendría que trabajar a la inversa.

El conjunto de instancias en una subclase es un subconjunto de las instancias en la superclase. Piensa en el ejemplo estándar de "Forma". La clase Shape representa el conjunto de todas las Formas. La clase Circle, su subclase, representa el subconjunto de Formas que son Círculos.

Para que sea consistente, una subclase de una enumeración debería contener un subconjunto de los elementos en la enumeración de la que hereda.

(Y no, C++ no soporta esto.)

Answer 4

he resuelto de esta manera:

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

Por supuesto, si se agrega un nuevo protocolo de red en el archivo NetProtocols.def, hay que recompilar, pero al menos es expandible.

Answer 5

http://www.codeproject.com/KB/cpp/InheritEnum.aspx repasa un método para crear una enumeración expandida.

Answer 6

Sólo una idea:

Se podría tratar de crear una clase vacía para cada constante (tal vez poner a todos en el mismo archivo para reducir el desorden), cree una instancia de cada clase y utilizar los punteros a estas instancias como las "constantes".De esta forma, el compilador comprenderá la herencia y realizará cualquier conversión ChildPointer-to-ParentPointer necesaria al usar llamadas a funciones, Y usted todavía obtiene verificaciones de seguridad de tipo por parte del compilador para asegurarse de que nadie transfiera un valor int inválido a las funciones (lo que tendría para usar si usa el método de valor LAST para "extender" la enumeración).

Aunque no lo he pensado del todo, cualquier comentario sobre este enfoque es bienvenido.

Y trataré de publicar un ejemplo de lo que quiero decir tan pronto como tenga algo de tiempo.

Answer 7

yo probamos este, funciona, pero es un poco tedioso:

#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; 
}