Re: Is binding non-const references to temporaries the sole key feature
of rvalue references?
Am 14.07.2013 22:20, schrieb K. Frank:
If so, then I would say:
Rvalue references have two key features: they support
binding of non-const references to temporaries; and they
are different (in this regard) from regular references,
so that they can be used to distinguish moves from copies,
as in the above example.
Right. They support binding of non-const references to temporaries
(rvalues) and they can be used to distinguish between lvalues and
rvalues which is very important for the whole move semantics stuff:
void foo(const int& ref); // #1 for lvalues (and rvalues)
void foo(const int&& ref); // #2 for rvalues (preferred)
int main() {
int i = 1729;
foo(i); // pixks #1, ref will refer to i
foo(23); // picks #2, ref will refer to temporary
foo(i+0); // picks #2, ref will refer to temporary
}
Function #1 in isolation would also "eat" rvalues due to the const. But
overload resolution prefers an rvalue reference for rvalues if
everything else (type including cv-qualification) is deemed an equally
good match.
In addition to that, they have a funny template argument deduction rule
attatched to them:
template<class T> // Be aware! A very special deduction
void foo(T&& ref); // rule kicks in here in this situation!
int main() {
int i = 1729;
// deduction | reference collapsing
// ----------+---------------------
foo(i); // T=int& | T&&=int&
foo(23); // T=int | T&&=int&&
foo(i+0); // T=int | T&&=int&&
}
The deduction rule might make T an lvalue reference, see first case. The
reference collapsing rules turn T&& also into an lvalue reference in
this case. So, this kind of function template makes a
grab-it-all-and-also-preserve-the-value-category-as-part-of-the-type
function. This is deliberate and supports what is known as "perfect
forwarding".
Basically, that's all the low-level details about rvalue references.
Everything else (move semantics, perfect forwarding) builds on that.
Cheers!
SG