Sınıf içindeki bir numaralandırma bildirme

Aşağıdaki kod snippet'inde, Colornumaralandırmanın Carkapsamını sınırlamak ve genel ad alanını "kirletmemek" için sınıflandırma sınıf içinde bildirilir .

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) Bu, Colornumaralandırma kapsamını sınırlamanın iyi bir yolu mu? Yoksa, Carsınıfın dışında , ancak muhtemelen kendi ad alanı veya yapısı içinde mi ilan etmeliyim ? Bugün bu makaleye geldim, ikincisini savunuyor ve numaralandırmalar hakkında bazı güzel noktaları tartışıyor: http://gamesfromwithin.com/stupid-c-tricks-2-better-enums .

(2) Bu örnekte, sınıf içinde çalışırken , sıralamayı en iyi şekilde kodlamak mı Car::Coloryoksa Coloryeterli olur mu? (Birincisinin daha iyi olduğunu düşünüyorum, Colorküresel ad alanında başka bir numaralandırma bildirilmesi durumunda . En azından, bahsettiğimiz numaralandırma hakkında açıkız.)

1. Eğer Colorsadece Cars'ye özgü bir şey varsa , o zaman kapsamını sınırlandırırsınız. ColorDiğer sınıfların kullandığı başka bir numaralandırma yapacaksanız, onu global (veya en azından dışarıda Car) yapabilirsiniz.

2. Fark yaratmıyor. Küresel bir tane varsa, o zaman yerel olan mevcut kapsama daha yakın olduğu için yine de kullanılır. Bu işlevi sınıf tanımının dışında tanımlarsanız Car::Color, işlevin arabiriminde açıkça belirtmeniz gerektiğini unutmayın .

Günümüzde - C ++ 11 kullanarak - bunun için enum sınıfını kullanabilirsiniz :

enum class Color { RED, BLUE, WHITE };

AFAII bu tam olarak ne istediğinizi yapar.

Aşağıdaki yaklaşımı tercih ediyorum (aşağıdaki kod). "Ad alanı kirliliği" sorununu çözer, ama aynı zamanda çok daha tipiktir (iki farklı numaralandırma ya da diğer yerleşik türlerle numaralandırmayı atayamaz ve hatta karşılaştıramazsınız).

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;
};

Kullanımı:

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

Kullanımı kolaylaştırmak için makro oluşturuyorum:

#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),

Kullanımı:

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

Bazı referanslar:

1. Herb Sutter, Jum Hyslop, C / C ++ Kullanıcı Günlüğü, 22 (5), Mayıs 2004
2. Herb Sutter, David E. Miller, Bjarne Stroustrup Güçlü Yazılan Numaralandırmalar (revizyon 3), Temmuz 2007

Genel olarak, numaralandırmalarımı her zaman bir struct. "Ön ek" dahil olmak üzere çeşitli yönergeler gördüm.

enum Color
{
  Clr_Red,
  Clr_Yellow,
  Clr_Blue,
};

Bunun her Czamankinden daha çok yönergeler gibi göründüğünü düşündüm C++(biri kısaltma ve ayrıca ad alanları nedeniyle C++).

Kapsamı sınırlamak için şimdi iki alternatifimiz var:

• ad
• yapılar / sınıfları

Ben şahsen kullanmak eğilimindedir structçünkü bir isim alanı manipüle edilemez iken şablon programlama için parametre olarak kullanılabilir.

Manipülasyon örnekleri şunları içerir:

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

bu yapı içindeki numaralandırma elemanlarının sayısını döndürür T:)

Bir kod kitaplığı oluşturuyorsanız, ad alanını kullanırdım. Ancak, yine de bu ad alanının içinde yalnızca bir Renk numaralandırma olabilir. Ortak bir ad kullanabilen, ancak farklı sınıflar için farklı sabitlere sahip olabilen bir numaralandırmaya ihtiyacınız varsa, yaklaşımınızı kullanın.