Equivalente di "utilizzo dello spazio dei nomi X" per le enumerazioni con ambito?

Question

Sto utilizzando un enumerato ambito per enumerare gli stati in una macchina a stati che sto implementando. Per esempio, diciamo qualcosa di simile:

enum class CatState 
{ 
    sleeping, 
    napping, 
    resting 
}; 

Nel mio file cpp in cui mi definisco un tavolo transizione di stato, vorrei utilizzare qualcosa di equivalente a using namespace X in modo che io non ho bisogno di prefisso tutti i miei nomi degli stati con CatState::. In altre parole, mi piacerebbe utilizzare sleeping anziché CatState::sleeping. La mia tabella di transizione ha alcune colonne, quindi evitare il prefisso CatState:: manterrebbe le cose più compatte e leggibili.

Quindi, c'è un modo per evitare di dover digitare CatState:: tutto il tempo?

---

^{Sì, sì, io sono già consapevoli delle insidie ​​di using namespace. Se esiste un equivalente per enumerazioni fortemente tipizzate, prometto di usarlo solo in un ambito limitato nel mio file di implementazione cpp, e non per il male.}

Answer 1

Quindi, c'è un modo per evitare di dover digitare CatState:: tutto il tempo?

No. Proprio come non esiste un equivalente per dover digitare ClassName:: per membri di classe statici. Non puoi dire using typename ClassName e poi raggiungere la parte interna. Lo stesso vale per gli enum s fortemente tipizzati.

Naturalmente non è possibile utilizzare la sintassi enum class, utilizzando solo i normali enum s. Ma poi perdi forte digitazione.

Va notato che uno dei motivi per l'utilizzo di ALL_CAPS per le enumerazioni debolmente tipizzate era evitare conflitti di nome. Una volta che abbiamo un ambito completo e una digitazione forte, il nome di un enum è identificato in modo univoco e non può essere in conflitto con altri nomi. Essere in grado di portare questi nomi in ambito namespace potrebbe reintrodurre questo problema. Quindi probabilmente vorrai usare ancora ALL_CAPS per aiutare a chiarire i nomi.

Answer 2

si potrebbe considerare l'utilizzo di un typedef per accorciare i nomi qualificati:

typedef CatState C; 

Oppure, se le colonne sono ripetitive in modo che essi possono essere generati facilmente, si potrebbe considerare l'utilizzo di una macro per generare ogni riga nella tabella, che può portare a un codice molto conciso (e più facile da leggere).

Answer 3

La risposta di Nicol è corretta: il linguaggio è progettato per farti qualificare sempre gli enumeratori con ambito (tranne nello scope enum { } stesso).

Tuttavia, here is a technique Mi sono avvicinato per gli enumeratori "scoped" che sono senza ambito all'interno delle classi selezionate. Tecnicamente, gli enumeratori sono senza ambito, quindi convertiranno ancora implicitamente in int. (Non "fortemente tipizzato" come lo metti.) Tuttavia, nell'idioma sono accessibili usando l'operatore scope dopo un vero nome enum, quindi sintatticamente non c'è una differenza - e quindi richiede C++ 11.

#define IMPORTABLE_ENUM(TYPENAME, ...) \ 
\ 
struct import_ ## TYPENAME { \ 
    enum TYPENAME { \ 
     __VA_ARGS__ \ 
    }; \ 
}; \ 
\ 
typedef import_ ## TYPENAME :: TYPENAME TYPENAME; 

// usage: 
IMPORTABLE_ENUM (duck, huey, dewey, louie) 

duck d = duck::dewey; // can't use unscoped enumerators here 

struct duck_madness : private import_duck { // but inside a derived class 
    duck who_did_it() { return huey; } // qualification is unnecessary 
}; 

Answer 4

Mi piacerebbe anche avere questa possibilità e trovo la limitazione piuttosto fastidiosa.Di solito è meglio che il programmatore decida quali funzionalità desidera utilizzare. O scoping esplicito o il modo più conveniente. Se si limita il programmatore, o perderà l'intera funzionalità per comodità o inventerà brutte soluzioni alternative, come il seguente enum sicuro basato sul modello. Avrà un overhead quando compilato senza ottimizzazione.

template<class _Enum> 
class type_safe_enum 
{ 
private: 
    _Enum m_EnumValue; 
    operator int(); 
public: 
    inline operator _Enum() const { return m_EnumValue; } 
    inline void operator =(_Enum x) { m_EnumValue = x; } 
}; 

enum _MY_ENUM 
{ 
    Value1, 
    Value2 
}; 

enum _MY_ENUM2 
{ 
    Value3, 
    Value4 
}; 

typedef type_safe_enum<_MY_ENUM> MY_ENUM; 

void TestMyEnum() 
{ 
    MY_ENUM myEnum; 
    int x; 

    myEnum = Value1; // ok 
    // myEnum = Value3; // compilation error 
    // myEnum = 0; // compilation error 
    // x = myEnum; // compilation error 

}