Etendre les énumérations en C++?

Question

Existe-t-il un moyen en C++ d'étendre/"hériter" des enumérations ?

Par exemple :

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

ou au moins définir une conversion entre eux ?

Answer 1

Non, il n'y en a pas.

enum est vraiment le pauvre élément en C++, et c'est bien sûr malheureux.

Même la enum classe introduite en C++0x ne résout pas ce problème d'extensibilité (bien qu'ils fassent certaines choses pour la sécurité des types au moins).

Le seul avantage de enum est qu'ils n'existent pas : ils offrent une certaine sécurité des types sans imposer de surcharge à l'exécution car ils sont directement substitués par le compilateur.

Si vous voulez un tel élément, vous devrez travailler vous-même :

• créez une classe MyEnum, qui contient un int (basiquement)
• créez des constructeurs nommés pour chacune des valeurs intéressantes

vous pouvez maintenant étendre votre classe (en ajoutant des constructeurs nommés) à volonté...

C'est une solution de contournement cependant, je n'ai jamais trouvé de moyen satisfaisant de traiter une énumération...

Answer 2

J'ai résolu de cette manière :

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

Bien sûr, si vous ajoutez un nouveau protocole de réseau dans le fichier NetProtocols.def, vous devez recompiler, mais au moins il est extensible.

"NetProtocols.def" contiendra uniquement les noms des champs :

HTTP,
HTTPS,
FTP

Answer 3

Si vous étiez capable de créer une sous-classe d'une énumération, cela devrait fonctionner dans l'autre sens.

L'ensemble des instances dans une sous-classe est un sous-ensemble des instances dans la super-classe. Pensez à l'exemple standard de "Forme". La classe Forme représente l'ensemble de toutes les formes. La classe Cercle, sa sous-classe, représente le sous-ensemble des formes qui sont des cercles.

Donc, pour être cohérent, une sous-classe d'une énumération devrait contenir un sous-ensemble des éléments de l'énumération dont elle hérite.

(Et non, C++ ne supporte pas cela.)

Answer 4

http://www.codeproject.com/KB/cpp/InheritEnum.aspx passe en revue une méthode pour créer une énumération étendue.

Créez InheritEnum.h:

// -- InheritEnum.h

template 
class InheritEnum
{
public:
  InheritEnum() {}
  InheritEnum(EnumT e)
    : enum_(e)
  {}

  InheritEnum(BaseEnumT e)
    : baseEnum_(e)
  {}

  explicit InheritEnum( int val )
    : enum_(static_cast(val))
  {}

  operator EnumT() const { return enum_; }
private:
  // Note - la valeur est déclarée comme une union principalement pour aider au débogage. Si 
  // la union n'est pas souhaitée et que vous avez d'autres méthodes de débogage, modifiez-la
  // en EnumT ou en base de EnumT et faites une conversion pour le constructeur qui accepte BaseEnumT.
  union
  { 
    EnumT enum_;
    BaseEnumT baseEnum_;
  };
};

Et ensuite l'utiliser:

enum Fruit { Orange, Mango, Banana };
enum NewFruits { Apple, Pear }; 
typedef InheritEnum< NewFruit, Fruit > MyFruit;

void consume(MyFruit myfruit); 

Votre expérience peut varier.

Answer 5

Pas que je sache.