std::decay(3)

NAME
std::decay - std::decay

Synopsis
   Defined in header <type_traits>
   template< class T > (since C++11)
   struct decay;
   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.
   The behavior of a program that adds specializations for decay is undefined.

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

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

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;
   };

Example
// Run this code
 #include <type_traits>
 template <typename T, typename U>
 struct decay_equiv :
     std::is_same<typename std::decay<T>::type, U>::type
 {};
 template <typename T, typename U>
 constexpr bool is_decay_equ = decay_equiv<T, U>::value;
 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)>
     );
 }

See also
   remove_cvref combines std::remove_cv and std::remove_reference
   (C++20) (class template)
   implicit conversion array-to-pointer, function-to-pointer, lvalue-to-rvalue
                       conversions