NAME¶

std::underlying_type - std::underlying_type

Synopsis¶

Defined in header <type_traits>
template< class T > (since C++11)
struct underlying_type;

If T is a complete enumeration (enum) type, provides a member typedef type that
names the underlying type of T.

Otherwise, the behavior is undefined. (until C++20)
Otherwise, if T is not an enumeration type, there is no member type.
Otherwise (T is an incomplete enumeration type), the program is (since C++20)
ill-formed.

If the program adds specializations for std::underlying_type, the behavior is
undefined.

Member types¶

Name Definition
type the underlying type of T

Helper types¶

template< class T > (since C++14)
using underlying_type_t = typename underlying_type<T>::type;

Notes¶

Each enumeration type has an underlying type, which can be

1. Specified explicitly (both scoped and unscoped enumerations);
2. Omitted, in which case it is int for scoped enumerations or an
implementation-defined integral type capable of representing all values of the
enum (for unscoped enumerations).

Example¶

// Run this code

#include <iostream>
#include <type_traits>

enum e1 {};
enum class e2 {};
enum class e3 : unsigned {};
enum class e4 : int {};

int main()
{
constexpr bool e1_t = std::is_same_v<std::underlying_type_t<e1>, int>;
constexpr bool e2_t = std::is_same_v<std::underlying_type_t<e2>, int>;
constexpr bool e3_t = std::is_same_v<std::underlying_type_t<e3>, int>;
constexpr bool e4_t = std::is_same_v<std::underlying_type_t<e4>, int>;

std::cout
<< "underlying type for 'e1' is " << (e1_t ? "int" : "non-int") << '\n'
<< "underlying type for 'e2' is " << (e2_t ? "int" : "non-int") << '\n'
<< "underlying type for 'e3' is " << (e3_t ? "int" : "non-int") << '\n'
<< "underlying type for 'e4' is " << (e4_t ? "int" : "non-int") << '\n';
}

Possible output:¶

underlying type for 'e1' is non-int
underlying type for 'e2' is int
underlying type for 'e3' is non-int
underlying type for 'e4' is int

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 2396 C++11 incomplete enumeration types were complete enumeration type
allowed required

See also¶

is_enum checks if a type is an enumeration type
(C++11) (class template)
is_scoped_enum checks if a type is a scoped enumeration type
(C++23) (class template)
to_underlying converts an enumeration to its underlying type
(C++23) (function template)