std::forward

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Optional and any

optional (C++17)

any (C++17)

Pairs and tuples

pair

tuple (C++11)

apply (C++17)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Type operations

declval (C++11)

as_const (C++17)

 

Defined in header <utility>
template< class T > T&& forward( typename std::remove_reference<T>::type& t );	(1)	(since C++11) (until C++14)
template< class T > constexpr T&& forward( typename std::remove_reference<T>::type& t );	(1)	(since C++14)
template< class T > T&& forward( typename std::remove_reference<T>::type&& t );	(2)	(since C++11) (until C++14)
template< class T > constexpr T&& forward( typename std::remove_reference<T>::type&& t );	(2)	(since C++14)

When used according to the following recipe in a function template, forwards the argument to another function with the value category it had when passed to the calling function.

For example, if used in wrapper such as the following, the template behaves as described below:

template<class T>
void wrapper(T&& arg)
{
    foo(std::forward<T>(arg)); // Forward a single argument.
}

• 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.

Notes

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.

See template argument deduction for the special rules behind T&& used as a function parameter.

Parameters

t

-

the object to be forwarded

Return value

static_cast<T&&>(t)

Exceptions

noexcept specification:  

noexcept

  

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>
#include <array>
 
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)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}
 
template<class T, class... U>
std::unique_ptr<T> make_unique(U&&... u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)...));
}
 
int main()
{   
    auto p1 = make_unique1<A>(2); // rvalue
    int i = 1;
    auto p2 = make_unique1<A>(i); // lvalue
 
    std::cout << "B\n";
    auto t = make_unique<B>(2, i, 3);
}

Output:

rvalue overload, n=2
lvalue overload, n=1
B
rvalue overload, n=2
lvalue overload, n=1
rvalue overload, n=3

Complexity

Constant

See also

move (C++11)	obtains an rvalue reference (function template)
move_if_noexcept (C++11)	obtains an rvalue reference if the move constructor does not throw (function template)