Güçlü yazılan numaralandırmayı otomatik olarak int'e nasıl dönüştürebilirim?

#include <iostream>

struct a {
  enum LOCAL_A { A1, A2 };
};
enum class b { B1, B2 };

int foo(int input) { return input; }

int main(void) {
  std::cout << foo(a::A1) << std::endl;
  std::cout << foo(static_cast<int>(b::B2)) << std::endl;
}

a::LOCAL_AKesinlikle yazılı Çeteleler alçıda olmadan bunu yapamaz iken, normal çeteleler, tamsayı türü dönüştürülebilir: kesinlikle yazılı enum ulaşmak için çalışıyor, ama küçük bir fark vardır budur.

Peki, güçlü bir şekilde türlenmiş bir enum değerini, cast olmadan bir tamsayı türüne dönüştürmenin bir yolu var mı? Evet ise, nasıl?

Birden fazla sorunu çözmeyi amaçlayan ve yalnızca sorunuzda belirttiğiniz gibi kapsam belirleme sorununu değil, güçlü bir şekilde yazılmış numaralandırmalar:

1. Tip güvenliği sağlayın, böylece entegre tanıtım ile tam sayıya örtük dönüşümü ortadan kaldırın.
2. Temel türleri belirtin.
3. Güçlü kapsam belirleme sağlayın.

Bu nedenle, kuvvetle yazılan bir sayıyı tamsayılara, hatta altta yatan türüne örtük olarak dönüştürmek imkansızdır - fikir budur. Bu yüzden static_castdönüşümü açık yapmak için kullanmanız gerekir.

Tek probleminiz kapsamayı içeriyorsa ve gerçekten de tamsayılara örtük bir tanıtım yapmak istiyorsanız, bildirildiği yapının kapsamı ile güçlü yazılmamış numaralandırma kullanarak daha iyi durumda olursunuz.

Diğerlerinin söylediği gibi, örtük bir dönüşüme sahip olamazsınız ve bu tasarım gereğidir.

İsterseniz, dökümde altta yatan türü belirtme gereksinimini ortadan kaldırabilirsiniz.

template <typename E>
constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept {
    return static_cast<typename std::underlying_type<E>::type>(e);
}

std::cout << foo(to_underlying(b::B2)) << std::endl;

R. Martinho Fernandes tarafından verilen cevabın C ++ 14 versiyonu :

#include <type_traits>

template <typename E>
constexpr auto to_underlying(E e) noexcept
{
    return static_cast<std::underlying_type_t<E>>(e);
}

Önceki cevapta olduğu gibi, bu her türlü numaralandırma ve altta yatan tiple çalışacaktır. noexceptAsla bir istisna atmayacak gibi anahtar kelime ekledim .

Güncelleme
Bu ayrıca Scott Meyers tarafından Effective Modern C ++ ' da da görülmektedir . 10. maddeye bakınız (kitabın kopyasındaki öğenin son sayfalarında ayrıntılı olarak verilmiştir).

#include <cstdlib>
#include <cstdio>
#include <cstdint>

#include <type_traits>

namespace utils
{

namespace details
{

template< typename E >
using enable_enum_t = typename std::enable_if< std::is_enum<E>::value, 
                                               typename std::underlying_type<E>::type 
                                             >::type;

}   // namespace details


template< typename E >
constexpr inline details::enable_enum_t<E> underlying_value( E e )noexcept
{
    return static_cast< typename std::underlying_type<E>::type >( e );
}   


template< typename E , typename T>
constexpr inline typename std::enable_if< std::is_enum<E>::value &&
                                          std::is_integral<T>::value, E
                                         >::type 
 to_enum( T value ) noexcept 
 {
     return static_cast<E>( value );
 }

} // namespace utils




int main()
{
    enum class E{ a = 1, b = 3, c = 5 };

    constexpr auto a = utils::underlying_value(E::a);
    constexpr E    b = utils::to_enum<E>(5);
    constexpr auto bv = utils::underlying_value(b);

    printf("a = %d, b = %d", a,bv);
    return 0;
}

Hayır . Doğal bir yol yok .

Aslında, enum classC ++ 11'e güçlü bir şekilde yazmanın ardındaki motivasyonlardan biri, sessiz dönüşümlerini önlemektir int.

Örtük dönüşümün (tasarım gereği) olmamasının nedeni diğer cevaplarda verilmiştir.

Ben şahsen operator+enum sınıflarından onların altta yatan tür dönüşüm için unary kullanın :

template <typename T>
constexpr auto operator+(T e) noexcept
    -> std::enable_if_t<std::is_enum<T>::value, std::underlying_type_t<T>>
{
    return static_cast<std::underlying_type_t<T>>(e);
}

Hangi oldukça az "yazarak yükü" verir:

std::cout << foo(+b::B2) << std::endl;

Ben aslında bir makro numaralandırmalar oluşturmak ve operatör tek çekimde çalışır.

#define UNSIGNED_ENUM_CLASS(name, ...) enum class name : unsigned { __VA_ARGS__ };\
inline constexpr unsigned operator+ (name const val) { return static_cast<unsigned>(val); }

Umarım bu size veya başka birine yardımcı olur

enum class EnumClass : int //set size for enum
{
    Zero, One, Two, Three, Four
};

union Union //This will allow us to convert
{
    EnumClass ec;
    int i;
};

int main()
{
using namespace std;

//convert from strongly typed enum to int

Union un2;
un2.ec = EnumClass::Three;

cout << "un2.i = " << un2.i << endl;

//convert from int to strongly typed enum
Union un;
un.i = 0; 

if(un.ec == EnumClass::Zero) cout << "True" << endl;

return 0;
}

Kısa cevap, yukarıdaki yayınların işaret ettiği gibi yapamazsınız. Ama benim durumum için, sadece ad alanını karıştırmak istemedim ama yine de örtük dönüşümler var, bu yüzden yaptım:

#include <iostream>

using namespace std;

namespace Foo {
   enum Foo { bar, baz };
}

int main() {
   cout << Foo::bar << endl; // 0
   cout << Foo::baz << endl; // 1
   return 0;
}

Altta yatan türe herhangi bir enum değeri statik olarak dökmek zorunda değilken, ad türü bir tür güvenlik katmanı ekler.

Bu yerli ile imkansız görünüyor enum class, ama muhtemelen bir enum classile aclass :

Bu durumda,

enum class b
{
    B1,
    B2
};

şuna eşdeğer olur:

class b {
 private:
  int underlying;
 public:
  static constexpr int B1 = 0;
  static constexpr int B2 = 1;
  b(int v) : underlying(v) {}
  operator int() {
      return underlying;
  }
};

Bu çoğunlukla orijinaline eşdeğerdir enum class. b::B1Dönüş türü olan bir işlevde doğrudan geri dönebilirsiniz b. switch caseBununla vb. Yapabilirsiniz .

Ve bu örneğin ruhuyla, enum classsözdizimi tarafından tanımlanan olası herhangi bir nesneyi genelleştirmek ve alay etmek için şablonları (muhtemelen diğer şeylerle birlikte) kullanabilirsiniz .

Birçoğunun dediği gibi, genel giderler ve çok fazla karmaşıklık eklemeden otomatik olarak dönüştürmenin bir yolu yoktur, ancak bir senaryoda biraz döküm kullanılacaksa lambdas kullanarak lambda'ları kullanarak daha iyi görünmesini sağlayabilirsiniz. Bu, biraz işlev ek yükü ekler, ancak kodu aşağıda görüldüğü gibi uzun static_cast dizelerine kıyasla daha okunabilir hale getirir. Bu proje çapında yararlı olmayabilir, sadece sınıf çapında olabilir.

#include <bitset>
#include <vector>

enum class Flags { ......, Total };
std::bitset<static_cast<unsigned int>(Total)> MaskVar;
std::vector<Flags> NewFlags;

-----------
auto scui = [](Flags a){return static_cast<unsigned int>(a); };

for (auto const& it : NewFlags)
{
    switch (it)
    {
    case Flags::Horizontal:
        MaskVar.set(scui(Flags::Horizontal));
        MaskVar.reset(scui(Flags::Vertical)); break;
    case Flags::Vertical:
        MaskVar.set(scui(Flags::Vertical));
        MaskVar.reset(scui(Flags::Horizontal)); break;

   case Flags::LongText:
        MaskVar.set(scui(Flags::LongText));
        MaskVar.reset(scui(Flags::ShorTText)); break;
    case Flags::ShorTText:
        MaskVar.set(scui(Flags::ShorTText));
        MaskVar.reset(scui(Flags::LongText)); break;

    case Flags::ShowHeading:
        MaskVar.set(scui(Flags::ShowHeading));
        MaskVar.reset(scui(Flags::NoShowHeading)); break;
    case Flags::NoShowHeading:
        MaskVar.set(scui(Flags::NoShowHeading));
        MaskVar.reset(scui(Flags::ShowHeading)); break;

    default:
        break;
    }
}

C ++ komitesi bir adım ileri (küresel ad alanından numaralandırma kapsamı) ve elli adım geri (tamsayıya enum tipi bozulma yok) gitti. Ne yazık ki,enum class enumun değerine sembolik olmayan bir şekilde ihtiyacınız varsa, sadece kullanılamaz.

En iyi çözüm, hiç kullanmamak ve bunun yerine bir ad alanı veya bir yapı kullanarak numaralandırmayı kapsamaktır. Bu amaçla değiştirilebilirler. Enum türünün kendisine atıfta bulunurken biraz fazladan yazmanız gerekir, ancak bu muhtemelen sık olmayacaktır.

struct TextureUploadFormat {
    enum Type : uint32 {
        r,
        rg,
        rgb,
        rgba,
        __count
    };
};

// must use ::Type, which is the extra typing with this method; beats all the static_cast<>()
uint32 getFormatStride(TextureUploadFormat::Type format){
    const uint32 formatStride[TextureUploadFormat::__count] = {
        1,
        2,
        3,
        4
    };
    return formatStride[format]; // decays without complaint
}