Como converter automaticamente enum fortemente tipado em 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;
}

O a::LOCAL_Aé o que o enum fortemente digitado está tentando alcançar, mas há uma pequena diferença: enums normais pode ser convertido em tipo inteiro, enquanto enums rigidez não pode fazê-lo sem um elenco.

Portanto, existe uma maneira de converter um valor de enumeração fortemente tipado em um tipo inteiro sem uma conversão? Se sim, como?

Enums fortemente tipadas, com o objetivo de resolver vários problemas e não apenas o problema de escopo, como você mencionou na sua pergunta:

1. Forneça segurança de tipo, eliminando assim a conversão implícita em número inteiro por promoção integral.
2. Especifique os tipos subjacentes.
3. Forneça escopo forte.

Portanto, é impossível converter implicitamente uma enumeração fortemente tipada em números inteiros ou mesmo no tipo subjacente - essa é a ideia. Então você precisa usar static_castpara tornar a conversão explícita.

Se o seu único problema é o escopo e você realmente deseja ter uma promoção implícita para números inteiros, é melhor usar enum não fortemente tipado com o escopo da estrutura em que está declarado.

Como outros já disseram, você não pode ter uma conversão implícita, e isso é por projeto.

Se você quiser, pode evitar a necessidade de especificar o tipo subjacente no elenco.

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;

Uma versão em C ++ 14 da resposta fornecida por R. Martinho Fernandes seria:

#include <type_traits>

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

Como na resposta anterior, isso funcionará com qualquer tipo de enum e tipo subjacente. Eu adicionei a noexceptpalavra-chave, pois ela nunca lançará uma exceção.

Atualização
Isso também aparece no Effective Modern C ++ de Scott Meyers . Veja o item 10 (está detalhado nas páginas finais do item na minha cópia do livro).

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

Não. Não existe um caminho natural .

De fato, uma das motivações por trás da digitação forte enum classdo C ++ 11 é impedir sua conversão silenciosa para int.

O motivo da ausência de conversão implícita (por design) foi dado em outras respostas.

Pessoalmente, uso unário operator+para a conversão de classes enum para seu tipo subjacente:

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

O que fornece muito pouco "sobrecarga de digitação":

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

Onde eu realmente uso uma macro para criar enums e o operador funciona de uma só vez.

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

Espero que isso ajude você ou outra pessoa

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

Resposta curta é que você não pode, como as postagens acima apontam. Mas, no meu caso, eu simplesmente não queria desorganizar o espaço para nome, mas ainda tinha conversões implícitas, então fiz:

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

O namespacing meio que adiciona uma camada de segurança de tipo enquanto eu não tenho que converter estática nenhum valor de enumeração para o tipo subjacente.

Isso parece impossível com o nativo enum class, mas provavelmente você pode zombar de um enum classcom um class:

Nesse caso,

enum class b
{
    B1,
    B2
};

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

Isso é equivalente ao original enum class. Você pode retornar diretamente b::B1para uma função com o tipo de retorno b. Você pode fazer switch caseisso, etc.

E no espírito deste exemplo, você pode usar modelos (possivelmente junto com outras coisas) para generalizar e zombar de qualquer objeto possível definido pela enum classsintaxe.

Como muitos disseram, não há como converter automaticamente sem adicionar sobrecargas e muita complexidade, mas você pode reduzir um pouco a digitação e melhorar a aparência usando lambdas se alguma conversão for usada um pouco demais em um cenário. Isso adicionaria um pouco de sobrecarga de função, mas tornará o código mais legível em comparação com as longas seqüências static_cast, como pode ser visto abaixo. Isso pode não ser útil em todo o projeto, mas apenas em toda a 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;
    }
}

O comitê C ++ deu um passo à frente (enumerações de escopo fora do espaço de nomes global) e cinquenta etapas atrás (nenhum tipo de enumeração decai para um número inteiro). Infelizmente, isso enum classsimplesmente não é utilizável se você precisar do valor da enum de qualquer maneira não simbólica.

A melhor solução é não usá-lo e, em vez disso, escopo a enum usando um espaço para nome ou uma estrutura. Para esse fim, eles são intercambiáveis. Você precisará digitar um pouco mais ao se referir ao tipo de enum, mas isso provavelmente não será frequente.

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
}