Difference between std::decay and std::remove_reference

Question

When template metaprogramming in C++, I often run into something like the following:

template <typename T>
S<T> make_wrapper(T&& t) { return S<T>(std::forward<T>(t)); }

I know I should use something like std::decay in the return type, but why wouldn't std::remove_reference work as well? What's the difference here? What about std::remove_cvref ?

Answer 1

Consider for example

#include <type_traits>

int main()
{
    static_assert(std::is_same_v<
        std::decay_t<const int&>, 
        std::remove_reference_t<const int&>
    >); // int != const int
}

std::decay will remove any cv-qualifer, remove_reference won't. It will just strip the "reference" part of the type.

From the reference :

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.

Therefore std::decay will perform way more type conversions than std::remove_reference .

There are also further type modifiers for more nuanced applications that will only perform selected parts of the set of possible transformations decay does, like remove_cv , remove_volatile or, in C++20, remove_cvref .

Answer 2

Removing reference would leave const and volatile . If that is what you want, then it will suffice.

Removing cvref does most of what decay does, but doesn't convert function types and array types to pointers.

decay converts a type in a way that you could reasonably store a copy of it in an array or in a struct , or return it from or pass it to a function.