Re: Template argument as rvalue reference
Am 26.10.2012 12:23, schrieb Juha Nieminen:> There's a special rule in
the new standard with regard to rvalue references
when used with a template argument. Namely, if you have T&& (where T
is a template argument), it will be collapsed to T& if an lvalue is
given
to it.
No, reference collapsing is always applicable. It is not restricted to
the case of templates. The only restriction w.r.t. reference collapsing
is that you cannot actually type things like
typedef int && & lvalue_reference;
But you can write
typedef int&& rvalue_reference;
typedef rvalue_reference& lvalue_reference;
The special rule w.r.t. rvalue references is a deduction rule. That is,
if a function receives a parameter of type T&& where T will be deduced,
a special rule kicks in which might render T to be an lvalue reference.
This is done depending on the argument you use to invoke the function
template.
This means that if you have something like this:
template<typename T> void foo(T&&, T&&);
This is not the way to enable perfect forwarding.
then two different functions will be instantiated depending on whether
you call it with rvalues or lvalues. In other words foo(1, 2) will
generate one function and foo(a, b) (where a and b are existing
variables) a different one.
What I do not understand is why calling foo(a, 1) or foo(1, b) doesn't
compile. It gives an error (at least with clang).
Because it's a template argument deduction error.
template<typename T> void foo(T&&, T&&);
int main() {
int a=0, b=0;
foo(1,2); // --> T=int --> T&&=int&&
foo(a,b); // --> T=int& --> T&&=int&
foo(1,b); // deduction error
}
It's a deduction error, because the deduction of T for the first
parameter yields T=int while the deduction of T for the second parameter
yields T=int&&. This is inconsistent and qualifies as deduction failure.
Since no other function or function template called foo is available,
the compiler complains about not being able to call the right foo.
Ok, so, you might think that if the compiler isn't able to figure out
what T is ... how about specifying T? Let's try ...
foo<int>(1,b); // error #1
foo<int&>(1,b); // error #2
#1 is an error because T=int makes the second parameter an rvalue
reference but an rvalue reference of type int is not allowed to be
initialized with an lvalue of int -- for safety reasons.
#2 is an error because T=int& makes the first parameter an lvalue
reference but an lvalue reference of type int is not allowed to be
initialized with an rvalue of int -- for safety reasons, too.
HTH,
SG