c++ - para - La herencia de la clase Base enum

enum type c++ example

Question

¿Hay un patrón donde puedo heredar enum de otra enumeración en C ++?

Algo como eso:

enum eBase
{
one=1, two, three
};
enum eDerived: public eBase
{
four=4, five, six
};

Answer 1

¿Qué tal esto? Ok, se crea una instancia para cada valor posible, pero además de eso es muy flexible. ¿Hay algún inconveniente?

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

Uso:

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

Answer 2

Bueno, si defines enum con el mismo nombre en la clase derivada y lo comienzas desde el último elemento de la enum correspondiente en la clase base, recibirás casi lo que deseas: enum heredado. Mira este código:

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

Answer 3

Como dice bayda , las funciones de enum no tienen (y / o no deberían), así que he adoptado el siguiente enfoque a tu dilema mediante la adaptación de la respuesta de Mykola Golubyev :

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

Answer 4

Desafortunadamente no es posible en C ++ 14. Espero que tengamos esa función de lenguaje en C ++ 17. Como ya tiene algunas soluciones para su problema, no proporcionaré una solución.

Me gustaría señalar que la redacción debe ser "extensión" y no "herencia". La extensión permite más valores (cuando saltas de 3 a 6 valores en tu ejemplo), mientras que la herencia significa poner más restricciones a una clase base dada, por lo que el conjunto de posibilidades se reduce. Por lo tanto, el casting potencial funcionaría exactamente en oposición a la herencia. Puede convertir la clase derivada a la clase base y no viceversa con la herencia de clase. Pero cuando tienes extensiones "deberías" poder convertir la clase base a su extensión y no viceversa. Estoy diciendo "debería" porque, como dije, esa característica de idioma todavía no existe.

Answer 5

Imposible. No hay herencia con enums.

En su lugar, puede usar clases con const ints nombrados.

Ejemplo:

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 6

Imposible.
Pero puede definir la enumeración anónimamente en una clase, luego agregar constantes de enumeración adicionales en las clases derivadas.

Answer 7

No puedes hacer eso directamente, pero podrías intentar usar la solución de this artículo.

La idea principal es usar la clase de plantilla auxiliar que tiene valores enum y tiene el operador de conversión de tipo. Teniendo en cuenta que el tipo subyacente para enum es int , puede usar esta clase de titular de manera transparente en su código en lugar de la enumeración.

Answer 8

Puede usar un proyecto SuperEnum para crear enumeraciones extensibles.

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

Answer 9

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