Namespaces
Variants
Views
Actions

std::decay

From cppreference.com
< cpp‎ | types
 
 
Metaprogramming library
Type traits
Type categories
(C++11)
(C++14)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++14)
(C++11)
(C++11)(until C++20)
(C++11)(deprecated in C++20)
(C++11)
Type trait constants
Metafunctions
(C++17)
Supported operations
Relationships and property queries
Type modifications
(C++11)(C++11)(C++11)
Type transformations
(C++11)(deprecated in C++23)
(C++11)(deprecated in C++23)
decay
(C++11)
(C++11)
(C++17)

(C++11)(until C++20)(C++17)
Compile-time rational arithmetic
Compile-time integer sequences
 
Defined in header <type_traits>
template< class T >
struct decay;
(since C++11)

Applies lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T, removes cv-qualifiers, and defines the resulting type as the member typedef type. Formally:

  • If T names the type "array of U" or "reference to array of U", the member typedef type is U*.
  • Otherwise, if T is a function type F or a reference thereto, the member typedef type is std::add_pointer<F>::type.

These conversions model the type conversion applied to all function arguments when passed by value.

The behavior of a program that adds specializations for decay is undefined.

Contents

[edit] Member types

Name Definition
type the result of applying the decay type conversions to T

[edit] Helper types

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

[edit] Possible implementation

template< class T >
struct decay {
private:
    typedef typename std::remove_reference<T>::type U;
public:
    typedef typename std::conditional< 
        std::is_array<U>::value,
        typename std::add_pointer<typename std::remove_extent<U>::type>::type,
        typename std::conditional< 
            std::is_function<U>::value,
            typename std::add_pointer<U>::type,
            typename std::remove_cv<U>::type
        >::type
    >::type type;
};

[edit] Example

#include <type_traits>
 
template <typename T, typename U>
constexpr bool is_decay_equ = std::is_same_v<std::decay_t<T>, U>;
 
int main()
{
    static_assert(
        is_decay_equ<int, int> &&
        ! is_decay_equ<int, float> &&
        is_decay_equ<int&, int> &&
        is_decay_equ<int&&, int> &&
        is_decay_equ<const int&, int> &&
        is_decay_equ<int[2], int*> &&
        ! is_decay_equ<int[4][2], int*> &&
        ! is_decay_equ<int[4][2], int**> &&
        is_decay_equ<int[4][2], int(*)[2]> &&
        is_decay_equ<int(int), int(*)(int)>
    );
}

[edit] See also

combines std::remove_cv and std::remove_reference
(class template) [edit]
implicit conversion array-to-pointer, function-to-pointer, lvalue-to-rvalue conversions