C++11 type trait to differentiate between enum class and regular enum

Question

I'm writing a promotion template alias similar to boost::promote but for C++11. The purpose of this is to avoid warnings when retrieving arguments from varidic functions. e.g.

template <typename T> std::vector<T> MakeArgVectorV(int aArgCount, va_list aArgList) {     std::vector<T> args;     while (aArgCount > 0)     {         args.push_back(static_cast<T>(va_arg(aArgList, Promote<T>)));         --aArgCount;     }     return args; } 

The Promote template alias promotes the type following the default argument promotion for variadic arguments: 1) An integer that's smaller than an int is promoted to int 2) A float is promoted to double

My problem is that a standard C++ enum can be promoted but a C++11 enum class is not promoted (compiler does not generate a warning). I want Promote to work with a regular enum but ignore a C++11 enum class.

How can I tell the difference between an enum class and an enum in my Promote template alias?

Answer 1

Here is a possible solution:

#include <type_traits>  template<typename E> using is_scoped_enum = std::integral_constant<     bool,     std::is_enum<E>::value && !std::is_convertible<E, int>::value>; 

The solution exploits a difference in behavior between scoped and unscoped enumerations specified in Paragraph 7.2/9 of the C++11 Standard:

The value of an enumerator or an object of an unscoped enumeration type is converted to an integer by integral promotion (4.5). [...] Note that this implicit enum to int conversion is not provided for a scoped enumeration. [...]

Here is a demonstration of how you would use it:

enum class E1 { }; enum E2 { }; struct X { };  int main() {     // Will not fire     static_assert(is_scoped_enum<E1>::value, "Ouch!");      // Will fire     static_assert(is_scoped_enum<E2>::value, "Ouch!");      // Will fire     static_assert(is_scoped_enum<X>::value, "Ouch!"); } 

And here is a live example.

ACKNOWLEDGEMENTS:

Thanks to Daniel Frey for pointing out that my previous approach would only work as long as there is no user-defined overload of operator +.

Answer 2

It appears that as of C++23 a similar solution to the one provided by @AndyProwl will be available from type_traits

#include <type_traits>  enum E { a, b }; enum class Es { x, y, z };  std::is_scoped_enum_v<E>;  // False std::is_scoped_enum_v<Es>; // True