std:: forward

当 t 是 转发引用 （声明为 cv-未限定函数模板参数的右值引用的函数参数）时，此重载将参数转发给另一个函数，并保持其传递给调用函数时的 值类别 。

例如，若在如下包装器中使用时，该模板的行为如下所述：

template<class T>
void wrapper(T&& arg)
{
    // arg 始终是左值
    foo(std::forward<T>(arg)); // 根据 T 的类型决定转发为左值或右值
}

• 如果对 wrapper() 的调用传递了一个右值 std::string ，则 T 被推导为 std::string （而非 std::string& 、 const std::string& 或 std::string&& ），且 std::forward 确保向 foo 传递右值引用。
• 如果对 wrapper() 的调用传递了一个常量左值 std::string ，则 T 被推导为 const std::string& ，且 std::forward 确保向 foo 传递常量左值引用。
• 如果对 wrapper() 的调用传递了一个非常量左值 std::string ，则 T 被推导为 std::string& ，且 std::forward 确保向 foo 传递非常量左值引用。

此重载使得能够将表达式结果（例如函数调用）作为转发引用参数的原始值类别进行转发，该结果可能是右值或左值。

例如，如果一个包装器不仅转发其参数，而是调用参数上的成员函数，并转发其结果：

// 转换包装器
template<class T>
void wrapper(T&& arg)
{
    foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));
}

其中 arg 的类型可能是

struct Arg
{
    int i = 1;
    int  get() && { return i; } // 对该重载的调用是右值
    int& get() &  { return i; } // 对该重载的调用是左值
};

尝试将右值作为左值转发，例如用左值引用类型 T 实例化形式 (2) ，会导致编译时错误。

注释

请参阅 模板实参推导 了解转发引用（函数参数中使用的 T&& ）背后的特殊规则，以及 转发引用 获取其他详细信息。

参数

返回值

static_cast < T && > ( t )

复杂度

常量。

示例

#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)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}
template<class T, class... U>
std::unique_ptr<T> make_unique2(U&&... u)
{
    return std::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); // rvalue
    int 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);
}

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

参见