std::forward

 

C++

编译器支持

自由（freestanding）与宿主（hosted）

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

工具库

语言支持 类型支持（基本类型、RTTI） 库特性测试宏 (C++20) 程序工具 变参函数 initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) 协程支持 (C++20) 契约支持 (C++26) 三路比较 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)

通用工具 函数对象 位操作 (C++20) bitset hash (C++11) 关系运算符 (C++20 中弃用) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= 整数比较函数 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 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) 常用词汇类型 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)

 

在头文件 <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-unqualified 函数模板参数的右值引用形式的函数参数）时，此重载将参数以其传入调用函数时的值类别转发给另一个函数。

例如，如果在一个像下面这样的包装器中使用，模板的行为如下所述：

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

参阅

move (C++11)	将参数转换为亡值 (函数模板)
move_if_noexcept (C++11)	如果移动构造函数不抛出异常，则将参数转换为亡值 (函数模板)