Advantages of using forward?

Question

In perfect forwarding, `std::forward` is used to convert the named rvalue references `t1` and `t2` to unnamed rvalue references. What is the purpose of doing that? How would that affect the called function `inner` if we leave `t1` & `t2` as lvalues? template <typename T1, typename T2> void outer(T1&& t1, T2&& t2) { inner(std::forward<T1>(t1), std::forward<T2>(t2)); }

Answer 1

There are a number of good posts on what std::forward does and how it works (such as here and here).

In a nutshell, it preserves the value category of its argument. Perfect forwarding is there to ensure that the argument provided to a function is forwarded to another function (or used within the function) with the same value category (basically r-value vs. l-value) as originally provided. It is typically used with template functions where reference collapsing may have taken place (involving universal/forwarding references).

Consider the code sample below. Removing the std::forward would print out requires lvalue and adding the std::forward prints out requires rvalue. The func is overloaded based on whether it is an rvalue or an lvalue. Calling it without the std::forward calls the incorrect overload. The std::forward is required in this case as pass is called with an rvalue.

#include <utility>

#include <iostream>

class Test {public:

Test() {

std::cout << "ctor" << std::endl;

}

Test(const Test&) {

std::cout << "copy ctor" << std::endl;

}

Test(Test&&) {

std::cout << "move ctor" << std::endl;

}

};

void func(Test const&)

{

std::cout << "requires lvalue" << std::endl;

}

void func(Test&&)

{

std::cout << "requires rvalue" << std::endl;

}

template<typename Arg>

void pass(Arg&& arg) {

// use arg here

func(std::forward<Arg>(arg));

return;

}

template<typename Arg, typename ...Args>

void pass(Arg&& arg, Args&&... args)

{

// use arg herereturn pass(std::forward<Args>(args)...);

}

int main(int, char**)

{

pass(std::move<Test>(Test()));

return 0;

}