What is std::decay and when it should be used?

by

<joke>It’s obviously used to decay radioactive std::atomic types into non-radioactive ones.</joke>

N2609 is the paper that proposed std::decay. The paper explains:

Simply put, decay<T>::type is the identity type-transformation except
if T is an array type or a reference to a function type. In those
cases the decay<T>::type yields a pointer or a pointer to a function,
respectively.

The motivating example is C++03 std::make_pair:

template <class T1, class T2> 
inline pair<T1,T2> make_pair(T1 x, T2 y)
{ 
    return pair<T1,T2>(x, y); 
}

which accepted its parameters by value to make string literals work:

std::pair<std::string, int> p = make_pair("foo", 0);

If it accepted its parameters by reference, then T1 will be deduced as an array type, and then constructing a pair<T1, T2> will be ill-formed.

But obviously this leads to significant inefficiencies. Hence the need for decay, to apply the set of transformations that occurs when pass-by-value occurs, allowing you to get the efficiency of taking the parameters by reference, but still get the type transformations needed for your code to work with string literals, array types, function types and the like:

template <class T1, class T2> 
inline pair< typename decay<T1>::type, typename decay<T2>::type > 
make_pair(T1&& x, T2&& y)
{ 
    return pair< typename decay<T1>::type, 
                 typename decay<T2>::type >(std::forward<T1>(x), 
                                            std::forward<T2>(y)); 
}

Note: this is not the actual C++11 make_pair implementation – the C++11 make_pair also unwraps std::reference_wrappers.

More Related Contents:

  1. What is std::promise?
  2. Are int8_t and uint8_t intended to be char types?
  3. Does std::mt19937 require warmup?
  4. Is it possible to print a variable’s type in standard C++?
  5. What is std::move(), and when should it be used?
  6. Variadic template pack expansion
  7. How does #include work in C++? [duplicate]
  8. std::function vs template
  9. Why is the destructor of a future returned from `std::async` blocking?
  10. When is a private constructor not a private constructor?
  11. C++11 “auto” semantics
  12. Reading from ifstream won’t read whitespace
  13. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  14. When is overloading pass by reference (l-value and r-value) preferred to pass-by-value?
  15. Does the GotW #101 “solution” actually solve anything?
  16. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  17. Is there any compiler barrier which is equal to asm(“” ::: “memory”) in C++11?
  18. What are unevaluated contexts in C++?
  19. C++11 “overloaded lambda” with variadic template and variable capture
  20. How to handle key press events in C++
  21. Is it valid to bind non-const lvalue-references to rvalues in C++ 11?(modified)
  22. What’s the difference between parentheses and braces in c++ when constructing objects
  23. cc1plus: error: unrecognized command line option “-std=c++11” with g++
  24. Is it wise to ignore gcc/clang’s “-Wmissing-braces” warning?
  25. Why does pointer to int convert to void* but pointer to function convert to bool?
  26. boost::asio + std::future – Access violation after closing socket
  27. What is the purpose of std::function and how to use it?
  28. How does std::forward receive the correct argument?
  29. const auto std::initializer_list difference between Clang and GCC
  30. Overload resolution with ref-qualifiers

Leave a Comment