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

#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 2

Pas possible. Il n'y a pas d'héritage avec les enums.

Vous pouvez à la place utiliser des classes avec des const ints nommés.

Exemple :

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 3

Vous ne pouvez pas faire cela directement, mais vous pouvez essayer d'utiliser la solution de este article.

L'idée principale est d'utiliser la classe modèle d'aide qui contient des valeurs d'énumération et possède l'opérateur de cast de type. Si l'on considère que le type sous-jacent de l'enum est int vous pouvez utiliser cette classe titulaire de manière transparente dans votre code au lieu de l'enum.

Answer 4

Malheureusement, ce n'est pas possible en C++14. J'espère que nous aurons une telle fonctionnalité dans le C++17. Comme vous avez déjà obtenu quelques solutions de contournement pour votre problème, je ne vais pas fournir une solution.

Je tiens à souligner que la formulation devrait être "extension" et non "héritage". L'extension permet plus de valeurs (puisque vous passez de 3 à 6 valeurs dans votre exemple) alors que l'héritage signifie mettre plus de contraintes à une classe de base donnée de sorte que l'ensemble des possibilités se réduit. Par conséquent, le casting potentiel fonctionnerait exactement à l'opposé de l'héritage. Vous pouvez couler une classe dérivée vers la classe de base et non l'inverse avec l'héritage de classe. Mais lorsque vous avez des extensions, vous "devriez" être en mesure de mouler la classe de base vers son extension et non l'inverse. Je dis "devrait" parce que, comme je l'ai dit, une telle fonctionnalité du langage n'existe toujours pas.

Answer 5

Que pensez-vous de ça ? D'accord, une instance est créée pour chaque valeur possible, mais à part ça, c'est très flexible. Y a-t-il des inconvénients ?

.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;

Utilisation :

BaseEnum e = DerivedEnum::THREE;

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