Re: forwarding Args&&... vs forwarding Args...
On 4 Jan., 21:51, Andrew Tomazos wrote:
Can someone please clarify the difference (if any) between the
following two functions...
template<class... Args>
void f1(Args&&... args)
{ f(forward<Args>(args)...); }
and
template<class... Args>
void f2(Args... args)
{ f(forward<Args>(args)); }
The difference (&&) affects template argument deduction. The first
function template always takes references as parameters and encodes
the value category of the supplied arguments as part of the type
parameters. This value category is then restored by std::forward. The
second function template always takes function parameters by value and
the forward call is basically just a move request (like std::move).
Keep in mind that something like
template<class T>
void foo(T&& x);
is basically a "catch everything and remember the value category, too,
so that it can be restored later"-signature.
int main() {
int i = 23;
// special deduction rule for T&& with lvalue arguments
// |
// | reference collapsing
// | |
foo(i); // --> deduce T=int& --> T&&=int&
foo(i+0); // --> deduce T=int --> T&&=int&&
}
As for restoring the value category:
forward<int >(...) yields an rvalue.
forward<int&>(...) yields an lvalue.
The use of std::forward is necessary because named rvalue references
are actually lvalues. The x in foo above is ALWAYS lvalue.
Cheers!
SG