C++ std::forward 详解

01

引言

std::forward 是 C++ 中的一个模板函数，用于实现完美转发。它声明在 <utility> 头文件中。std::forward 用于转发模板参数的左值或右值引用属性，而不会改变它们的值类别。std::forward 使用了引用折叠规则和右值引用的特性，将传入的参数按照原始的值类别（左值或右值）进行转发。

02

基本语法

std::forward 的语法如下：

namespace std {
    // 完美转发的声明
    template <class T>
    typename conditional<
        is_lvalue_reference<T>::value,
        T&, // 如果 T 是左值引用类型，则转发为左值引用
        typename remove_reference<T>::type&&
    >::type forward(typename remove_reference<T>::type& t) noexcept;


    template <class T>
    typename conditional<
        is_lvalue_reference<T>::value,
        T&, 
        const typename remove_reference<T>::type&&
    >::type forward(typename remove_reference<T>::type&& t) noexcept;
}

std::conditional 根据 T 是否是左值引用来选择正确的转发类型。std::forward 的两个重载分别处理左值引用和右值引用：

当 T 是左值引用类型时，std::forward<T>(t) 将 t 转发为 T&。

当 T 是右值引用类型时，std::forward<T>(t) 将 t 转发为 typename remove_reference<T>::type&&，即保持其右值引用状态。

std::forward 通常与模板函数结合使用，以实现完美转发。完美转发允许模板函数在转发参数时保留参数的原始值类别（左值或右值）。

03

示例

#include <utility>
#include <iostream>


// 一个模板函数，演示 std::forward 的用法
template <typename T>
void wrapper(T&& arg) {
    // 这里使用 std::forward 来转发参数
    passThrough(std::forward<T>(arg));
}


// 另一个模板函数，接受一个转发引用
template <typename T>
void passThrough(T&& arg) {
    std::cout << arg << std::endl;
}


int main() {
    int a = 5;
    wrapper(a);  // a 是左值，wrapper 中的 arg 是左值引用，但通过 std::forward 转发为右值引用


    int b = 10;
    wrapper(std::move(b));  // b 通过 std::move 转换为右值，wrapper 中的 arg 是右值引用
}

04

使用场景

• std::forward 只有在与模板函数结合使用时才有意义，因为它需要编译时类型信息来确定如何转发参数。
• std::forward 可以与 std::move 结合使用，std::move 将左值转换为对应的右值引用，然后 std::forward 保持这个右值引用属性。
• 滥用 std::forward 可能会导致不可预期的行为，特别是当它被错误地用于左值时。因此，只在确定需要转发右值属性时才使用 std::forward。

std::forward 是C++11及以后版本中模板编程的强大工具，它为编写灵活、高效的泛型代码提供了可能。

一个经典的完美转发的场景是：

template <class... Args>
void forward(Args&&... args) {
    f(std::forward<Args>(args)...);
}

std::forward的模板参数必须是<Args>，而不能是<Args...>，这是由于我们不能对Args进行解包之后传递给std::forward，而解包的过程必须在调用std::forward之后.

05

小结

std::forward 是 C++ 中用于实现完美转发的一个工具函数，它使用了引用折叠规则和右值引用的特性，将传入的参数按照原始的值类别（左值或右值）进行转发。

在 C++ 中，想要实现完美转发，即在函数模板中将传入的参数原封不动地转发给其他函数，需要考虑到两个方面：

1. 保持参数的值类别：如果传入的是左值，转发给目标函数时需要保持为左值；如果传入的是右值，转发给目标函数时需要保持为右值。
2. 保持参数的 const 和 volatile 限定符：如果传入的参数是 const 或 volatile 限定的，转发给目标函数时需要保持这些限定符。

std::forward 就是为了解决这两个问题而存在的。

下面是一个使用 std::forward 实现完美转发的示例代码：

template <typename T>
void func(T&& arg) {
    other_func(std::forward<T>(arg));
}

在这个示例代码中，func 函数接受一个参数 arg。通过使用 std::forward，arg 的值类别和 const/volatile 限定符将被保持不变地转发给 other_func 函数。

请注意，为了使用 std::forward，函数模板的参数类型通常是一个右值引用 T&&。这是因为使用引用折叠规则，当传入左值时，T 被推断为一个左值引用类型，此时 std::forward 会将参数转发为一个左值引用；当传入右值时，T 被推断为一个非引用类型，此时 std::forward 会将参数转发为一个右值引用。

使用 std::forward 和完美转发可以在泛型编程中非常有用，特别是在实现函数包装器或传递参数给其他函数的情况下。

06

附录

std::forward 使用的引用折叠规则？

在C++中，引用折叠（Reference Collapsing）规则定义了当多个引用类型相互结合时，最终的引用类型是什么。这些规则在模板编程中特别重要，因为它们决定了模板参数推导后引用类型的具体形态。std::forward 使用了引用折叠规则和右值引用的特性，将传入的参数按照原始的值类别（左值或右值）进行转发。

引用折叠规则如下：

1. 左值引用和左值引用结合（T& &）：

• 结果是左值引用 T&。

2. 右值引用和右值引用结合（T&& &&）：

• 结果是右值引用 T&&。

3. 左值引用和右值引用结合（T& && 或 T&& &）：

• 结果是左值引用 T&。

引用折叠的目的是为了在模板参数推导时，能够明确地知道最终的引用类型。这在实现转发引用（也称为通用引用）时尤其关键。

示例：

template <typename T>
void process(T&& arg) {
    // arg 是一个转发引用，它可以是左值引用或右值引用
    forward(arg); // forward 函数根据 arg 的类型进行转发
}


void forward(int& arg) {
    std::cout << "forward called with lvalue: " << arg << std::endl;
}


void forward(int&& arg) {
    std::cout << "forward called with rvalue: " << arg << std::endl;
}


int main() {
    int a = 5;
    process(a);  // a 是左值，process 中 arg 的类型是 int&，转发到 forward(int&)
    process(std::move(a));  // a 通过 std::move 转换为右值，process 中 arg 的类型是 int&&，转发到 forward(int&&)
}

示例中，process 函数接受一个转发引用 arg。根据 arg 的类型（左值或右值），process 将 arg 转发到 forward 函数的适当重载。forward 函数有两个重载，分别处理左值引用和右值引用。引用折叠规则确保了 process 函数中的 T&& 参数能够正确地推导并转发给 forward 函数。

引用折叠规则是C++11引入的特性，它们为模板编程提供了更大的灵活性，特别是在处理转发引用时。通过正确应用引用折叠规则，程序员可以实现完美转发，这是现代C++编程中的一个重要概念。