C/C++编程：完美转发

你的名字 2022-11-11 13:24 162阅读 0赞

> C++11标准为C++引入右值引用语法的同时，还解决了一个C++98/03标准长期存在的短板，**即用简单的方式即可在函数模板中实现参数的完美转发**。那么什么是完美转发？它为什么是 C++98/03 标准存在的一个短板？C++11 标准又是如何为 C++ 弥补这一短板的？

# 什么是完美转发 #

**完美转发，指的是函数模板可以将自己的参数“完美”的转发给内部调用的其他函数。****所谓完美，即不仅能准确的转发参数的值，还能保证被转发参数的左右值属性不变**。

举个例子：

template<typename T>
    void function(T t) {
        
        otherdef(t);
    }

如上所示，function() 函数模板中调用了 otherdef() 函数。在此基础上，完美转发指的是：如果 function() 函数接收到的参数 t 为左值，那么该函数传递给 otherdef() 的参数 t 也是左值；反之如果 function() 函数接收到的参数 t 为右值，那么传递给 otherdef() 函数的参数 t 也必须为右值。

**显然，`function`函数模板并没有实现完美转发。一方面，参数`t`为非引用类型，这意味着在调用`function()`函数时，实参将值传递给形参的过程就需要额外进行一次拷贝操作；另一方面，无论调用`function()`函数模板时传递给参数t的是左值还是右值，对于函数内部的参数t来说，它有自己的名称，也可以获取它的存储地址，因此它永远都是左值，也就是说，传递给 otherdef() 函数的参数 t 永远都是左值。总之，无论从那个角度看，function() 函数的定义都不“完美”。**

> 读者可能会问，完美转发这样严苛的参数传递机制，很常用吗？C++98/03标准中几乎不会用到，但C++11标准为C++引入了右值引用和移动语义，因此很多场景中是否实现完美转发，直接决定了该参数的传递过程使用的是拷贝语义（调用拷贝构造函数）还是移动语义（调用移动构造函数）

事实上，C++98/03标准下的C++可可以实现完美转发，只是实现方式比较笨拙。

C++98/03标准中只有左值引用，并且可以细分为非const引用和const引用。其中，使用非const引用作为函数模板参数时，只能接收左值，无法接收右值；而const左值引用既可以接收左值，也可以接收右值，但考虑其cont属性，除非被调用的参数也是const属性，否则无法直接传递

这也意味着，单独使用任何一种引用形式，可以实现转发，但是无法保证完美。因此，如果C++99/03标准下的C++语言，我们可以采用函数模板重载的方式实现完美转发，比如：

#include <iostream>
    using namespace std;
    //重载被调用函数，查看完美转发的效果
    void otherdef(int & t) {
        
        cout << "lvalue\n";
    }
    void otherdef(const int & t) {
        
        cout << "rvalue\n";
    }
    //重载函数模板，分别接收左值和右值
    //接收右值参数
    template <typename T>
    void function(const T& t) {
        
        otherdef(t);
    }
    //接收左值参数
    template <typename T>
    void function(T& t) {
        
        otherdef(t);
    }
    int main()
    {
        
        function(5);//5 是右值
        int  x = 1;
        function(x);//x 是左值
        return 0;
    }

![在这里插入图片描述][20210322161045106.png]  
从输出结果中可以看到，对于右值 5 来说，它实际调用的参数类型为 const T& 的函数模板，由于 t 为 const 类型，所以 otherdef() 函数实际调用的也是参数用 const 修饰的函数，所以输出“rvalue”；对于左值 x 来说，2 个重载模板函数都适用，C++编译器会选择最适合的参数类型为 T& 的函数模板，进而 therdef() 函数实际调用的是参数类型为非 const 的函数，输出“lvalue”。

显然，使用重载的模板实参实现完美转发也是有弊端的，此实现方式仅适用于模板参数有少量参数的情况，否则就要编写大量的重载函数模板，造成代码冗余。为了方便用于更快速的实现完美转发，C++标准中允许在函数模板中使用右值引用来实现完美转发。

C++标准中规定，**通常情况下右值引用形式的参数只能接受右值，不能接受左值。但对于函数模板中使用右值引用语义定义的参数来说，它不在遵守这一规定，既可以接收右值，也可以接收**

仍以 function() 函数为例，在 C++11 标准中实现完美转发，只需要编写如下一个模板函数即可：

template <typename T>
    void function(T&& t) {
        
        otherdef(t);
    }

此模板函数的参数 t 既可以接收左值，也可以接收右值。但仅仅使用右值引用作为函数模板的参数是远远不够的，还有一个问题继续解决，即如果调用 function() 函数时为其传递一个左值引用或者右值引用的实参，如下所示：

int n = 10;
    int & num = n;
    function(num); // T 为 int&
    int && num2 = 11;
    function(num2); // T 为 int &&

其中，由 function(num) 实例化的函数底层就变成了 function(int & & t)，同样由 function(num2) 实例化的函数底层则变成了 function(int && && t)。要知道，C++98/03 标准是不支持这种用法的，而 C++ 11标准为了更好地实现完美转发，特意为其指定了新的类型匹配规则，又称为引用折叠规则（假设用 A 表示实际传递参数的类型）：

*  当实参为左值或者左值引用（A&）时，函数模板中 T&& 将转变为 A&（A& && = A&）；
 *  当实参为右值或者右值引用（A&&）时，函数模板中 T&& 将转变为 A&&（A&& && = A&&）。

> 当然，我们没有必要记那么多，只要知道，在实现完美转发时，只要函数模板的参数类型为`T &&`，则C++可以自行准确的判定出实现传入的实参是左值还是右值。

通过将函数模板的形参类型设置为 T&&，我们可以很好地解决接收左、右值的问题。但除此之外，还需要解决一个问题，即无论传入的形参是左值还是右值，对于函数模板内部来说，形参既有名称又能寻址，因此它都是左值。那么如何才能将函数模板接收到的形参连同其左、右值属性，一起传递给被调用的函数呢？

C++11 标准的开发者已经帮我们想好的解决方案，该新标准还引入了一个模板函数 forword()，我们只需要调用该函数，就可以很方便地解决此问题。仍以 function 模板函数为例，如下演示了该函数模板的用法：

#include <iostream>
    using namespace std;
    //重载被调用函数，查看完美转发的效果
    void otherdef(int & t) {
        
        cout << "lvalue\n";
    }
    void otherdef(const int & t) {
        
        cout << "rvalue\n";
    }
    //实现完美转发的函数模板
    template <typename T>
    void function(T&& t) {
        
        otherdef(forward<T>(t));
    }
    int main()
    {
        
        function(5);
        int  x = 1;
        function(x);
        return 0;
    }

注意程序中第 12~16 行，此 function() 模板函数才是实现完美转发的最终版本。可以看到，forword() 函数模板用于修饰被调用函数中需要维持参数左、右值属性的参数。

**从技术上来讲，完美转发就是通过引用坍缩规则和模板推导规则，使得转发函数在不损失任何数据属性的情况下，将数据完美的传递给其他函数**。

完美转发在标准库中被广泛使用，也是泛型编程中一种很好的包装方式。

# 总结 #

总的来说，在定义模板函数时，我们采用**右值引用的语法格式定义参数类型**，由此该函数既可以接收外界传入的左值，也可以接收右值；其次，还需要使用 C++11 标准库提供的**forword() 模板函数修饰被调用函数中需要维持左、右值属性的参数**。由此即可轻松实现函数模板中参数的完美转发。

using namespace std;
    
    void fun(int &x) {
         
    	cout << "lvalue ref" << endl; 
    }
    void fun(int &&x) {
         
    	cout << "rvalue ref" << endl;
    }
    void fun(const int &x) {
         
    	cout << "const lvalue ref" << endl;
    }
    void fun(const int &&x) {
         
    	cout << "const rvalue ref" << endl;
    }
    
    template<typename T>
    void PerfectForward(T &&t) {
         
    	fun(std::forward<T>(t));
    }
    
    int main1(int argc , CHAR* argv[]) {
        
    	fun(10);           // rvalue ref
    
    	int a;
    	fun(a);            // lvalue ref
    	fun(std::move(a)); // rvalue ref
    
    	const int b = 8;
    	fun(b);            // const lvalue ref
    	fun(std::move(b)); // const rvalue ref
    
    	system("pause");
    	return 0;
    }
    
    int main2(int argc , CHAR* argv[]) {
        
    	PerfectForward(10);           // rvalue ref
    
    	int a;
    	PerfectForward(a);            // lvalue ref
    	PerfectForward(std::move(a)); // rvalue ref
    
    	const int b = 8;
    	PerfectForward(b);            // const lvalue ref
    	PerfectForward(std::move(b)); // const rvalue ref
    
    	system("pause");
    	return 0;
    }

[20210322161045106.png]: /images/20221022/bfb37f6f10ad41d48803e8cb12989786.png