"Inheritable" enums

enum-inherit.cpp

#include <iostream>

struct BaseEnum
{
public:
    operator int() const { return this->type_; }

protected:
    inline BaseEnum(int type) : type_(type) {}

private:
    int type_;
};

struct DefaultEnumValue : public BaseEnum
{
public:
    inline DefaultEnumValue() : BaseEnum(0) {}
};

struct ExtendedEnum : public BaseEnum
{
    enum EExtendedEnum
    {
        FirstValue,
        SecondValue
    };

    explicit inline ExtendedEnum(EExtendedEnum type) : BaseEnum(static_cast<int>(type)) {}
};

int main()
{
    std::cout << "DefaultEnumValue value: " << DefaultEnumValue() << " (" << sizeof(DefaultEnumValue) << " bytes)" << std::endl;
    std::cout << "ExtendedEnum::SecondValue value: " << ExtendedEnum(ExtendedEnum::SecondValue) << " (" << sizeof(ExtendedEnum) << " bytes)" << std::endl;

    return 0;
}

The basic idea can be extended into an even more horrifying code, such as:

struct ExtendedEnum : public BaseEnum
{
    enum EExtendedEnum
    {
        FirstValue,
        SecondValue
    };

    explicit inline ExtendedEnum(EExtendedEnum type) : BaseEnum(static_cast<int>(type)) {}

protected:
    inline ExtendedEnum(int type) : BaseEnum(type + SecondValue + 1) {}
};

struct EvenMoreExtendedEnum : public ExtendedEnum
{
    enum EEvenMoreExtendedEnum
    {
        FirstValue,
        SecondValue
    };

    explicit inline EvenMoreExtendedEnum(EEvenMoreExtendedEnum type) : ExtendedEnum(static_cast<int>(type)) {}
};

But that's just evil.