Lvalue/rvalue -nes encoding for universal references

Question

I've been reading Effective Modern C++ and the following thing caught my attention:

In Item 28 Scott writes:

Together, these observations about universal references and lvalue/rvalue encoding mean that for this template

template<typename T> void func(T&& param);

the deduced template parameter T will encode whether the argument passed to param was an lvalue or an rvalue. The encoding mechanism is simple. When an lvalue is passed as an argument, T is deduced to be an lvalue reference. When an rvalue is passed, T is deduced to be a non-reference. (Note the asymmetry: lvalues are encoded as lvalue references, but rvalues are encoded as non-references.)

Can somebody explain why such encoding mechanism was chosen?

I mean if we will follow reference collapsing rules than usage of aforementioned template with rvalue yields rvalue reference. And as far as I can tell everything would work just the same if it were deduced as rvalue reference. Why is it encoded as non-reference?

Answer 1

Let's say you need to pass param around. In fact, you need to store it for lifetime purposes. As is, you'd just use T:

template <typename T>
struct store { T val; };

template<typename T> void func(T&& param) {
    store<T> s{std::forward<T>(param)};
}

This works because if param got passed in by lvalue, T would be an lvalue reference type, and we're just copying the reference. If param got passed in by rvalue, we need to take ownership - T is a non-reference type, so we end up move-constructing into s.

The fact that I can just use T here as the template argument for store, instead of std::conditional_t<std::is_lvalue_reference<T>::value, T, std::remove_reference_t<T>> is probably not an accident.

Answer 2

I think you're thinking the wrong way around. Instead of asking "why not always make T a reference type", look at it from the other side:

Suppose you have template <typename T> void f(T&&t).

Calling it as int i; f(i);, some T is needed such that T&& resolves to int&. What's the simplest T that can achieve that? It's int&.

Calling it as f(0);, some T is needed such that T&& resolves to int&&. What's the simplest T that can achieve that? It's int, not int&&.

int&& simply doesn't really have any advantages here.