Dichiarare un enum all'interno di una classe

Nel seguente frammento di codice, l' Colorenum viene dichiarato all'interno della Carclasse al fine di limitare l'ambito dell'enum e cercare di non "inquinare" lo spazio dei nomi globale.

class Car
{
public:

   enum Color
   {
      RED,
      BLUE,
      WHITE
   };

   void SetColor( Car::Color color )
   {
      _color = color;
   }

   Car::Color GetColor() const
   {
      return _color;
   }

private:

   Car::Color _color;

};

(1) È un buon modo per limitare la portata Colordell'enum? O dovrei dichiararlo al di fuori della Carclasse, ma possibilmente all'interno del suo spazio dei nomi o struttura? Ho appena trovato questo articolo oggi, che sostiene quest'ultimo e discute alcuni bei punti sugli enum: http://gamesfromwithin.com/stupid-c-tricks-2-better-enums .

(2) In questo esempio, quando si lavora all'interno della classe, è meglio codificare l'enum come Car::Coloro sarebbe Colorsufficiente? (Suppongo che il primo sia migliore, nel caso in cui ci sia un altro Colorenum dichiarato nello spazio dei nomi globale. In questo modo, almeno, siamo espliciti sull'enum a cui ci stiamo riferendo.)

1. Se Colorè qualcosa che è specifico solo per Cars, questo è il modo in cui ne limiteresti l'ambito. Se hai un altro Colorenum che altre classi usano, potresti anche renderlo globale (o almeno esterno Car).

2. Non fa differenza. Se ce n'è uno globale, quello locale viene comunque utilizzato in quanto è più vicino all'ambito attuale. Si noti che se si definiscono tali funzioni al di fuori della definizione della classe, sarà necessario specificare esplicitamente Car::Colornell'interfaccia della funzione.

Al giorno d'oggi - usando C ++ 11 - puoi usare la classe enum per questo:

enum class Color { RED, BLUE, WHITE };

AFAII questo fa esattamente quello che vuoi.

Preferisco seguire l'approccio (codice sotto). Risolve il problema dell '"inquinamento dello spazio dei nomi", ma è anche molto più semplice (non puoi assegnare e nemmeno confrontare due diverse enumerazioni o la tua enumerazione con altri tipi predefiniti, ecc.).

struct Color
{
    enum Type
    {
        Red, Green, Black
    };
    Type t_;
    Color(Type t) : t_(t) {}
    operator Type () const {return t_;}
private:
   //prevent automatic conversion for any other built-in types such as bool, int, etc
   template<typename T>
    operator T () const;
};

Uso:

Color c = Color::Red;
switch(c)
{
   case Color::Red:
     //некоторый код
   break;
}
Color2 c2 = Color2::Green;
c2 = c; //error
c2 = 3; //error
if (c2 == Color::Red ) {} //error
If (c2) {} error

Creo macro per facilitare l'utilizzo:

#define DEFINE_SIMPLE_ENUM(EnumName, seq) \
struct EnumName {\
   enum type \
   { \
      BOOST_PP_SEQ_FOR_EACH_I(DEFINE_SIMPLE_ENUM_VAL, EnumName, seq)\
   }; \
   type v; \
   EnumName(type v) : v(v) {} \
   operator type() const {return v;} \
private: \
    template<typename T> \
    operator T () const;};\

#define DEFINE_SIMPLE_ENUM_VAL(r, data, i, record) \
    BOOST_PP_TUPLE_ELEM(2, 0, record) = BOOST_PP_TUPLE_ELEM(2, 1, record),

Uso:

DEFINE_SIMPLE_ENUM(Color,
             ((Red, 1))
             ((Green, 3))
             )

Alcuni riferimenti:

1. Herb Sutter, Jum Hyslop, C / C ++ Users Journal, 22 (5), maggio 2004
2. Herb Sutter, David E. Miller, Bjarne Stroustrup Enumerazioni fortemente tipizzate (revisione 3), luglio 2007

In generale, ho sempre messo le mie enumerazioni in a struct. Ho visto diverse linee guida tra cui "prefisso".

enum Color
{
  Clr_Red,
  Clr_Yellow,
  Clr_Blue,
};

Ho sempre pensato che questo assomigliava più a Clinee guida che a C++quelle (per uno a causa dell'abbreviazione e anche per gli spazi dei nomi in C++).

Quindi per limitare l'ambito abbiamo ora due alternative:

• spazi dei nomi
• struct / classes

Personalmente tendo a usare a structperché può essere usato come parametro per la programmazione dei template mentre uno spazio dei nomi non può essere manipolato.

Esempi di manipolazione includono:

template <class T>
size_t number() { /**/ }

che restituisce il numero di elementi di enum all'interno della struttura T:)

Se stai creando una libreria di codici, utilizzerei lo spazio dei nomi. Tuttavia, puoi comunque avere solo un enum Color all'interno di quello spazio dei nomi. Se hai bisogno di un enum che potrebbe usare un nome comune, ma potrebbe avere costanti diverse per classi diverse, usa il tuo approccio.