Come convertire automaticamente enum fortemente tipizzato in int?

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

Questo a::LOCAL_Aè ciò che l'enum fortemente tipizzato sta cercando di ottenere, ma c'è una piccola differenza: gli enum normali possono essere convertiti in tipo intero, mentre gli enum fortemente tipizzati non possono farlo senza un cast.

Quindi, c'è un modo per convertire un valore enum fortemente tipizzato in un tipo intero senza cast? Se si, come?

Enum fortemente tipizzati che mirano a risolvere molteplici problemi e non solo problemi di scoping come hai menzionato nella tua domanda:

1. Fornire la sicurezza del tipo, eliminando così la conversione implicita in numero intero mediante la promozione integrale.
2. Specifica i tipi sottostanti.
3. Fornire un ambito di applicazione forte.

Pertanto, è impossibile convertire implicitamente un enum fortemente tipizzato in numeri interi o persino nel suo tipo sottostante: questa è l'idea. Quindi devi usare static_castper rendere esplicita la conversione.

Se il tuo unico problema è l'ambito e vuoi davvero avere una promozione implicita per gli interi, allora è meglio usare enum non fortemente tipizzato con l'ambito della struttura in cui è dichiarato.

Come altri hanno già detto, non è possibile avere una conversione implicita, e questo è un progetto.

Se lo desideri, puoi evitare la necessità di specificare il tipo sottostante nel cast.

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;

Una versione C ++ 14 della risposta fornita da R. Martinho Fernandes sarebbe:

#include <type_traits>

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

Come nella risposta precedente, questo funzionerà con qualsiasi tipo di enum e tipo sottostante. Ho aggiunto la noexceptparola chiave in quanto non genererà mai un'eccezione.

Aggiornamento
Questo appare anche in Effective Modern C ++ di Scott Meyers . Vedi l'articolo 10 (è dettagliato nelle pagine finali dell'articolo all'interno della mia copia del libro).

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

No. Non esiste un modo naturale .

In effetti, una delle motivazioni alla base della forte digitazione enum classin C ++ 11 è impedire la loro conversione silenziosa in int.

Il motivo dell'assenza di conversione implicita (in base alla progettazione) è stato fornito in altre risposte.

Personalmente uso unario operator+per la conversione da classi enum al tipo sottostante:

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

Che dà abbastanza poco "overhead di battitura":

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

Dove effettivamente uso una macro per creare enumerazioni e l'operatore funziona in un colpo solo.

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

Spero che questo aiuti te o qualcun altro

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

La risposta breve è che non puoi, come sottolineano i post precedenti. Ma per il mio caso, semplicemente non volevo ingombrare lo spazio dei nomi ma ho ancora conversioni implicite, quindi ho appena fatto:

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

Il tipo di namespace aggiunge un livello di sicurezza del tipo mentre non devo lanciare staticamente alcun valore enum sul tipo sottostante.

Questo sembra impossibile con il nativo enum class, ma probabilmente puoi deridere a enum classcon a class:

In questo caso,

enum class b
{
    B1,
    B2
};

sarebbe equivalente a:

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

Questo è per lo più equivalente all'originale enum class. È possibile tornare direttamente b::B1per in una funzione con tipo restituito b. Tu puoi fareswitch case , ecc.

E nello spirito di questo esempio puoi usare i template (possibilmente insieme ad altre cose) per generalizzare e deridere qualsiasi possibile oggetto definito dalla enum classsintassi.

Come molti hanno detto, non c'è modo di convertire automaticamente senza aggiungere overhead e troppa complessità, ma è possibile ridurre un po 'la digitazione e renderla migliore usando lambdas se alcuni cast verranno usati un po' troppo in uno scenario. Ciò aggiungerebbe un po 'di overhead di funzione, ma renderà il codice più leggibile rispetto alle stringhe static_cast lunghe come si può vedere di seguito. Questo potrebbe non essere utile a livello di progetto, ma solo a livello di classe.

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

Il comitato C ++ ha fatto un passo avanti (scoping enum fuori dallo spazio dei nomi globale) e cinquanta passi indietro (nessun decadimento del tipo enum in intero). Purtroppo,enum class semplicemente non è utilizzabile se hai bisogno del valore dell'enum in modo non simbolico.

La soluzione migliore è di non usarlo affatto, e invece di enfatizzare l'enum usando uno spazio dei nomi o una struttura. A tale scopo, sono intercambiabili. Dovrai digitare un piccolo extra quando ti riferisci al tipo di enum stesso, ma probabilmente non lo sarà spesso.

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
}