std::forward

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros(C++20) Program utilities Variadic functions initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine support(C++20) Contract support(C++26) Three-way comparison three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

General utilities Function objects Bit manipulation(C++20) bitset hash (C++11) Relational operators(deprecated in C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

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)

1) Forwards lvalues as either lvalues or as rvalues, depending on T.

When t is a forwarding 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 the value 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}

• If a call to wrapper() passes an rvalue std::string, then T is deduced to std::string (not std::string&, const std::string&, or std::string&&), and std::forward ensures that an rvalue reference is passed to foo.
• If a call to wrapper() passes a const lvalue std::string, then T is deduced to const std::string&, and std::forward ensures that a const lvalue reference is passed to foo.
• If a call to wrapper() passes a non-const lvalue std::string, then T is deduced to std::string&, and std::forward ensures that a non-const lvalue reference is passed to foo.

2) Forwards rvalues as rvalues and prohibits forwarding of rvalues as lvalues.

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.

Notes

See template argument deduction for the special rules behind forwarding references (T&& used as a function parameter) and forwarding references for other detail.

Parameters

t

-

the object to be forwarded

Return value

static_cast<T&&>(t)

Complexity

Constant.

Example

This example demonstrates perfect forwarding of the parameter(s) to the argument of the constructor of class T. Also, perfect forwarding of parameter packs is demonstrated.

Run this code

#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=2 lvalue overload, n=1 B rvalue overload, n=2 lvalue overload, n=1 rvalue overload, n=3 make_B rvalue overload, n=4 lvalue overload, n=1 rvalue overload, n=5

See also

move (C++11)	converts the argument to an xvalue (function template)
move_if_noexcept (C++11)	converts the argument to an xvalue if the move constructor does not throw (function template)