##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::decay

From cppreference.com
< cpp‎ | types

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.

- Otherwise, the member typedef `type` is std::remove_cv<std::remove_reference<T>::type>::type.

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

### [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::remove_extent<U>::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

Run this code

    #include <iostream>
    #include <type_traits>

    template <typename T, typename U>
    struct decay_equiv :
        std::is_same<typename std::decay<T>::type, U>::type
    {};

    int main()
    {
        std::cout << std::boolalpha
                  << decay_equiv<int, int>::value << '\n'
                  << decay_equiv<int&, int>::value << '\n'
                  << decay_equiv<int&&, int>::value << '\n'
                  << decay_equiv<const int&, int>::value << '\n'
                  << decay_equiv<int[2], int*>::value << '\n'
                  << decay_equiv<int(int), int(*)(int)>::value << '\n';
    }

Output:

    true
    true
    true
    true
    true
    true

### [edit] See also

`implicit conversion` | array-to-pointer, function-to-pointer, lvalue-to-rvalue conversions

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/types/decay&oldid=85775"