编辑“︁C++ 引用折叠”︁

{{DISPLAYTITLE:C++引用折叠}}

'''C++引用折叠'''（Reference Collapsing）是C++模板和类型推导中的一个重要规则，它决定了当引用嵌套时最终形成的引用类型。该概念在[[完美转发]]（Perfect Forwarding）和通用引用（Universal Reference）的实现中起着关键作用。

== 基本概念 ==

在C++中，引用本身不能形成引用的引用（即不存在`int&& &`这样的类型）。但在模板类型推导或`typedef`/`using`别名中，可能会间接产生引用的引用。引用折叠规则定义了这种情况下最终的类型。

引用折叠规则如下：
* `T& &` → `T&`
* `T& &&` → `T&`
* `T&& &` → `T&`
* `T&& &&` → `T&&`

用数学形式表示：
<math>
\begin{cases}
A\& \& \equiv A\& \\
A\& \&\& \equiv A\& \\
A\&\& \& \equiv A\& \\
A\&\& \&\& \equiv A\&\&
\end{cases}
</math>

== 代码示例 ==

以下示例展示引用折叠在模板中的行为：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <type_traits>

template<typename T>
void check_reference(T&& param) {
    if (std::is_lvalue_reference<T&&>::value) {
        std::cout << "T&& is lvalue reference\n";
    } else if (std::is_rvalue_reference<T&&>::value) {
        std::cout << "T&& is rvalue reference\n";
    } else {
        std::cout << "T&& is not a reference\n";
    }
}

int main() {
    int x = 42;
    const int cx = x;
    
    // 示例1：传递左值
    check_reference(x);    // T = int& → T&& = int& && → int&
    // 输出: T&& is lvalue reference
    
    // 示例2：传递const左值
    check_reference(cx);   // T = const int& → T&& = const int& && → const int&
    // 输出: T&& is lvalue reference
    
    // 示例3：传递右值
    check_reference(42);   // T = int → T&& = int&&
    // 输出: T&& is rvalue reference
}
</syntaxhighlight>

== 引用折叠与完美转发 ==

引用折叠是实现完美转发的关键机制。`std::forward`利用引用折叠保留原始参数的值类别：

<syntaxhighlight lang="cpp">
template<typename T>
T&& forward(typename std::remove_reference<T>::type& arg) {
    return static_cast<T&&>(arg);
}

// 使用示例
template<typename T>
void wrapper(T&& arg) {
    some_function(std::forward<T>(arg));  // 完美转发
}
</syntaxhighlight>

当`T`是左值引用时，`forward`返回左值引用；当`T`是非引用或右值引用时，返回右值引用。

== 实际应用案例 ==

'''案例1：工厂函数'''
<syntaxhighlight lang="cpp">
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
</syntaxhighlight>

'''案例2：emplace_back实现'''
容器`emplace_back`方法使用引用折叠高效构造元素：
<syntaxhighlight lang="cpp">
template<typename... Args>
void emplace_back(Args&&... args) {
    // 使用完美转发将参数传递给构造函数
    construct_at_end(std::forward<Args>(args)...);
}
</syntaxhighlight>

== 类型推导中的引用折叠 ==

引用折叠在`auto`类型推导中同样适用：
<syntaxhighlight lang="cpp">
int x = 10;
auto&& r1 = x;   // auto = int& → int& && → int&
auto&& r2 = 42;  // auto = int → int&&
</syntaxhighlight>

== 常见误区 ==

1. '''误认为所有`T&&`都是右值引用'''：实际上在模板中`T&&`可能是通用引用，会根据传入参数决定最终类型。
2. '''忽略const的影响'''：`const T& &&`会折叠为`const T&`，保留const限定符。
3. '''不理解引用折叠发生的场景'''：只有在类型推导或别名中才会发生引用折叠。

== 总结 ==

引用折叠是C++类型系统的重要组成部分，它：
* 使通用引用和完美转发成为可能
* 保持代码的简洁性和效率
* 在模板元编程中广泛使用

理解引用折叠有助于深入掌握现代C++的移动语义和模板编程。

== 参见 ==
* [[右值引用]]
* [[完美转发]]
* [[类型推导]]

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 引用]]