Why does std::make_tuple turn std::reference_wrapper<X> arguments into X&?

Question

In the C++11 standard it states that (see cppreference.com , see also section 20.4.2.4 of the standard) it states that

template< class... Types >
tuple<VTypes...> make_tuple( Types&&... args );

Creates a tuple object, deducing the target type from the types of arguments.

For each Ti in Types... , the corresponding type Vi in Vtypes... is std::decay<Ti>::type unless application of std::decay results in std::reference_wrapper<X> for some type X , in which case the deduced type is X& .

I am wondering: Why are reference wrappers treated special here?

Answer 1

This is more or less the primary purpose of reference_wrapper .

Normally, std::make_tuple always makes tuples of values ( std::decay simulates pass-by-value semantics). Given int x, y; std::make_tuple(x, y); int x, y; std::make_tuple(x, y); makes a std::tuple<int, int> , even though it will have deduced Types as a pack of references int&, int& . std::decay converts those to int, int .

reference_wrapper allows you to force creation of tuples of references : std::make_tuple(std::ref(x), y) will make a std::tuple<int&, int> .

Other parts of the standard library use reference_wrapper in the same way. As an example, std::bind will usually copy/move the bound arguments into the resulting object, but if you want it to store only a reference, you can explicitly request it by passing a reference_wrapper .

Answer 2

Your title is misleading: using std::reference_wrapper<X> turns the members to be X& rather than X . The reason this transformation is done is that std::reference_wrapper<T> is an auxiliary type, meant to turn a value type into a reference type. However, the extra conversion needed to make it appear that way sometimes interferes with the usage. Thus, unwrapping the reference where possible seems a reasonable approach: making the std::tuple<...> member a T& makes the use more natural.

Answer 3

People are usually using std::reference_wrapper<X> to hold non-copyable types. Therefore, copying them in make_tuple would beat the purpose (and may break the build if the copy constructor is deleted). That is the reason why it uses reference (instead of a value) in it's return type.