Comment implémenter une vraie classe enum en C++

Question

J'essaye d'implémenter un enum class qui se comporte comme celui introduit avec C++ 11 (avec le type de sécurité etc.) mais qui se comporte aussi comme une vraie classe (avec le constructeur , méthode, etc.). Pour ce faire, je gardais l'interne enum anonyme: effet cela avait le côté que pour garder m_value en tant que variable membre private, je devais ajouter une variable membre static nommé _, comme vous pouvez le voir ci-dessous:

#include <iostream> 
#include <experimental/string_view> 

class State 
{ 
public: 
    static enum 
    { 
     UNKNOWN, 
     STARTED, 
     STOPPED 
    } _; 

private: 

    using Type = decltype(_); 
    Type m_value; 

public: 

    constexpr State(Type value = UNKNOWN) 
     : m_value(value) 
    { } 

    constexpr bool operator==(Type value) const 
    { 
     return m_value == value; 
    } 

    constexpr std::experimental::string_view to_string() const 
    { 
     switch (m_value) 
     { 
     case UNKNOWN: return "UNKNOWN"; 
     case STARTED: return "STARTED"; 
     case STOPPED: return "STOPPED"; 
     } 
     return ""; 
    } 
}; 

State::Type State::_; 

int main() 
{ 
    State state; 
    std::cout << state.to_string() << std::endl; 

    state = State::STARTED; 
    std::cout << state.to_string() << std::endl; 

    if(state == State::STOPPED) 
    { 
     std::cout << state.to_string() << std::endl; 
    } 

    return 0; 
} 

Existe-t-il un moyen de se débarrasser de la variable static de membre inutile _? Je voudrais garder l'interne enum anonyme, et d'une manière ou d'une autre pour récupérer son type si nécessaire (= uniquement en privé).

Answer 1

Que diriez-vous simplement d'utiliser l'une des valeurs enum? par exemple:

//... 
enum 
{ 
    UNKNOWN, 
    STARTED, 
    STOPPED 
}; 

private: 

using Type = decltype(UNKNOWN); 
//... 

[live demo]