万能引用和原样转发 - Vafail的个人博客

1. 左值与右值#

1.1 定义与分类#

**左值（lvalue）和右值（rvalue）**是C++中用于描述表达式值类别的重要概念。

左值（lvalue）：
- 表示具有持久存储的对象。
- 可以出现在赋值语句的左侧。
- 可以被取地址（即，可以使用&运算符）。
- 示例：变量名、引用等。
右值（rvalue）：
- 表示临时对象或没有持久存储的值。
- 通常出现在赋值语句的右侧。
- 不能被取地址。
- 示例：字面量、临时对象、表达式结果等。

C++11进一步细化了右值的分类：

纯右值（prvalues）：表示临时对象或字面量，如42、3.14。
将亡值（xvalues，expiring values）：表示即将被移动的对象，如std::move的结果。

1.2 示例代码#

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
int main() {
6
    int a = 10;           // a是一个左值
7
    int& b = a;           // b是a的左值引用
8
    int&& c = 20;         // c是一个右值引用，绑定到临时右值20
9
    int d = a + 5;        // (a + 5)是一个纯右值
10

11
    std::string s1 = "Hello";                   // s1是一个左值
12
    std::string s2 = std::string("World");      // std::string("World")是一个纯右值
13

14
    std::cout << "a: " << a << ", d: " << d << std::endl;
15
    std::cout << "s1: " << s1 << ", s2: " << s2 << std::endl;
16

17
    // 检查类型
18
    std::cout << std::boolalpha;
19
    // 使用 decltype((a)) 获取 a 的类型，包括引用
20
    // `(a)` 是一个左值表达式，所以 decltype((a)) 是 `int&`
21
    std::cout << "a 是左值: " << std::is_lvalue_reference<decltype((a))>::value << std::endl;
22
    std::cout << "c 是右值引用: " << std::is_rvalue_reference<decltype(c)>::value << std::endl;
23

24
    return 0;
25
}

输出：

1
a: 10, d: 15
2
s1: Hello, s2: World
3
a 是左值: true
4
c 是右值引用: true

1.3 类型判断工具#

C++标准库提供了几个类型特性（type traits）用于判断表达式的值类别：

std::is_lvalue_reference<T>：判断类型T是否为左值引用。
std::is_rvalue_reference<T>：判断类型T是否为右值引用。
std::is_lvalue<T>（C++20起）：判断表达式是否为左值。
std::is_rvalue<T>（C++20起）：判断表达式是否为右值。

示例：

1
#include <iostream>
2
#include <type_traits>
3

4
void func(int& x) {
5
    std::cout << "func(int&)" << std::endl;
6
}
7

8
void func(int&& x) {
9
    std::cout << "func(int&&)" << std::endl;
10
}
11

12
int main() {
13
    int a = 5;
14
    const int& ref = a;
15

16
    // 判断类型
17
    std::cout << std::boolalpha;
18
    // 使用 decltype((a)) 获取 a 的类型，包括引用
19
    // `(a)` 是一个左值表达式，所以 decltype((a)) 是 `int&`
20
    std::cout << "a 是左值: " << std::is_lvalue_reference<decltype((a))>::value << std::endl;
21
    std::cout << "ref 是左值引用: " << std::is_lvalue_reference<decltype(ref)>::value << std::endl;
22

23
    // 调用函数
24
    func(a);          // 调用func(int&)
25
    func(10);         // 调用func(int&&)
26

27
    return 0;
28
}

输出：

1
a 是左值: true
2
ref 是左值引用: true
3
func(int&)
4
func(int&&)

1.4 应用场景#

理解左值与右值的区别是实现移动语义、完美转发以及高效内存管理的基础。在编写高性能C++代码时，合理利用右值引用和移动语义可以显著提升程序的效率。

2. 模板万能引用（转发引用）#

2.1 定义与特性#

模板万能引用（也称为转发引用，英文为forwarding references）是C++11引入的一种引用类型，具有以下特点：

表现形式为T&&，其中T是模板参数。
在特定条件下，编译器会将其解析为左值引用或右值引用。
能够统一处理左值和右值，适用于泛型编程中的参数传递。

重要特性：

当模板参数T被推导为普通类型时，T&&是右值引用。
当模板参数T被推导为引用类型时，T&&会根据引用折叠规则解析为左值引用。

2.2 引用折叠规则#

引用折叠是C++中的一项规则，用于处理引用类型的嵌套。主要规则如下：

& &、& &&、&& & 都折叠为 &（左值引用）。
&& && 折叠为 &&（右值引用）。

示例：

1
#include <type_traits>
2
#include <iostream>
3

4
template<typename T>
5
void check_referenc(T&& x){
6
    std::cout << std::boolalpha;
7
    std::cout << "T is lvalue reference: " << std::is_lvalue_reference<T>::value << std::endl;
8
    std::cout << "T is rvalue reference: " << std::is_rvalue_reference<T>::value << std::endl;
9
    std::cout << "T is rvalue : " << std::is_rvalue_reference<T&&> ::value << std::endl;
10
    std::cout << "x is lvalue reference: " << std::is_lvalue_reference<decltype(x)>::value << std::endl;
11
    std::cout << "x is rvalue reference: " << std::is_rvalue_reference<decltype(x)>::value << std::endl;
12
}
13

14
int main() {
15
    int a = 10;
16
    check_reference(a);          // T被推导为 int&， 因此 T&& -> int& && -> int&
17
    check_reference(20);         // T被推导为 int，  T&& -> int&&
18

19
    return 0;
20
}

输出：

1
T is lvalue reference: true
2
T is rvalue reference: false
3
T is rvalue : false
4
x is lvalue reference: true
5
x is rvalue reference: false
6
T is lvalue reference: false
7
T is rvalue reference: false
8
T is rvalue : true
9
x is lvalue reference: false
10
x is rvalue reference: true

但是要注意，如果如果我这样调用

1
int &&c = 100;
2
check_referenc(c);

输出的却是

1
T is lvalue reference: true
2
T is rvalue reference: false
3
T is rvalue : false
4
x is lvalue reference: true
5
x is rvalue reference: false

然而，实际中 T 被推导为 int&，这是因为 命名的右值引用变量在表达式中被视为左值。

关键点：#

变量的值类别（Value Category）：
- 左值（lvalue）：有名称，可以出现在赋值的左侧。
- 右值（rvalue）：临时的、没有名称的值，一般不能出现在赋值的左侧。
命名的右值引用变量是左值：
- 虽然 c 的类型是 int&&，但作为一个变量名，它本身是一个左值。
- 这意味着在表达式中使用 c 时，c 被视为左值，而不是右值。
类型推导规则：
- 当模板参数使用T&&（被称为转发引用或万能引用）时，类型推导遵循特定规则：
  - 如果传入的是左值，T 被推导为 T&。
  - 如果传入的是右值，T 被推导为 T（非引用类型）。

传入左值（c）：
- c 是一个命名的右值引用变量，但作为表达式它是左值。
- 因此，T 被推导为 int&。
- T&& 则根据引用折叠规则（int& && => int&）。

为了让 T 被推导为右值引用，我们需要传递一个 真正的右值。这可以通过使用 std::move 来实现：

1
// std::move(c) 是右值，T 被推导为 int
2
check_reference(std::move(c));

输出

1
T is lvalue reference: false
2
T is rvalue reference: false
3
T is rvalue : true
4
x is lvalue reference: false
5
x is rvalue reference: true

**传递右值 **std::move(c)：
- std::move(c) 将 c 转换为 int&&（右值）。
- T 被推导为 int（非引用类型）。
- std::is_lvalue_reference<T>::value 为 false。
- std::is_rvalue_reference<T>::value 为 false。
- std::is_rvalue_reference<T&&>::value 相当于 std::is_rvalue_reference<int&&>::value，为 true。
- decltype(x) 相当于 int&&，所以 x 被识别为右值引用。
为什么T被实例化为int而不是int&&

在模板参数中，当一个类型参数 T 以 T&& 的形式出现，并且 T 是模板参数时，T&& 被称为 转发引用（有时称为万能引用）。转发引用具有特殊的类型推导规则：

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

模板类型推导的具体规则

根据 C++ 标准（C++17 标准草案）：

如果 P 是 T&&，并且 A（实参类型）是一个非引用类型的表达式，则 T 被推导为 A 的类型。
如果 P 是 T&&，并且 A 是一个引用类型的表达式，则去除引用后的类型用于推导。

具体到我们的例子：

传递 c（一个左值，类型 int&&）：
- 表达式 c 是一个左值。
- 当传递左值给 T&& 时，T 被推导为 int&（即 int 加上引用）。
- 因此，参数类型 T&& 实际上是 int& &&，根据引用折叠规则，int& && 合并为 int&。
传递 std::move(c)（一个右值，类型 int&&）：
- 表达式 std::move(c) 是一个右值。
- 当传递右值给 T&& 时，T 被推导为 int（不带引用）。
- 因此，参数类型 T&& 是 int&&。

也可以采用原样转发，达到和move相同的效果

1
check_referenc(std::forward<int&&>(c));

输出

1
T is lvalue reference: false
2
T is rvalue reference: false
3
T is rvalue : true
4
x is lvalue reference: false
5
x is rvalue reference: true

2.3 示例代码#

以下示例展示了如何使用模板万能引用编写能够接受任意类型参数的函数，并通过转发保持参数的原有值类别。

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
// 目标函数，分别有左值和右值的重载
6
void process(int&x){
7
    std::cout << "process(int&)" << std::endl;
8
}
9

10
void process(int&& x){
11
    std::cout << "process(int&&)" << std::endl;
12
}
13

14
// 通用的包装函数，使用转发引用
15
template<typename T>
16
void wrapper(T&& arg) {
17
    process(std::forward<T>(arg)); // 原样转发
18
}
19

20
int main() {
21
    int a = 10;
22
    wrapper(a);          // 传递左值，调用process(int&)
23
    wrapper(20);         // 传递右值，调用process(int&&)
24
    return 0;
25
}

输出：

1
process(int&)
2
process(int&&)

在上述代码中，wrapper函数使用模板万能引用T&&接收参数，通过std::forward<T>(arg)实现原样转发，确保传递给process函数的参数保持其原有的值类别。

如果我们把wrapper改为

1
// 通用的包装函数，使用转发引用
2
template<typename T>
3
void wrapper(T&& arg) {
4
    process(arg); // 原样转发
5
}

调用

1
int main() {
2
    int a = 10;
3
    wrapper(a);          // 传递左值，调用process(int&)
4
    wrapper(20);         // 传递右值，调用process(int&&)
5
    return 0;
6
}

则输出

1
process(int&)
2
process(int&)

因为虽然wrapper(20)调用时会将T实例化为int类型, arg变为int && 类型，但是arg本身是一个左值, 所以调用process会选择左值引用版本

1
// 目标函数
2
void process(int&x){
3
    std::cout << "process(int&)" << std::endl;
4
}

3. 类型推导（Type Deduction）#

3.1 类型推导规则#

在C++模板编程中，类型推导是指编译器根据传入的实参自动推导模板参数的类型。类型推导遵循以下基本规则：

模板参数的推导：
- 当模板参数与函数参数进行匹配时，编译器会根据实参类型推导出模板参数类型T。
引用的处理：
- 如果函数参数采用右值引用（如T&&），且传递的是左值，则T会被推导为左值引用类型。
- 如果传递的是右值，则T会被推导为非引用类型。
cv限定符的去除：
- 类型推导会去除顶层的const和volatile修饰。

3.2 与引用的关系#

在模板参数中使用引用类型时，类型推导会涉及引用折叠规则。例如，当一个模板函数参数为T&或T&&时，传入参数的值类别会影响T的推导结果。

示例：

1
#include <iostream>
2
#include <type_traits>
3

4
template<typename T>
5
void deduce_type(T&&) {
6
    std::cout << std::boolalpha;
7
    std::cout << "Is T an lvalue reference? " << std::is_lvalue_reference<T>::value << std::endl;
8
    std::cout << "Is T an rvalue reference? " << std::is_rvalue_reference<T>::value << std::endl;
9
}
10

11
int main() {
12
    int a = 5;
13
    const int& ref = a;
14

15
    deduce_type(a);            // T被推导为 int&
16
    deduce_type(10);           // T被推导为 int
17
    deduce_type(ref);          // T被推导为 const int&
18
    deduce_type(std::move(a)); // T被推导为 int
19

20
    return 0;
21
}

输出：

1
Is T an lvalue reference? true
2
Is T an rvalue reference? false
3
Is T an lvalue reference? false
4
Is T an rvalue reference? true
5
Is T an lvalue reference? true
6
Is T an rvalue reference? false
7
Is T an lvalue reference? false
8
Is T an rvalue reference? true

3.3 示例代码#

以下示例展示了不同情况下模板参数T的推导结果，以及如何利用类型推导编写通用函数。

1
#include <iostream>
2
#include <type_traits>
3

4
template<typename T>
5
void display_type(T&& param) {
6
    std::cout << "Type of T: "
7
              << (std::is_lvalue_reference<T>::value ? "lvalue reference" : "rvalue reference")
8
              << ", "
9
              << (std::is_integral<typename std::remove_reference<T>::type>::value ? "Integral" : "Non-Integral")
10
              << std::endl;
11
}
12

13
int main() {
14
    int x = 10;
15
    const int& y = x;
16
    display_type(x);            // T被推导为 int&
17
    display_type(20);           // T被推导为 int&&
18
    display_type(y);            // T被推导为 const int&
19
    display_type(std::move(x)); // T被推导为 int&&
20

21
    return 0;
22
}

输出：

1
Type of T: lvalue reference, Integral
2
Type of T: rvalue reference, Integral
3
Type of T: lvalue reference, Integral
4
Type of T: rvalue reference, Integral

在此示例中，通过模板函数display_type，我们可以观察到不同参数传递方式下，模板参数T的推导结果。

4. 原样转发（Perfect Forwarding）#

4.1 定义与作用#

原样转发（Perfect Forwarding）是指在模板函数中，将接收到的参数以其原有的值类别（左值或右值）传递给另一个函数。这项技术确保了泛型代码能够像手写特定代码那样高效和正确地处理参数。

作用：

保持参数的值类别，确保正确调用函数重载。
利用移动语义，避免不必要的拷贝，提升性能。
编写通用、复用性强的代码。

4.2 实现原理#

原样转发通常结合模板万能引用（转发引用）和std::forward来实现。具体流程如下：

使用模板万能引用（T&&）接收参数。
使用

1
std::forward<T>(arg)

将参数转发给目标函数。

1
- `std::forward`根据`T`的类型，将参数转换为左值或右值。
2
- 如果参数原本是左值，`std::forward`返回左值引用。
3
- 如果参数原本是右值，`std::forward`返回右值引用。

4.3 为什么需要原样转发#

在泛型编程中，函数模板可能需要将接收到的参数传递给其他函数。若不使用原样转发，参数会失去原有的值类别信息，可能导致以下问题：

右值参数被当作左值处理，无法利用移动语义，导致性能下降。
无法正确调用目标函数的重载版本。
增加不必要的拷贝开销，影响程序性能。

通过原样转发，可以确保参数在传递过程中保持其原有的左值或右值特性，提升代码的效率和灵活性。

4.4 示例代码#

以下示例展示了如何实现一个通用的wrapper函数，通过原样转发将参数传递给目标函数，同时保留参数的值类别。

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
// 目标函数，分别有左值和右值的重载
6
void process(const std::string& s) {
7
    std::cout << "Processing lvalue: " << s << std::endl;
8
}
9

10
void process(std::string&& s) {
11
    std::cout << "Processing rvalue: " << s << std::endl;
12
}
13

14
// 通用的包装函数，实现原样转发
15
template<typename T>
16
void wrapper(T&& arg) {
17
    process(std::forward<T>(arg));
18
}
19

20
int main() {
21
    std::string name = "Alice";
22
    wrapper(name);                     // 传递左值，调用process(const std::string&)
23
    wrapper("Bob");                    // 传递右值，调用process(std::string&&)
24
    wrapper(std::move(name));          // 传递右值，调用process(std::string&&)
25

26
    return 0;
27
}

输出：

1
Processing lvalue: Alice
2
Processing rvalue: Bob
3
Processing rvalue: Alice

在上述代码中：

wrapper(name)传递的是左值，T被推导为std::string&，std::forward保持其为左值引用，调用process(const std::string&)。
wrapper("Bob")传递的是右值，T被推导为const char*，在process函数重载的选择上，这里简单化处理为调用接收右值的版本（视具体实现而定）。
wrapper(std::move(name))传递的是右值，T被推导为std::string，std::forward将其转换为右值引用，调用process(std::string&&)。

4.5 泛型工厂函数示例#

以下示例展示了如何使用原样转发实现一个泛型工厂函数，完美转发构造函数的参数，以高效创建对象。

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
// 类的定义
6
class Person {
7
public:
8
    std::string name;
9
    int age;
10

11
    // 左值引用构造函数
12
    Person(const std::string& n, int a) : name(n), age(a) {
13
        std::cout << "Constructed Person(const std::string&, int)" << std::endl;
14
    }
15

16
    // 右值引用构造函数
17
    Person(std::string&& n, int a) : name(std::move(n)), age(a) {
18
        std::cout << "Constructed Person(std::string&&, int)" << std::endl;
19
    }
20
};
21

22
// 工厂函数，使用原样转发构造函数参数
23
template<typename T, typename... Args>
24
T create(Args&&... args) {
25
    return T(std::forward<Args>(args)...);
26
}
27

28
int main() {
29
    std::string name = "Alice";
30

31
    // 传递左值
32
    Person p1 = create<Person>(name, 30);
33
    // 传递右值
34
    Person p2 = create<Person>(std::string("Bob"), 25);
35

36
    return 0;
37
}

输出：

1
Constructed Person(const std::string&, int)
2
Constructed Person(std::string&&, int)

在此示例中：

create<Person>(name, 30)传递的是左值，调用Person(const std::string&, int)构造函数。
create<Person>(std::string("Bob"), 25)传递的是右值，调用Person(std::string&&, int)构造函数。

通过原样转发，create函数能够根据传入参数的值类别，调用相应的构造函数，实现高效的对象创建。

4.6 避免不必要的拷贝#

以下示例展示了如果不使用原样转发，可能导致的多次拷贝问题。

1
#include <iostream>
2
#include <string>
3

4
// 类的定义
5
class BigObject {
6
public:
7
    std::string data;
8

9
    BigObject(const std::string& d) : data(d) {
10
        std::cout << "BigObject constructed with lvalue" << std::endl;
11
    }
12

13
    BigObject(std::string&& d) : data(std::move(d)) {
14
        std::cout << "BigObject constructed with rvalue" << std::endl;
15
    }
16
};
17

18
// 处理函数，左值和右值的重载
19
void process(const BigObject& obj) {
20
    std::cout << "Processing lvalue BigObject" << std::endl;
21
}
22

23
void process(BigObject&& obj) {
24
    std::cout << "Processing rvalue BigObject" << std::endl;
25
}
26

27
// 包装函数，不使用原样转发
28
template<typename T>
29
void bad_wrapper(T&& obj) {
30
    process(obj); // 始终以左值形式传递
31
}
32

33
// 包装函数，使用原样转发
34
template<typename T>
35
void good_wrapper(T&& obj) {
36
    process(std::forward<T>(obj)); // 原样转发
37
}
38

39
int main() {
40
    std::string s = "Sample data";
41

42
    // 使用bad_wrapper
43
    BigObject bo1 = BigObject(s);              // 使用lvalue构造
44
    BigObject bo2 = BigObject(std::move(s));   // 使用rvalue构造
45

46
    bad_wrapper(bo1); // 始终作为左值处理
47
    bad_wrapper(BigObject("Temp")); // 作为左值处理，浪费移动语义
48

49
    // 使用good_wrapper
50
    good_wrapper(bo1); // 作为左值处理
51
    good_wrapper(BigObject("Temp")); // 作为右值处理，利用移动语义
52

53
    return 0;
54
}

输出：

1
BigObject constructed with lvalue
2
BigObject constructed with rvalue
3
Processing lvalue BigObject
4
Processing lvalue BigObject
5
BigObject constructed with rvalue
6
Processing rvalue BigObject

在此示例中：

bad_wrapper函数不使用std::forward，导致即使传递的是右值，process函数也以左值形式接收，无法利用移动语义。
good_wrapper函数使用std::forward，正确保持参数的值类别，允许process函数调用右值重载，从而利用移动语义，提高性能。

5. forward源码剖析#

std::forward之所以能进行原样转发，我们来看一下源码，std::forward实现了两个版本

返回左值引用版本

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr _Tp&&
4
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
5
    { return static_cast<_Tp&&>(__t); }

重点解释#

1. **_GLIBCXX_NODISCARD**

**_GLIBCXX_NODISCARD** 是一个宏，通常定义在 libstdc++（GNU的C++标准库实现）中，用于指示编译器不要忽略函数的返回值。具体来说，它通常被定义为 C++17 引入的 [[nodiscard]] 属性，或者对应的编译器特定属性。

**[[nodiscard]]** 属性：这是C++17引入的一个属性，用于标记函数的返回值不应该被忽略。如果调用该函数的返回值被忽略，编译器会发出警告。例如：

1
[[nodiscard]] int compute() { return 42; }
2

3
void example() {
4
    compute(); // 编译器会发出警告，因为返回值被忽略
5
}

在**_GLIBCXX_NODISCARD**中的作用：通过使用这个宏，forward函数的设计者告诉编译器和使用者：调用 forward 时，返回值不应该被忽略，因为它在转发参数时起到了关键作用。如果返回值被忽略，可能会导致意想不到的行为或性能问题。

总结：_GLIBCXX_NODISCARD 确保使用 forward 时，返回的转发结果不会被无意中忽略，增强代码的安全性和正确性。

2. **constexpr**

**constexpr** 是C++11引入的一个关键字，用于指示一个函数或变量可以在编译时求值。

在函数中的作用：
- 编译时计算：constexpr 函数可以在编译时被求值，如果传入的参数也都是编译时常量。
- 优化性能：通过在编译时进行计算，可以减少运行时的开销，提高程序的性能。
在 **forward** 函数中的作用：
- 高效实现：forward 是一个轻量级的操作，通常涉及简单的静态类型转换（如 static_cast）。将其定义为 constexpr 允许编译器在可能的情况下在编译时完成这些转换，从而避免不必要的运行时开销。
- 支持常量表达式：如果在编译时上下文中使用 forward，例如在 constexpr 函数中，它能够在编译时正确地转发参数。

总结：constexpr 使得 forward 函数能够在编译时进行优化，同时确保在运行时不引入额外的开销。

3. **remove_reference**作用

源码分析

1
template<typename _Tp>
2
    struct remove_reference
3
    { using type = _Tp; };
4

5
  template<typename _Tp>
6
    struct remove_reference<_Tp&>
7
    { using type = _Tp; };
8

9
  template<typename _Tp>
10
    struct remove_reference<_Tp&&>
11
    { using type = _Tp; };

根据模板就近匹配规则，会按照最相似的方式进行匹配，优先匹配特例化版本，比如

remove_reference<int> 会调用第一个版本

remove_reference<int&>会调用第二个版本(特例化)

remove_reference<int&&>会调用第三个版本

所以我们对比这三个版本

1
remove_reference<int>::type;
2
remove_reference<int&>::type;
3
remove_reference<int&&>::type;

这三个版本的type都为int，这样达到了去引用的效果。

所以带入

typename std::remove_reference<_Tp>::type& __t

我们可以指导__t一定是个左值引用类型。

原样转发内幕

此时我们考虑对一个左值引用类型(int& )参数执行forward函数

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr _Tp&&
4
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
5
    { return static_cast<_Tp&&>(__t); }

函数各部分解释：

模板参数 **typename _Tp**：定义了一个模板类型参数 _Tp，表示要转发的类型。
**typename std::remove_reference<_Tp>::type& __t**：使用 std::remove_reference 去除 _Tp 的引用性质，然后以左值引用的形式接受参数。
**static_cast<_Tp&&>(__t)**：通过 static_cast 将参数转换为 _Tp 类型的右值引用。这是实现完美转发的关键步骤，使得被转发的参数保留其原有的值类别。
**noexcept**：指明函数不会抛出异常，有助于编译器进行优化，并提高代码的异常安全性。

__t为int&类型，TP被实例化为int&, 通过引用折叠

int& std::forward<int&>(arg)

达到了原样转发的目的。

模板参数 **typename _Tp**：定义了一个模板类型参数 _Tp，表示要转发的类型。

同样我们分析右值引用类型原样转发原理

返回右值引用版本

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr _Tp&&
4
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
5
    {
6
      static_assert(!std::is_lvalue_reference<_Tp>::value,
7
      "std::forward must not be used to convert an rvalue to an lvalue");
8
      return static_cast<_Tp&&>(__t);
9
    }

这里限制了不能将右值引用转化为左值引用。

__t是右值引用类型，当我们执行如下

int&& forward<int&&>(args)

_Tp被实例化为int&&, 返回类型通过折叠变为int&& , 参数__t变为int&&类型

6. move源码解析#

std::move源码

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr typename std::remove_reference<_Tp>::type&&
4
    move(_Tp&& __t) noexcept
5
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

可以看到move的实现很简单，无论__t是左值引用还是右值引用，都会通过

static_cast<typename std::remove_reference<_Tp>::type&&>(__t)

强制转换为去除引用的type, 再加上&&的类型，也就是具体的右值引用类型。

7. 总结#

左值与右值：理解值类别是掌握C++移动语义、资源管理和高效编程的基础。左值代表具有持久存储的对象，而右值通常是临时对象。
模板万能引用（转发引用）：通过T&&形式的模板参数，可以统一处理左值和右值，适用于泛型编程中的参数传递。引用折叠规则决定了T&&在不同上下文中的解析方式。
类型推导：编译器根据实参自动推导模板参数类型，涉及引用类型时需要理解引用折叠规则和类型推导的细节。
原样转发（Perfect Forwarding）：结合模板万能引用和std::forward，确保在泛型函数中将参数以其原有值类别传递给目标函数，避免不必要的拷贝，提升代码效率和灵活性。

1. 左值与右值#

1.1 定义与分类#

1.2 示例代码#

1.3 类型判断工具#

1.4 应用场景#

2. 模板万能引用（转发引用）#

2.1 定义与特性#

2.2 引用折叠规则#

关键点：#

2.3 示例代码#

3. 类型推导（Type Deduction）#

3.1 类型推导规则#

3.2 与引用的关系#

3.3 示例代码#

4. 原样转发（Perfect Forwarding）#

4.1 定义与作用#

4.2 实现原理#

4.3 为什么需要原样转发#

4.4 示例代码#

4.5 泛型工厂函数示例#

4.6 避免不必要的拷贝#

5. forward源码剖析#

重点解释#

6. move源码解析#

7. 总结#

文章分享

评论区