|
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Defined in header <utility> | ||
| (1) | ||
template<class T> T&& forward(typenamestd::remove_reference<T>::type& t)noexcept; | (since C++11) (until C++14) | |
template<class T> constexpr T&& forward(std::remove_reference_t<T>& t)noexcept; | (since C++14) | |
| (2) | ||
template<class T> T&& forward(typenamestd::remove_reference<T>::type&& t)noexcept; | (since C++11) (until C++14) | |
template<class T> constexpr T&& forward(std::remove_reference_t<T>&& t)noexcept; | (since C++14) | |
Whent is aforwarding reference (a function argument that is declared as an rvalue reference to a cv-unqualified function template parameter), this overload forwards the argument to another function with thevalue category it had when passed to the calling function.
For example, if used in a wrapper such as the following, the template behaves as described below:
template<class T>void wrapper(T&& arg){// arg is always lvalue foo(std::forward<T>(arg));// Forward as lvalue or as rvalue, depending on T}
wrapper() passes an rvaluestd::string, thenT is deduced tostd::string (notstd::string&,const std::string&, orstd::string&&), andstd::forward ensures that an rvalue reference is passed tofoo.wrapper() passes a const lvaluestd::string, thenT is deduced toconst std::string&, andstd::forward ensures that a const lvalue reference is passed tofoo.wrapper() passes a non-const lvaluestd::string, thenT is deduced tostd::string&, andstd::forward ensures that a non-const lvalue reference is passed tofoo.This overload makes it possible to forward a result of an expression (such as function call), which may be rvalue or lvalue, as the original value category of a forwarding reference argument.
For example, if a wrapper does not just forward its argument, but calls a member function on the argument, and forwards its result:
// transforming wrappertemplate<class T>void wrapper(T&& arg){ foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));}
where the type of arg may be
struct Arg{int i=1;int get()&&{return i;}// call to this overload is rvalueint& get()&{return i;}// call to this overload is lvalue};
Attempting to forward an rvalue as an lvalue, such as by instantiating the form(2) with lvalue reference type T, is a compile-time error.
Contents |
Seetemplate argument deduction for the special rules behind forwarding references (T&& used as a function parameter) andforwarding references for other detail.
| t | - | the object to be forwarded |
static_cast<T&&>(t)
Constant.
This example demonstrates perfect forwarding of the parameter(s) to the argument of the constructor of classT. Also, perfect forwarding of parameter packs is demonstrated.
#include <iostream>#include <memory>#include <utility> struct A{ A(int&& n){std::cout<<"rvalue overload, n="<< n<<'\n';} A(int& n){std::cout<<"lvalue overload, n="<< n<<'\n';}}; class B{public:template<class T1,class T2,class T3> B(T1&& t1, T2&& t2, T3&& t3): a1_{std::forward<T1>(t1)}, a2_{std::forward<T2>(t2)}, a3_{std::forward<T3>(t3)}{} private: A a1_, a2_, a3_;}; template<class T,class U>std::unique_ptr<T> make_unique1(U&& u){returnstd::unique_ptr<T>(new T(std::forward<U>(u)));} template<class T,class...U>std::unique_ptr<T> make_unique2(U&&...u){returnstd::unique_ptr<T>(new T(std::forward<U>(u)...));} auto make_B(auto&&...args)// since C++20{return B(std::forward<decltype(args)>(args)...);} int main(){auto p1= make_unique1<A>(2);// rvalueint i=1;auto p2= make_unique1<A>(i);// lvalue std::cout<<"B\n";auto t= make_unique2<B>(2, i,3); std::cout<<"make_B\n";[[maybe_unused]] B b= make_B(4, i,5);}
Output:
rvalue overload, n=2lvalue overload, n=1Brvalue overload, n=2lvalue overload, n=1rvalue overload, n=3make_Brvalue overload, n=4lvalue overload, n=1rvalue overload, n=5
(C++11) | converts the argument to an xvalue (function template)[edit] |
(C++11) | converts the argument to an xvalue if the move constructor does not throw (function template)[edit] |
