std::underlying_type
| Defined in header <type_traits>
|
||
| template< class T > struct underlying_type; |
(since C++11) | |
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 |
(since C++20) |
The behavior of a program that adds specializations for underlying_type is undefined.
Contents |
[edit] Member types
| Name | Definition |
type
|
the underlying type of T
|
[edit] Helper types
| template< class T > using underlying_type_t = typename underlying_type<T>::type; |
(since C++14) | |
[edit] 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)
[edit] Example
#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
[edit] 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 allowed | complete enumeration type required |
[edit] See also
| (C++11) |
checks if a type is an enumeration type (class template) |
| (C++23) |
checks if a type is a scoped enumeration type (class template) |
| (C++23) |
converts an enumeration to its underlying type (function template) |

Formed in 2009, the Archive Team (not to be confused with the archive.org Archive-It Team) is a rogue archivist collective dedicated to saving copies of rapidly dying or deleted websites for the sake of history and digital heritage. The group is 100% composed of volunteers and interested parties, and has expanded into a large amount of related projects for saving online and digital history.
