Can an enum class be converted to the underlying type?

by

I think you can use std::underlying_type to know the underlying type, and then use cast:

#include <type_traits> //for std::underlying_type

typedef std::underlying_type<my_fields>::type utype;

utype a = static_cast<utype>(my_fields::field);

With this, you don’t have to assume the underlying type, or you don’t have to mention it in the definition of the enum class like enum class my_fields : int { .... } or so.

You can even write a generic convert function that should be able to convert any enum class to its underlying integral type:

template<typename E>
constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type 
{
   return static_cast<typename std::underlying_type<E>::type>(e);
}

then use it:

auto value = to_integral(my_fields::field);

auto redValue = to_integral(Color::Red);//where Color is an enum class!

And since the function is declared to be constexpr, you can use it where constant expression is required:

int a[to_integral(my_fields::field)]; //declaring an array

std::array<int, to_integral(my_fields::field)> b; //better!

More Related Contents:

  1. “unpacking” a tuple to call a matching function pointer
  2. Does C++11 allow vector?
  3. shared_ptr to an array : should it be used?
  4. When does a constexpr function get evaluated at compile time?
  5. How much is too much with C++11 auto keyword?
  6. Why do I get the same sequence for every run with std::random_device with mingw gcc4.8.1?
  7. Why do C++11-deleted functions participate in overload resolution?
  8. Nice way to append a vector to itself
  9. What does std::match_results::size return?
  10. C++ – Why is boost::hash_combine the best way to combine hash-values?
  11. Disambiguate class-member in multiple inheritance
  12. Where is the lock for a std::atomic?
  13. Difference between C++03 throw() specifier C++11 noexcept
  14. Why doesn’t my template accept an initializer list
  15. What is the status of N2965 – std::bases and std::direct_bases?
  16. smart pointers and arrays
  17. How can I use something like std::vector?
  18. Non-copyable elements in vector
  19. Are C++11 thread_local variables automatically static?
  20. Are there any tricks to use std::cin to initialize a const variable?
  21. How to atomically update a maximum value?
  22. Why is the volatile qualifier used through out std::atomic?
  23. C++11 – declaring non-static data members as ‘auto’
  24. How to implement timeout for function in c++
  25. c++11 regex slower than python
  26. Using `std::function` to call non-void function
  27. Why does destructor disable generation of implicit move methods?
  28. What is the purpose of std::function and how to use it?
  29. const auto std::initializer_list difference between Clang and GCC
  30. Workaround for error C2536: cannot specify explicit initializer for arrays in Visual Studio 2013

Leave a Comment