Namespaces
Variants

    std::underlying_type

    From cppreference.com
     
    C++
     
    Metaprogramming library
    Type traits
    Type categories
    (C++11)
    (C++11)(DR*)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11) 
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)  
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    Type properties
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++14)
    (C++11)
    (C++17)
    (C++23)
    (C++11)(deprecated in C++26)
    (C++11)
    (C++11)
    (C++11)(until C++20*)
    (C++11)(deprecated in C++20)
    (C++11)
    (C++11)
    (C++20)
    (C++20)
    (C++23)
    (C++17)
    Type trait constants
    (C++11)(C++17)(C++11)(C++11)
    Metafunctions
    (C++17)
    (C++17)
    (C++17)
    Supported operations
    Relationships and property queries
    Type modifications
    (C++11)(C++11)(C++11)
    (C++11)(C++11)(C++11)
    (C++11)
    (C++11)
    Type transformations
    (C++11)(deprecated in C++23)
    (C++11)(deprecated in C++23)
    (C++11)
    (C++20)
    (C++11)(until C++20*)(C++17)

    (C++11)
    (C++11)
    (C++20)
    (C++11)
    (C++20)
    (C++11)
    (C++17)
    Compile-time rational arithmetic
    Compile-time integer sequences
    (C++14)
     
    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 T is not an enumeration type, there is no member type. Otherwise (T is an incomplete enumeration type), the program is ill-formed.

    		(since C++20)

    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 > using underlying_type_t = typename underlying_type<T>::type;
    		 (since C++14)

    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 allowed complete enumeration type required

    See also

    (C++11)
    		 checks if a type is an enumeration type
    (class template) [edit]
    (C++23)
    		 checks if a type is a scoped enumeration type
    (class template) [edit]
    (C++23)
    		 converts an enumeration to its underlying type
    (function template) [edit]