使用 std::forward 的作用---完美转发

std::forward是什么

使用 std::forward 是为了实现完美转发（perfect forwarding）。

完美转发是一种技术，用于将函数模板的参数按原始类型转发给其他函数或对象。它可以保持原始参数的值类别（lvalue 或 rvalue）和 const 限定符，从而实现更高的灵活性和效率。

在这个特定的代码片段中，std::forward(func) 是将传递给 enqueue 函数的 func 参数完美转发给 std::packaged_task 对象的构造函数。

不使用std::forward的危害

#include 
#include 

void processValue(int& value)
{
    std::cout << "processValue(int&): " << value << std::endl;
    value = 100;
}

void processValue(const int& value)
{
    std::cout << "processValue(const int&): " << value << std::endl;
}

template <typename T>
void forwardExample(T&& value)
{
    processValue(value);
}

template <typename T>
void forwardExample2(T&& value)
{
    processValue(std::forward<T&&>(value));
}

template <typename T>
void forwardExample3(T&& value)
{
    processValue(std::forward<T>(value));
}

int main()
{
    int x = 42;

    forwardExample(x); // 传递左值

    forwardExample(123); // 传递右值

    forwardExample2(x); // 传递左值

    forwardExample2(123); // 传递右值

    forwardExample3(x); // 传递左值

    forwardExample3(123); // 传递右值

    return 0;
}

以上例子的对应输出如下：

processValue(int&): 42
processValue(int&): 123
processValue(int&): 100
processValue(const int&): 123
processValue(int&): 100
processValue(const int&): 123

在这个例子中，我定义了2个重载的 processValue 函数，一个接受非常量左值引用，另一个接受常量左值引用。然后，我们定义了一个模板函数 forwardExample，它接受一个通用引用参数 value。

在 forwardExample 函数中，我们将参数 value 传递给 processValue 函数。但是，这里我们没有使用 std::forward 进行完美转发。

当我们在 main 函数中调用 forwardExample(x) 时，我们传递了一个左值 x。由于没有使用 std::forward，value 参数在 forwardExample 中被视为左值引用，并且调用了 processValue(int&)，输出的结果为 processValue(int&): 42。这是符合预期的。

然而，当我们在 main 函数中调用 forwardExample(123) 时，我们传递了一个右值。同样，由于没有使用 std::forward，value 参数在 forwardExample 中仍然被视为左值引用，并且调用了 processValue(int&)，而不是我们期望的 processValue(const int&)。结果输出为 processValue(int&): 123，而不是 processValue(const int&): 123。

这个例子展示了在没有使用 std::forward 进行完美转发时，参数的值类别和 const 限定符会被改变，导致函数重载的选择不符合预期。

如果我们在 forwardExample 函数中使用 std::forward 来进行完美转发，即 processValue(std::forward(value))，那么参数的值类别和 const 限定符将被正确地保留，从而选择正确的函数重载。

所以，使用 std::forward 进行完美转发可以避免这种错误的函数重载选择，确保参数以原始的值类别和 const 限定符传递给下游函数。

还有一种万能的完美转发，即正确的类型上再套一层T&&，根据引用折叠的原则，依旧是正确的类型，即这里的forwardExample2，大家可以留意一下完美转发的两种手法。