Home Original page

std::is_scoped_enum - cppreference.com

From cppreference.com

template< class T > struct is_scoped_enum;

 (since C++23)

std::is_scoped_enum is a UnaryTypeTrait.

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.

If the program adds specializations for std::is_scoped_enum or std::is_scoped_enum_v, the behavior is undefined.

Template parameters

Helper variable template

template< class T > constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;

 (since C++23)

Inherited from std::integral_constant

Member constants

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

Member functions

converts the object to bool, returns value
(public member function)
returns value
(public member function)

Member types

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

Notes

Feature-test macro Value Std Feature
__cpp_lib_is_scoped_enum 202011L (C++23) std::is_scoped_enum

Possible implementation

namespace detail
{
void test_conversion(...);          // selected when E is complete and scoped
void test_conversion(int) = delete; // selected when E is complete and unscoped

template<class E>
concept is_scoped_enum_impl =
    std::is_enum_v<E> &&                        // checked first
    requires { detail::test_conversion(E{}); }; // ill-formed before overload resolution
                                                // when E is incomplete
} // namespace detail

template<class T>
struct is_scoped_enum : std::bool_constant<detail::is_scoped_enum_impl<T>> {};

Example

#include <type_traits>

static_assert(std::is_scoped_enum_v<int> == false);

class A {};
static_assert(std::is_scoped_enum_v<A> == false);

enum B { self_test = std::is_scoped_enum_v<B> };
static_assert(std::is_scoped_enum_v<B> == false);
static_assert(!self_test);

enum struct C { final, import, module };
static_assert(std::is_scoped_enum_v<C> == true);

enum class D : int { pre, post, override };
static_assert(std::is_scoped_enum_v<D> == true);

enum class E;
static_assert(std::is_scoped_enum_v<E> == true);

int main() {}

See also