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?

BTW, the term "universal reference" didn't catch on, and the committee chose to use forwarding reference instead. — Bo Persson
I think your question might be the same as this one stackoverflow.com/questions/32282705/… — aldr
See open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm esp. #7. IIRC, Howard Hinnant once stated that introducing some &&& solely for forwarding references probably wasn't going to be accepted at that time (as a third reference kind). — dyp
OTOH, that doesn't seem to answer why T isn't deduced to be A&&, though. — dyp

Barry Barry · Accepted Answer · 2015-08-29T09:35:18

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.

Lvalue/rvalue -nes encoding for universal references

2 Answers