Namespaces
Variants
Views
Actions

std::is_scoped_enum

From cppreference.com
< cpp‎ | types
 
 
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++14)
(C++11)
(C++11)(until C++20)
(C++11)(deprecated in C++20)
(C++11)
is_scoped_enum
(C++23)
Type trait constants
Metafunctions
(C++17)
Supported operations
Relationships and property queries
Type modifications
(C++11)(C++11)(C++11)
Type transformations
(C++11)(deprecated in C++23)
(C++11)(deprecated in C++23)
(C++11)
(C++11)
(C++17)

(C++11)(until C++20)(C++17)
Compile-time rational arithmetic
Compile-time integer sequences
 
Defined in header <type_traits>
template< class T >
struct is_scoped_enum;
(since C++23)

Checks whether T is a scoped enumeration type. Provides the member constant value which is equal to true, if T is a scoped enumeration type. Otherwise, value is equal to false.

The behavior of a program that adds specializations for is_scoped_enum or is_scoped_enum_v is undefined.

Contents

[edit] Template parameters

T - a type to check

[edit] Helper variable template

template< class T >
inline constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;
(since C++23)

Inherited from std::integral_constant

Member constants

value
[static]
true if T is a scoped enumeration type , false otherwise
(public static member constant)

Member functions

operator bool
converts the object to bool, returns value
(public member function)
operator()
(C++14)
returns value
(public member function)

Member types

Type Definition
value_type bool
type std::integral_constant<bool, value>

[edit] Notes

As currently the standard allows the name of an enumeration type appears in its enum-base, for example, enum class E : std::enable_if_t<std::is_scoped_enum_v<E>, int> {}; is allowed, std::is_scoped_enum cannot be implemented without extensions, because scoped and unscoped enumeration types are indistinguishable in expressions when they are incomplete.

However, all known compilers consider an enumeration type is still undeclared in its enum-base. As a result, a scoped enumeration type can never be incomplete, and std::is_scoped_enum can be implemented like below. This is CWG issue 2516.

Feature testing macro: __cpp_lib_is_scoped_enum

[edit] Possible implementation

This implementation assumes that scoped enumeration types are always complete.

namespace detail {
namespace { // avoid ODR-violation
template<class T>
auto test_sizable(int) -> decltype(sizeof(T), std::true_type{});
template<class>
auto test_sizable(...) -> std::false_type;
 
template<class T>
auto test_nonconvertible_to_int(int)
    -> decltype(static_cast<std::false_type (*)(int)>(nullptr)(std::declval<T>()));
template<class>
auto test_nonconvertible_to_int(...) -> std::true_type;
 
template<class T>
constexpr bool is_scoped_enum_impl = std::conjunction_v<
    decltype(test_sizable<T>(0)),
    decltype(test_nonconvertible_to_int<T>(0))
>;
}
} // namespace detail
 
template<class>
struct is_scoped_enum : std::false_type {};
 
template<class E>
    requires std::is_enum_v<E>
struct is_scoped_enum<E> : std::bool_constant<detail::is_scoped_enum_impl<E>> {};

[edit] Example

#include <iostream>
#include <type_traits>
 
class A {};
 
enum E {};
 
enum struct Es { oz };
 
enum class Ec : int {};
 
int main() 
{
    std::cout << std::boolalpha;
    std::cout << std::is_scoped_enum_v<A> << '\n';
    std::cout << std::is_scoped_enum_v<E> << '\n';
    std::cout << std::is_scoped_enum_v<Es> << '\n';
    std::cout << std::is_scoped_enum_v<Ec> << '\n';
    std::cout << std::is_scoped_enum_v<int> << '\n';
}

Output:

false
false
true
true
false

[edit] See also

checks if a type is an integral type
(class template) [edit]
checks if a type is an arithmetic type
(class template) [edit]
(C++11)
checks if a type is a scalar type
(class template) [edit]
(C++11)
checks if a type is an enumeration type
(class template) [edit]