命名空间
变体
操作

std::forward

来自 cppreference.com
< cpp‎ | utility
 
 
实用程序库
语言支持
类型支持 (基本类型, RTTI)
库功能测试宏 (C++20)
动态内存管理
程序实用程序
协程支持 (C++20)
可变参数函数
调试支持
(C++26)
三方比较
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
通用实用程序
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中已弃用)
整数比较函数
(C++20)(C++20)(C++20)   
(C++20)
交换类型操作
(C++14)
(C++11)
forward
(C++11)
(C++11)
(C++17)
通用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
基本字符串转换
(C++17)
(C++17)

 
定义在头文件 <utility>
(1)
template< class T >
T&& forward( typename std::remove_reference<T>::type& t ) noexcept;
(自 C++11 起)
(直到 C++14)
template< class T >
constexpr T&& forward( std::remove_reference_t<T>& t ) noexcept;
(自 C++14 起)
(2)
template< class T >
T&& forward( typename std::remove_reference<T>::type&& t ) noexcept;
(自 C++11 起)
(直到 C++14)
template< class T >
constexpr T&& forward( std::remove_reference_t<T>&& t ) noexcept;
(自 C++14 起)
1) 将左值转发为左值或右值,具体取决于 T。

t 是一个 转发引用(声明为对 cv 无限定函数模板参数的右值引用的函数参数)时,此重载将参数转发给另一个函数,并具有其在传递给调用函数时的 值类别

例如,如果在如下所示的包装器中使用,则模板的行为如下所述

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() 的调用传递一个右值 std::string,则 T 被推断为 std::string(而不是 std::string&const std::string&std::string&&),并且 std::forward 确保将一个右值引用传递给 foo
  • 如果对 wrapper() 的调用传递一个 const 左值 std::string,则 T 被推断为 const std::string&,并且 std::forward 确保将一个 const 左值引用传递给 foo
  • 如果对 wrapper() 的调用传递一个非 const 左值 std::string,则 T 被推断为 std::string&,并且 std::forward 确保将一个非 const 左值引用传递给 foo
2) 将右值转发为右值,并禁止将右值转发为左值。

此重载使得可以转发表达式的结果(如函数调用),该结果可能是右值或左值,作为转发引用参数的原始值类别。

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

// transforming wrapper
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; } // call to this overload is rvalue
    int& get() &  { return i; } // call to this overload is lvalue
};

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

内容

[编辑] 备注

有关转发引用(T&& 用作函数参数)和 转发引用 背后的特殊规则,请参见 模板参数推断

[编辑] 参数

t - 要转发的对象

[编辑] 返回值

static_cast<T&&>(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

[编辑] 参见

(C++11)
将参数转换为右值
(函数模板) [编辑]
如果移动构造函数不抛出异常,则将参数转换为右值
(函数模板) [编辑]