enum türleri için ad alanları - en iyi yöntemler

Çoğu zaman, birkaç numaralandırılmış türe birlikte ihtiyaç duyar. Bazen isim çatışması yaşanır. Bunun için iki çözüm akla geliyor: bir ad alanı veya 'daha büyük' ​​enum öğe adları kullanın. Yine de ad alanı çözümünün iki olası uygulaması vardır: iç içe enum içeren bir kukla sınıf veya tam gelişmiş bir ad alanı.

Üç yaklaşımın da artılarını ve eksilerini arıyorum.

Misal:

// oft seen hand-crafted name clash solution
enum eColors { cRed, cColorBlue, cGreen, cYellow, cColorsEnd };
enum eFeelings { cAngry, cFeelingBlue, cHappy, cFeelingsEnd };
void setPenColor( const eColors c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cColorBlue: //...
        //...
    }
 }


// (ab)using a class as a namespace
class Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
class Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
 }


 // a real namespace?
 namespace Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
 namespace Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
 void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
  }

Orijinal C ++ 03 yanıtı:

Yarar bir gelen namespace(üzerinde classkendinizin kullanabileceği) 'dir usingistediğiniz zaman bildirimleri.

A kullanmanın sorununamespace , ad alanlarının kodun başka bir yerinde genişletilebilmesidir. Büyük bir projede, iki farklı numaralandırmanın her ikisinin de çağrıldığını düşünmeyeceği garanti edilemez.eFeelings

Daha basit görünen kod için, structmuhtemelen içeriğin herkese açık olmasını istediğiniz için a kullanıyorum .

Bu uygulamalardan herhangi birini yapıyorsanız, eğrinin önündesiniz ve muhtemelen bunu daha fazla incelemeniz gerekmiyor.

Daha yeni, C ++ 11 tavsiyesi:

C ++ 11 veya sonraki bir sürümünü kullanıyorsanız enum class, numaralandırmanın adı içindeki enum değerlerini örtük olarak kapsayacaktır.

İle enum classsize belirsiz veya hatalı kod keşfetmenize yardımcı olabilir örtük dönüşüm ve tamsayı türlerine karşılaştırmalar, ama pratikte kaybedecektir.

Bilginize C ++ 0x'de, bahsettiğiniz gibi durumlar için yeni bir sözdizimi vardır (bkz. C ++ 0x wiki sayfası )

enum class eColors { ... };
enum class eFeelings { ... };

Önceki cevapları şöyle bir şeye hibritledim: (DÜZENLE: Bu yalnızca C ++ 11 öncesi için kullanışlıdır. C ++ 11 kullanıyorsanız, kullanın enum class)

Tüm proje numaralarımı içeren büyük bir başlık dosyam var, çünkü bu numaralandırmalar işçi sınıfları arasında paylaşılıyor ve numaralandırmaları işçi sınıflarının içine koymak mantıklı değil.

Bu struct, public: sözdizimsel şekerden kaçınır ve typedefbu numaralandırmaların değişkenlerini diğer işçi sınıfları içinde gerçekten bildirmenize izin verir.

Bir ad alanı kullanmanın hiç yardımcı olduğunu sanmıyorum. Belki bir C # programcı olduğum için bu, ve orada var değerlerini bahsederken ben buna alışığım bu yüzden, enum türü adı kullanmak.

    struct KeySource {
        typedef enum { 
            None, 
            Efuse, 
            Bbram
        } Type;
    };

    struct Checksum {
        typedef enum {
            None =0,
            MD5 = 1,
            SHA1 = 2,
            SHA2 = 3
        } Type;
    };

    struct Encryption {
        typedef enum {
            Undetermined,
            None,
            AES
        } Type;
    };

    struct File {
        typedef enum {
            Unknown = 0,
            MCS,
            MEM,
            BIN,
            HEX
        } Type;
    };

...

class Worker {
    File::Type fileType;
    void DoIt() {
       switch(fileType) {
       case File::MCS: ... ;
       case File::MEM: ... ;
       case File::HEX: ... ;
    }
}

Bunun için bir sınıf kullanmaktan kesinlikle kaçınırım; bunun yerine bir ad alanı kullanın. Soru, bir ad alanı kullanıp kullanmamaya veya enum değerleri için benzersiz kimlikler kullanıp kullanmamaya bağlıdır. Şahsen, kimliklerimin daha kısa ve umarım daha açıklayıcı olması için bir ad alanı kullanırdım. Daha sonra uygulama kodu bir 'ad alanını kullanma' yönergesi kullanabilir ve her şeyi daha okunaklı hale getirebilir.

Yukarıdaki örneğinizden:

using namespace Colors;

void setPenColor( const e c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cBlue: //...
        //...
    }
}

Bir sınıf veya bir ad alanı kullanmak arasındaki fark, sınıfın bir ad alanı gibi yeniden açılamamasıdır. Bu, ad alanının gelecekte kötüye kullanılması olasılığını ortadan kaldırır, ancak aynı zamanda numaralandırma kümesine ekleyemeyeceğiniz bir sorun da vardır.

Bir sınıfı kullanmanın olası bir yararı, ad alanları için geçerli olmayan şablon türü argümanları olarak kullanılabilmeleridir:

class Colors {
public:
  enum TYPE {
    Red,
    Green,
    Blue
  };
};

template <typename T> void foo (T t) {
  typedef typename T::TYPE EnumType;
  // ...
}

Kişisel olarak, kullanmanın hayranı değilim ve tam nitelikli isimleri tercih ediyorum, bu yüzden bunu isim alanları için bir artı olarak görmüyorum. Ancak, bu muhtemelen projenizde vereceğiniz en önemli karar değil!

Bir sınıf kullanmanın avantajı, üzerine tam teşekküllü bir sınıf oluşturabilmenizdir.

#include <cassert>

class Color
{
public:
    typedef enum
    {
        Red,
        Blue,
        Green,
        Yellow
    } enum_type;

private:
    enum_type _val;

public:
    Color(enum_type val = Blue)
        : _val(val)
    {
        assert(val <= Yellow);
    }

    operator enum_type() const
    {
        return _val;
    }
};

void SetPenColor(const Color c)
{
    switch (c)
    {
        case Color::Red:
            // ...
            break;
    }
}

Yukarıdaki örnekte gösterildiği gibi, bir sınıf kullanarak şunları yapabilirsiniz:

1. C ++ 'ın geçersiz değerden bir dönüşüm yapılmasına izin vermesini yasaklayın (ne yazık ki derleme zamanı değil),
2. yeni oluşturulan numaralandırmalar için bir (sıfır olmayan) varsayılan ayarlayın,
3. Bir seçimin dize gösterimini döndürmek gibi başka yöntemler ekleyin.

operator enum_type()C ++ 'nın sınıfınızı temel numaralandırmaya nasıl dönüştüreceğinizi bilmesi için bildirmeniz gerektiğini unutmayın . Aksi takdirde, türü bir switchifadeye geçiremezsiniz .

Numaralandırmalar kapsama alanlarına göre ayarlandığından , genel ad alanını kirletmekten kaçınmak ve ad çakışmalarını önlemeye yardımcı olmak için bunları bir şeye sarmak muhtemelen en iyisidir . Ben sınıfa bir ad tercih çünkü namespacetutma torbası gibi hissediyor, oysa classsağlam bir nesne gibi hissediyor (Bkz structvs classtartışma). Bir ad alanının olası bir yararı, daha sonra genişletilebilmesidir - değiştiremeyeceğiniz üçüncü taraf koduyla uğraşıyorsanız kullanışlıdır.

C ++ 0x ile enum sınıfları aldığımızda elbette bu tartışmalı bir konudur.

Ayrıca numaralarımı derslere sarma eğilimindeyim.

Richard Corden'in işaret ettiği gibi, bir sınıfın yararı, c ++ anlamında bir tür olması ve böylece onu şablonlarla kullanabilmenizdir.

İhtiyaçlarım için özel toolbox :: Enum sınıfım var, temel işlevleri sağlayan her şablon için uzmanlaştım (esas olarak: bir enum değerini bir std :: string'e eşleyerek G / Ç'nin daha kolay okunması için).

Benim küçük şablonum, izin verilen değerleri gerçekten kontrol etme avantajına da sahiptir. Derleyici, değerin gerçekten enum'da olup olmadığını kontrol etmekte biraz gevşek:

typedef enum { False: 0, True: 2 } boolean;
   // The classic enum you don't want to see around your code ;)

int main(int argc, char* argv[])
{
  boolean x = static_cast<boolean>(1);
  return (x == False || x == True) ? 0 : 1;
} // main

Hiçbir anlamı olmayan (ve beklemeyeceğiniz) bir enum değeriyle kaldığınız için derleyicinin bunu yakalayamaması beni her zaman rahatsız etti.

Benzer şekilde:

typedef enum { Zero: 0, One: 1, Two: 2 } example;

int main(int argc, char* argv[])
{
  example y = static_cast<example>(3);
  return (y == Zero || y == One || y == Two) ? 0 : 1;
} // main

Bir kez daha main bir hata döndürür.

Sorun, derleyicinin mevcut en küçük gösterime sığmasıdır (burada 2 bite ihtiyacımız var) ve bu gösterime uyan her şeyin geçerli bir değer olarak kabul edilmesi.

Bazen bir anahtar yerine olası değerler üzerinde bir döngüye sahip olmayı tercih edeceğiniz bir sorun da vardır, böylece numaralandırmaya her değer eklediğinizde tüm anahtarlarınızı değiştirmek zorunda kalmazsınız.

Sonuçta benim küçük yardımcım, numaralandırmalarım için işleri gerçekten kolaylaştırıyor (elbette, bazı ek yükler ekler) ve bu yalnızca, her numaralamayı kendi yapısına yerleştirdiğim için mümkündür :)