在C++中,是否有一种模式可以从另一个枚举类型继承?
类似于这样:
enum eBase
{
one=1, two, three
};
enum eDerived: public eBase
{
four=4, five, six
};
#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;
}
不可能。枚举类型不支持继承。
你可以使用带有命名常量整数的类替代。
示例:
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;
};
Colors
类实例。你只需要使用静态常量成员中的 int 值。 - jiandingzheColor
的函数,就像你可以针对枚举一样。 - Drew Dormann您不能直接这样做,但可以尝试使用此文章中的解决方案。
主要思路是使用辅助模板类来保存枚举值并具有类型转换运算符。考虑到枚举的基础类型为int
,因此您可以在代码中无缝地使用这个持有者类来代替枚举。
extends
是Eiffel语言中用于继承的关键字。 - Cheers and hth. - Alfclass 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;
使用方法:
BaseEnum e = DerivedEnum::THREE;
if (e == DerivedEnum::THREE) {
std::cerr << "equal" << std::endl;
}
/*** 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
const int&
,改用简单的 int
。 - Moia如果您在派生类中使用相同名称定义enum
并从基类中对应的enum
的最后一项开始,您将获得几乎想要的继承枚举。请看以下代码:
class Base
{
public:
enum ErrorType
{
GeneralError,
NoMemory,
FileNotFound,
LastItem,
};
};
class Inherited: public Base
{
public:
enum ErrorType
{
SocketError = Base::LastItem,
NotEnoughBandwidth,
};
};
typedef struct
{
enum
{
ONE = 1,
TWO,
LAST
};
}BaseEnum;
typedef struct : public BaseEnum
{
enum
{
THREE = BaseEnum::LAST,
FOUR,
FIVE
};
}DerivedEnum;
这种方法可能有点巧妙,但在处理作用域枚举时,以下是我想出的解决方案:
最初的回答:
enum class OriginalType {
FOO, // 0
BAR // 1
END // 2
};
enum class ExtendOriginalType : std::underlying_type_t<OriginalType> {
EXTENDED_FOO = static_cast<std::underlying_type_t<OriginalType>>
(OriginalType::END), // 2
EXTENDED_BAR // 3
};
OriginalType myOriginalType = (OriginalType)ExtendOriginalType::EXTENDED_BAR;
这个答案是Brian R. Bondy的一个变体。由于在评论中被要求,我将其添加为答案。不过我并没有指出它是否真的值得。
#include <iostream>
class Colors
{
public:
static Colors RED;
static Colors GREEN;
operator int(){ return value; }
operator int() const{ return value; }
protected:
Colors(int v) : value{v}{}
private:
int value;
};
Colors Colors::RED{1};
Colors Colors::GREEN{2};
class RGB : public Colors
{
public:
static RGB BLUE;
private:
RGB(int v) : Colors(v){}
};
RGB RGB::BLUE{10};
int main ()
{
std::cout << Colors::RED << " " << RGB::RED << std::endl;
}
int basic(EnumBase b) { return b; }
和int derived(EnumDeriv d) { return d; }
时,这些类型将无法转换为int
,尽管普通的枚举类型可以转换为int
。 当您尝试运行甚至像这个简单的代码:cout << basic(EnumBase::One) << endl;
时,您会收到错误消息:conversion from ‘EnumBase::<anonymous enum>’ to non-scalar type ‘EnumBase’ requested
。 可以通过添加一些转换运算符来解决这些问题。 - SasQ