title

C++ 完美转发与引用折叠

在现代 C++ 中，完美转发（Perfect Forwarding） 是一个非常重要的概念，它允许我们在模板编程中将参数的值类别（左值或右值）保持不变地传递给其他函数。完美转发的实现依赖于 右值引用 和 引用折叠（Reference Collapsing）。本文将通过通俗易懂的讲解和代码实例，详细介绍完美转发和引用折叠的原理与应用。

1. 什么是完美转发？

1.1 问题背景

在模板编程中，我们经常需要编写一个“中间函数”，将参数传递给另一个函数。例如：

void process(int& x) {
    std::cout << "Lvalue: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

template <typename T>
void wrapper(T arg) {
    process(arg); // 传递参数
}

int main() {
    int a = 10;
    wrapper(a);  // 调用 process(int&)
    wrapper(20); // 调用 process(int&&)
    return 0;
}

在这个例子中，wrapper 函数将参数 arg 传递给 process 函数。然而，问题出现了：

当传递左值 a 时，process(int&) 被正确调用。
当传递右值 20 时，process(int&&) 并没有被调用，而是调用了 process(int&)。

这是因为 arg 在 wrapper 中是一个左值（即使它来自一个右值），因此无法正确传递右值。

1.2 完美转发的目标

完美转发的目标是：

如果传递的是左值，则保持左值的特性。
如果传递的是右值，则保持右值的特性。

换句话说，完美转发需要确保参数的值类别（左值或右值）在传递过程中不会丢失。

2. 完美转发的实现：`std::forward`

2.1 `std::forward` 的作用

std::forward 是实现完美转发的核心工具。它的作用是：

如果参数是左值，则返回一个左值引用。
如果参数是右值，则返回一个右值引用。

2.2 使用 `std::forward` 实现完美转发

#include <iostream>
#include <utility>

void process(int& x) {
    std::cout << "Lvalue: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

template <typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg)); // 完美转发
}

int main() {
    int a = 10;
    wrapper(a);  // 调用 process(int&)
    wrapper(20); // 调用 process(int&&)
    return 0;
}

在这个例子中：

当传递左值 a 时，std::forward<T> 返回一个左值引用，调用 process(int&)。
当传递右值 20 时，std::forward<T> 返回一个右值引用，调用 process(int&&)。

引用折叠（Reference Collapsing）是 C++ 模板编程中的一个重要概念，尤其是在完美转发（Perfect Forwarding）中起着关键作用。为了帮助你更好地理解引用折叠，我将通过通俗易懂的例子和详细的解释来逐步讲解。

3. 引用折叠

3.1 什么是引用折叠？

引用折叠是 C++ 模板编程中的一种规则，用于处理模板参数中的引用类型。它的规则如下：

T& & 折叠为 T&
T& && 折叠为 T&
T&& & 折叠为 T&
T&& && 折叠为 T&&

简单来说，引用折叠的目的是将多个引用类型“合并”为一个引用类型。

3.2 为什么需要引用折叠？

在模板编程中，模板参数的类型可能会包含多个引用（如 T& 或 T&&），这些引用需要被“简化”为一个单一的引用类型。引用折叠就是用来完成这个任务的。

例子：

template <typename T>
void foo(T&& arg) {
    // 这里 T 可能是 T& 或 T&&
}

在这个例子中，T 可能是 T& 或 T&&，具体取决于传递的是左值还是右值。引用折叠会将 T&& 折叠为 T& 或 T&&，具体取决于 T 的类型。

3.3 引用折叠的规则

引用折叠的规则非常简单：

输入类型	折叠结果
`T& &`	`T&`
`T& &&`	`T&`
`T&& &`	`T&`
`T&& &&`	`T&&`

解释：

如果输入类型中包含 &，折叠结果总是 T&。
只有当输入类型是 T&& && 时，折叠结果才是 T&&。

3.4 引用折叠的实际应用

引用折叠在完美转发中非常重要。完美转发的核心是保持参数的值类别（左值或右值）不变地传递给其他函数。为了实现这一点，我们需要使用 通用引用（Universal Reference） 和 引用折叠。

例子：

#include <iostream>
#include <utility>

void process(int& x) {
    std::cout << "Lvalue: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

template <typename T>
void wrapper(T&& arg) { // 通用引用
    process(std::forward<T>(arg)); // 完美转发
}

int main() {
    int a = 10;
    wrapper(a);  // 调用 process(int&)
    wrapper(20); // 调用 process(int&&)
    return 0;
}

分析：

传递左值 a：
- T 被推导为 int&。
- T&& 折叠为 int&。
- std::forward<T>(arg) 返回左值引用，调用 process(int& x)。
传递右值 20：
- T 被推导为 int。
- T&& 折叠为 int&&。
- std::forward<T>(arg) 返回右值引用，调用 process(int&& x)。

3.5 引用折叠的详细过程

3.5.1 传递左值

int a = 10;
wrapper(a);

T 被推导为 int&。
T&& 是 int& &&。
引用折叠：int& && 折叠为 int&。
std::forward<T>(arg) 返回左值引用，调用 process(int& x)。

3.5.2 传递右值

wrapper(20);

T 被推导为 int。
T&& 是 int&&。
引用折叠：int&& && 折叠为 int&&。
std::forward<T>(arg) 返回右值引用，调用 process(int&& x)。

3.6 引用折叠的代码验证

为了验证引用折叠的规则，我们可以编写一个简单的代码：

#include <iostream>
#include <type_traits>

template <typename T>
void print_type(T&& arg) {
    if (std::is_same<T, int&>::value) {
        std::cout << "Type is int&" << std::endl;
    } else if (std::is_same<T, int&&>::value) {
        std::cout << "Type is int&&" << std::endl;
    } else {
        std::cout << "Type is int" << std::endl;
    }
}

int main() {
    int a = 10;
    print_type(a);  // 传递左值
    print_type(20); // 传递右值
    return 0;
}

输出：

Type is int&
Type is int&&

解释：

传递左值 a 时，T 被推导为 int&，折叠为 int&。
传递右值 20 时，T 被推导为 int，折叠为 int&&。

3.7 总结

引用折叠 是 C++ 模板编程中的一种规则，用于处理模板参数中的引用类型。
引用折叠的规则是：
- T& & 折叠为 T&
- T& && 折叠为 T&
- T&& & 折叠为 T&
- T&& && 折叠为 T&&
完美转发 依赖于引用折叠，通过 std::forward 保持参数的值类别（左值或右值）不变地传递给其他函数。
在模板编程中，T&& 是一个通用引用，它的类型会根据传递的参数自动推导和折叠。

希望这个详细的解释能帮助你更好地理解引用折叠。如果你还有任何疑问，欢迎继续讨论！

4. 完美转发与引用折叠的结合

4.1 完美转发的模板参数

完美转发的模板参数通常写为 T&&，这被称为 通用引用（Universal Reference）。它的特点是：

如果传递的是左值，T 会被推导为左值引用（如 int&）。
如果传递的是右值，T 会被推导为右值引用（如 int&&）。

4.2 完美转发的完整实现

#include <iostream>
#include <utility>

void process(int& x) {
    std::cout << "Lvalue: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

template <typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg)); // 完美转发
}

int main() {
    int a = 10;
    wrapper(a);  // 调用 process(int&)
    wrapper(20); // 调用 process(int&&)
    return 0;
}

在这个例子中：

wrapper 的模板参数 T&& 是一个通用引用。
std::forward<T>(arg) 根据 T 的类型（左值引用或右值引用）返回相应的引用类型。

5. 完美转发的应用场景

5.1 在工厂函数中使用完美转发

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "Constructor" << std::endl; }
    MyClass(const MyClass&) { std::cout << "Copy Constructor" << std::endl; }
    MyClass(MyClass&&) noexcept { std::cout << "Move Constructor" << std::endl; }
};

template <typename T, typename... Args>
std::unique_ptr<T> create(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...); // 完美转发
}

int main() {
    auto ptr = create<MyClass>(); // 调用默认构造函数
    auto ptr2 = create<MyClass>(MyClass{}); // 调用移动构造函数
    return 0;
}

在这个例子中，create 函数通过完美转发将参数传递给 std::make_unique，确保参数的值类别被正确传递。

5.2 在容器中使用完美转发

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass() { std::cout << "Constructor" << std::endl; }
    MyClass(const MyClass&) { std::cout << "Copy Constructor" << std::endl; }
    MyClass(MyClass&&) noexcept { std::cout << "Move Constructor" << std::endl; }
};

int main() {
    std::vector<MyClass> v;
    v.push_back(MyClass{}); // 调用移动构造函数
    return 0;
}

在这个例子中，std::vector 的 push_back 函数通过完美转发确保临时对象的资源被移动，而不是拷贝。

6. 总结

完美转发 是 C++ 中保持参数值类别（左值或右值）不变传递的核心机制。
引用折叠 是完美转发的基础，它通过模板参数的推导和折叠规则，确保参数的引用类型正确。
std::forward 是实现完美转发的工具，它根据模板参数的类型返回相应的引用。

通过完美转发和引用折叠，C++ 开发者可以编写更高效、更灵活的代码，尤其是在模板编程和资源管理中。希望本文的讲解和代码实例能帮助你更好地理解这一重要概念！

文章合集：chongzicbo/ReadWriteThink: 博学而笃志，切问而近思 (github.com)

个人博客：程博仕

微信公众号：

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

C++002：完美转发和引用折叠.md

C++002：完美转发和引用折叠.md

C++ 完美转发与引用折叠

1. 什么是完美转发？

1.1 问题背景

1.2 完美转发的目标

2. 完美转发的实现：`std::forward`

2.1 `std::forward` 的作用

2.2 使用 `std::forward` 实现完美转发

3. 引用折叠

3.1 什么是引用折叠？

3.2 为什么需要引用折叠？

例子：

3.3 引用折叠的规则

解释：

3.4 引用折叠的实际应用

例子：

分析：

3.5 引用折叠的详细过程

3.5.1 传递左值

3.5.2 传递右值

3.6 引用折叠的代码验证

输出：

解释：

3.7 总结

4. 完美转发与引用折叠的结合

4.1 完美转发的模板参数

4.2 完美转发的完整实现

5. 完美转发的应用场景

5.1 在工厂函数中使用完美转发

5.2 在容器中使用完美转发

6. 总结

Files

C++002：完美转发和引用折叠.md

Latest commit

History

C++002：完美转发和引用折叠.md

File metadata and controls

C++ 完美转发与引用折叠

1. 什么是完美转发？

1.1 问题背景

1.2 完美转发的目标

2. 完美转发的实现：std::forward

2.1 std::forward 的作用

2.2 使用 std::forward 实现完美转发

3. 引用折叠

3.1 什么是引用折叠？

3.2 为什么需要引用折叠？

例子：

3.3 引用折叠的规则

解释：

3.4 引用折叠的实际应用

例子：

分析：

3.5 引用折叠的详细过程

3.5.1 传递左值

3.5.2 传递右值

3.6 引用折叠的代码验证

输出：

解释：

3.7 总结

4. 完美转发与引用折叠的结合

4.1 完美转发的模板参数

4.2 完美转发的完整实现

5. 完美转发的应用场景

5.1 在工厂函数中使用完美转发

5.2 在容器中使用完美转发

6. 总结

2. 完美转发的实现：`std::forward`

2.1 `std::forward` 的作用

2.2 使用 `std::forward` 实现完美转发