C ++中类似Java的枚举：静态类成员的初始化

Question

I tried to mimic Java enumerations. Here's what I came up with:

template<typename Enumeration_Type>
class Enumeration {
public:
    static auto get(int value) -> const Enumeration_Type& {
        const auto result = getMap().find(value);
        return *dynamic_cast<const Enumeration_Type*>(result->second);
    };

    const int value;

    Enumeration(const Enumeration& other) = delete;
    Enumeration(Enumeration&& other) noexcept = delete;
    auto operator=(const Enumeration& other) -> Enumeration& = delete;
    auto operator=(Enumeration&& other) noexcept -> Enumeration& = delete;

    virtual operator int() const noexcept { return value; }
protected:
    explicit constexpr Enumeration(const int value)
        : value{value} { getMap().emplace(value, this); }

    ~Enumeration() = default;
private:
    static auto getMap() noexcept -> std::unordered_map<int, const Enumeration<Enumeration_Type>*>& {
        static std::unordered_map<int, const Enumeration<Enumeration_Type>*> map;
        return map;
    }
};
}

It's a base class for enumerations, it registers pointers to instances of derived types in the constructor - in this way it enables the static method get() to access enumerations by assigned values. And here's a derived class:

class DataType final: public Enumeration<DataType> {
public:
    static const DataType UNSIGNED_INT;
// Other types...

    const std::string_view name;

    using Enumeration<DataType>::get;
private:
    constexpr DataType(const int value, const std::string_view name) noexcept
        : Enumeration<DataType>{value},
          name{name} {}
};

Followed by the source file:

const DataType DataType::UNSIGNED_INT{0x1405, "UNSIGNED INT"};
// Other types...

It seems to work, but I'm afraid there might be no guarantee for static members in the derived class to be initialized and registered through the constructor before the first call to get() in the base class. For example: could the following happen: the map in the base class is empty on the call to get() ?

Answer 1

As already stated in my comment earlier, the static variables (Enum Values) are initialized in the dynamic initialization phase, which is before the main function is called. Therefore you are on the safe side as long as you do not use your 'enums' before the main function starts. The following demonstrates a case, where this can happen:

#include <unordered_map>
#include <iostream>
#include <tuple>

class no_such_enum_value_exception {};

template<typename Enumeration_Type>
class Enumeration {
    using MapType = std::unordered_map<int, const Enumeration<Enumeration_Type>*>;
public:
    static const Enumeration_Type& get(int value)
    {
        const MapType& EnumMap = getMap();
        const auto result = EnumMap.find(value);

        if (result ==  EnumMap.end()) throw no_such_enum_value_exception();

        return *dynamic_cast<const Enumeration_Type*>(result->second);
    };

    const int value;

    virtual operator int() const noexcept { return value; }

protected:
    explicit constexpr Enumeration(const int value)
        : value{value} { getMap().emplace(value, this); }

    ~Enumeration() = default;

private:
    static MapType& getMap() noexcept {
        static MapType map;
        return map;
    }

// moved down as they are not an important part of the interface
    Enumeration(const Enumeration& other) = delete;
    Enumeration(Enumeration&& other) noexcept = delete;
    auto operator=(const Enumeration& other) -> Enumeration& = delete;
    auto operator=(Enumeration&& other) noexcept -> Enumeration& = delete;
};


class DataType final: public Enumeration<DataType> {
public:
// Other types...

    const std::string_view name;

    using Enumeration<DataType>::get; // not needed get is available anyway
public:
    constexpr DataType(const int value, const std::string_view name) noexcept
        : Enumeration<DataType>{value},
        name{name} {}
};

class DataType2 final: public Enumeration<DataType2> {
public:
    DataType2(int value)
        : Enumeration<DataType2>{value}
    {
        try {
            const DataType& dt1_b = DataType::get(2);
            std::cout << "DataType::get(2): " << dt1_b.name << std::endl;
        }
        catch (const no_such_enum_value_exception&)
        {
            std::cout << "DataType::get(2) failed" << std::endl;
        }
    }
};

static const DataType DT1_A{1, "UNSIGNED INT"};
static const DataType2 DT2_A{1};
static const DataType DT1_B{2, "UNSIGNED INT"};
static const DataType2 DT2_B{2};


int main(int,char**){}

When you run this program you will get:

DataType::get(2) failed                                                                                                                                                                                                                            
DataType::get(2): UNSIGNED INT