Jak poznać podstawowy rodzaj wyliczenia w klasie?

Question

mam zmienna zadeklarowana jako:

enum class FooEnum: uint64_t {} 

i chciałbym oddać do jego podstawowej typu, ale nie chcę aby hardcode bazowy typu. Na przykład coś takiego:

FooEnum myEnum; 
uint64_t * intPointer = (underlying_typeof(myEnum))&myEnum; 

Czy to możliwe?

Answer 1

Można to wykorzystać:

• std::underlying_type klasy szablon znać podstawowy typ enum.

doc mówi

określa element typedef typ typu że to podstawowy typ dla T. wyliczania

więc powinieneś być w stanie to zrobić:

#include <type_traits> //include this 

FooEnum myEnum; 
auto pointer = static_cast<std::underlying_type<FooEnum>::type*>(&myEnum); 

Answer 2

Twój użyta składnia jest niesamowicie bliska. Szukasz std::underlying_type w <type_traits>:

#include <type_traits> 
#include <cstdint> 

enum class FooEnum: std::uint64_t {}; 

int main() 
{ 
    FooEnum myEnum; 
    uint64_t* intPointer = (std::underlying_type<FooEnum>::type*)&myEnum; 
} 

Answer 3

Zarówno Visual C++ 10,0 i MinGW g ++ 4.6.1 brakuje std::underlying_type, ale zarówno zaakceptować ten kod:

template< class TpEnum > 
struct UnderlyingType 
{ 
    typedef typename conditional< 
     TpEnum(-1) < TpEnum(0), 
     typename make_signed<TpEnum>::type, 
     typename make_unsigned<TpEnum>::type 
     >::type T; 
}; 

Answer 4

Oto inne podejście do kiedy basis_type nie jest obecny. Ta metoda nie próbuje wykryć podpisu enum, wystarczy podać typ tego samego rozmiaru, który jest więcej niż wystarczający dla wielu sytuacji.

template<int> 
class TIntegerForSize 
{ 
    typedef void type; 
}; 

template<> 
struct TIntegerForSize<1> 
{ 
    typedef uint8_t type; 
}; 

template<> 
struct TIntegerForSize<2> 
{ 
    typedef uint16_t type; 
}; 

template<> 
struct TIntegerForSize<4> 
{ 
    typedef uint32_t type; 
}; 

template<> 
struct TIntegerForSize<8> 
{ 
    typedef uint64_t type; 
}; 

template<typename T> 
struct TIntegerForEnum 
{ 
    typedef typename TIntegerForSize<sizeof(T)>::type type; 
}; 

Zastosowanie:

enum EFoo {Alpha, Beta}; 
EFoo f = Alpha; 
TIntegerForEnum<EFoo>::type i = f; 
TIntegerForEnum<decltype(f)>::type j = f;