table of contents
std::underlying_type(3) | C++ Standard Libary | std::underlying_type(3) |
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.
The behavior of a program that adds specializations for underlying_type 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)
2022.07.31 | http://cppreference.com |