C ++ 'da int numaralandırmanın genel yolu

Döküm için genel bir yolu var mı inthiç enumde C++?

Bir intaralığına düşerse enumbir enumdeğer döndürmelidir , aksi takdirde bir exception. Genel olarak yazmanın bir yolu var mı ? Birden fazlası enum typedesteklenmelidir.

Arka plan: Harici bir enum türüne sahibim ve kaynak kodu üzerinde denetimim yok . Bu değeri bir veritabanında saklamak ve geri almak istiyorum.

Açık olan şey, numaranıza açıklama eklemektir:

// generic code
#include <algorithm>

template <typename T>
struct enum_traits {};

template<typename T, size_t N>
T *endof(T (&ra)[N]) {
    return ra + N;
}

template<typename T, typename ValType>
T check(ValType v) {
    typedef enum_traits<T> traits;
    const T *first = traits::enumerators;
    const T *last = endof(traits::enumerators);
    if (traits::sorted) { // probably premature optimization
        if (std::binary_search(first, last, v)) return T(v);
    } else if (std::find(first, last, v) != last) {
        return T(v);
    }
    throw "exception";
}

// "enhanced" definition of enum
enum e {
    x = 1,
    y = 4,
    z = 10,
};

template<>
struct enum_traits<e> {
    static const e enumerators[];
    static const bool sorted = true;
};
// must appear in only one TU,
// so if the above is in a header then it will need the array size
const e enum_traits<e>::enumerators[] = {x, y, z};

// usage
int main() {
    e good = check<e>(1);
    e bad = check<e>(2);
}

Dizinin güncel tutulması gerekiyor eki bu, yazarı değilseniz bir sıkıntıdır e. Sjoerd'in dediği gibi, muhtemelen herhangi bir düzgün inşa sistemi ile otomatikleştirilebilir.

Her durumda, 7.2 / 6'ya karşı çıkarsınız:

Emin'in en küçük numaralandırıcı olduğu ve emax'ın en büyük olduğu bir numaralandırma için, numaralandırmanın değerleri, bmin ve bmax'ın sırasıyla en küçük ve en büyük değerler olduğu bmin ila bmax aralığındaki temel tipin değerleridir. emin ve emax depolayabilen bit alanı. Numaralandırıcılarından herhangi biri tarafından tanımlanmamış değerlere sahip bir numaralandırma tanımlamak mümkündür.

Dolayısıyla, yazarı edeğilseniz, değerlerinin egerçekte tanımında göründüğüne dair bir garantiniz olabilir veya olmayabilir .

Çirkin.

enum MyEnum { one = 1, two = 2 };

MyEnum to_enum(int n)
{
  switch( n )
  {
    case 1 :  return one;
    case 2 : return two;
  }
  throw something();
}

Şimdi gerçek soru için. Niçin buna ihtiyacın var? Kod çirkin, yazması kolay değil (*?) Ve bakımı kolay değil ve kodunuza dahil edilmesi kolay değil. Yanlış olduğunu söyleyen kod. Neden onunla savaşalım?

DÜZENLE:

Alternatif olarak, numaralandırmaların C ++ 'da integral türler olduğu göz önüne alındığında:

enum my_enum_val = static_cast<MyEnum>(my_int_val);

ama bu, yukarıdakinden daha da çirkin, hatalara çok daha yatkındır ve istediğiniz gibi atmayacaktır.

Tanımladığınız gibi, değerler bir veritabanındaysa, neden bu tabloyu okuyan ve hem numaralandırma hem de to_enum(int)işlevle bir .h ve .cpp dosyası oluşturan bir kod üreteci yazmıyorsunuz ?

Avantajlar:

• Bir to_string(my_enum)işlev eklemek kolaydır .
• Az bakım gerektirir
• Veritabanı ve kod senkronize

Hayır- C ++ 'da iç gözlem veya yerleşik "alan denetimi" olanağı yoktur.

Bunun hakkında ne düşünüyorsun?

#include <iostream>
#include <stdexcept>
#include <set>
#include <string>

using namespace std;

template<typename T>
class Enum
{
public:
    static void insert(int value)
    {
        _set.insert(value);
    }

    static T buildFrom(int value)
    {
        if (_set.find(value) != _set.end()) {
            T retval;
            retval.assign(value);
            return retval;
        }
        throw std::runtime_error("unexpected value");
    }

    operator int() const { return _value; }

private:
    void assign(int value)
    {
        _value = value;
    }

    int _value;
    static std::set<int> _set;
};

template<typename T> std::set<int> Enum<T>::_set;

class Apples: public Enum<Apples> {};

class Oranges: public Enum<Oranges> {};

class Proxy
{
public:
    Proxy(int value): _value(value) {}

    template<typename T>
    operator T()
    {
        T theEnum;
        return theEnum.buildFrom(_value);
    }

    int _value;
};

Proxy convert(int value)
{
    return Proxy(value);
}

int main()
{    
    Apples::insert(4);
    Apples::insert(8);

    Apples a = convert(4); // works
    std::cout << a << std::endl; // prints 4

    try {
        Apples b = convert(9); // throws    
    }
    catch (std::exception const& e) {
        std::cout << e.what() << std::endl; // prints "unexpected value"
    }
    try {
        Oranges b = convert(4); // also throws  
    }
    catch (std::exception const& e) {
        std::cout << e.what() << std::endl; // prints "unexpected value"
    }
}

Daha sonra değerleri değiştirmek için buraya gönderdiğim kodu kullanabilirsiniz .

Tarif ettiğiniz gibi bir şeyin var olmasını istememelisiniz, korkarım kod tasarımınızda problemler vardır.

Ayrıca, numaralandırmaların bir aralıkta geldiğini varsayarsınız, ancak bu her zaman böyle değildir:

enum Flags { one = 1, two = 2, four = 4, eigh = 8, big = 2000000000 };

Bu bir aralıkta değil: Mümkün olsa bile, 0'dan 2 ^ n'ye kadar olan her tamsayıyı bir numaralandırma değeriyle eşleşip eşleşmediklerini kontrol etmeniz mi gerekiyor?

Enum değerlerinizi şablon parametreleri olarak listelemeye hazırsanız, bunu C ++ 11'de varadic şablonlarla yapabilirsiniz. Buna, farklı bağlamlarda geçerli enum değerlerinin alt kümelerini kabul etmenize izin veren iyi bir şey olarak bakabilirsiniz; dış kaynaklardaki kodları ayrıştırırken genellikle yararlıdır.

Belki de istediğiniz kadar genel olmayabilir, ancak kontrol kodunun kendisi genelleştirilmiştir, sadece değerler kümesini belirlemeniz gerekir. Bu yaklaşım boşlukları, keyfi değerleri vb. Ele alır.

template<typename EnumType, EnumType... Values> class EnumCheck;

template<typename EnumType> class EnumCheck<EnumType>
{
public:
    template<typename IntType>
    static bool constexpr is_value(IntType) { return false; }
};

template<typename EnumType, EnumType V, EnumType... Next>
class EnumCheck<EnumType, V, Next...> : private EnumCheck<EnumType, Next...>
{
    using super = EnumCheck<EnumType, Next...>;

public:
    template<typename IntType>
    static bool constexpr is_value(IntType v)
    {
        return v == static_cast<typename std::underlying_type<EnumType>::type>(V) || super::is_value(v);
    }

    EnumType convert(IntType v)
    {
        if (!is_value(v)) throw std::runtime_error("Enum value out of range");
        return static_cast<EnumType>(v);
};

enum class Test {
    A = 1,
    C = 3,
    E = 5
};

using TestCheck = EnumCheck<Test, Test::A, Test::C, Test::E>;

void check_value(int v)
{
    if (TestCheck::is_value(v))
        printf("%d is OK\n", v);
    else
        printf("%d is not OK\n", v);
}

int main()
{
    for (int i = 0; i < 10; ++i)
        check_value(i);
}

"Çirkin" sürüme alternatif C ++ 0x, birden çok numaralandırmaya izin verir. Anahtarlar yerine başlatıcı listeleri kullanır, biraz daha temiz IMO. Maalesef bu, enum değerlerini sabit kodlama ihtiyacını ortadan kaldırmaz.

#include <cassert>  // assert

namespace  // unnamed namespace
{
    enum class e1 { value_1 = 1, value_2 = 2 };
    enum class e2 { value_3 = 3, value_4 = 4 };

    template <typename T>
    int valid_enum( const int val, const T& vec )
    {
        for ( const auto item : vec )
            if ( static_cast<int>( item ) == val ) return val;

        throw std::exception( "invalid enum value!" );  // throw something useful here
    }   // valid_enum
}   // ns

int main()
{
    // generate list of valid values
    const auto e1_valid_values = { e1::value_1, e1::value_2 };
    const auto e2_valid_values = { e2::value_3, e2::value_4 };

    auto result1 = static_cast<e1>( valid_enum( 1, e1_valid_values ) );
    assert( result1 == e1::value_1 );

    auto result2 = static_cast<e2>( valid_enum( 3, e2_valid_values ) );
    assert( result2 == e2::value_3 );

    // test throw on invalid value
    try
    {
        auto result3 = static_cast<e1>( valid_enum( 9999999, e1_valid_values ) );
        assert( false );
    }
    catch ( ... )
    {
        assert( true );
    }
}