CPP11-右值引用-CFANZ编程社区

右值引用是cpp11引入的很重要的特性，是为了支持一下两个特性而引入的：

去除不必要的对象内存拷贝，极大提高了程序运行效率
在泛型中支持完美转发（Perfect Forwarding），提升编程效率

说在前面：一下所有代码均在g++编译器上进行编译并验证过的

右值引用

我们先来看看它和左值引用的区别

左值：int a = 1;其中a就是左值，那种非临时的对象即有分配内存且有名字的对象就是左值
右值：A a = A(100);其中A(100)就是右值，那种临时对象且之作用于单条语句的对象就是右值。右值也可以称之为“将亡值”即即将销毁的对象
总的来说，一个是临时对象，一个是非临时对象。cpp11引入了这个特性为了做好左值和右值的区分。那做好区分了之后呢？有什么作用呢？这个就需要讲到移动语义了

移动语义

移动语义也叫转移语义，移动语义可以将对象内的内存资源管理权转移到另外一个对象中。移动语义和拷贝语义是相对应的，这两者的区别跟拷贝和剪切的区别一样。因此，移动语义的效率要高于拷贝语义。

为了方便理解，我们可以将移动拷贝构造对应浅拷贝，拷贝构造对应深拷贝。
~~~~c++
#include <iostream>
using namespace std;
class A
{
public:
A() { cout << "A()" << endl; }
A(const A&) { cout << "A(const A&)" << endl; } // 拷贝构造
A(A&&) { cout << "A(A&&)" << endl; } // 移动拷贝构造
A self() { return *this; }
};

int main()
{
A a;
A a1(a);
A a2(a.self());
getchar();
return 0;
}

编译执行，输出如下
~~~~c++
A()
A(const A&)
A(const A&)

发现输出不符合预期，没有调用移动拷贝构造函数。是因为编译器进行了返回值优化（RVO），需要加上编译参数-fno-elide-constructors来关闭RVO。注意：visual studio无法关闭返回值优化，测试可使用g++编译器
加上-fno-elide-constructors参数后编译执行，输出如下
~~~~c++
A()
A(const A&)
A(const A&)
A(A&&)

看了上面的例子，很容易会发现一个很别扭的写法。为什么要这样`A a2(a.self());`通过调用`A::self`获取`a`对象而不直接使用`a`进行传参？这不是多此一举了？当然这是为了演示使用临时对象（将亡值）构造A对象而取了巧哈哈哈。那有什么方式可以不需要这么麻烦呢？
其实cpp11提供了`std::move`函数来解决这个问题！调用这个函数并没有任何移动，内部实现只是做了一个类型转化，使其可以将左值引用转化为右值引用。最终`a2`对象的构造可以改为`A a2(std::move(a));`

`std::move`的实现如下
~~~~c++
// FUNCTION TEMPLATE std::move
template<class _Ty> _NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept
{   // forward _Arg as movable
    return (static_cast<remove_reference_t<_Ty>
}

但是要注意的是执行A a2(std::move(a));后，对象a的内存就托管给a2，所以对象a成为了无效对象。在往后的编程中要注意没有必要则不要滥用std::move，例如对于一些临时对象就没有必要使用std::move。

完美转发（Perfect Forwarding）

我们先来看看完美转发的使用场景，在讲具体场景前我们先来看看下面代码：
~~~~c++
#include <iostream>
using namespace std;
void sum(int a, int b)
{
cout << a + b << endl;
}

void concat(const string& a, const string& b)
{
cout << (a + b).c_str() << endl;
}

template <typename FUNC, typename A, typename B>
void invoke(FUNC f, const A& a, const B& b)
{
f(a, b);
}

int main()
{
invoke(sum, 10, 10);
invoke(concat, "Hello ", "world");
return 0;
}

执行结果如下：
~~~~c++
20
Hello world

一切正常，完美~但是如果这时我们需要增加一个方法，那问题就来了
~~~~c++
void increase(int a, int & b)
{
b = ++a;
}

然后用同样的方法进行调用
~~~~c++
    int b = 0;
    invoke(increase, a, b);
    cout << b << endl;

会发现g++编译报错error: binding reference of type ‘int&’ to ‘const int’ discards qualifiers。注：vs2017是编译通过并且结果是符合预期，还未深究是否是编译器进行了优化还是cpp17的特性。

如果在没有完美转发（Perfect Forwarding）特性之前我们是如何解决这个问题的呢？很简单，针对这种情况再重载一个方法就可以了
~~~~c++
template <typename FUNC, typename A, typename B>
void invoke(FUNC f, const A& a, B& b)
{
f(a, b);
}

但是如果我们还需要支持`&, const &`, `&, &`类型的参数呢？我们来看看重载后的效果~
~~~~c++

template <typename FUNC, typename A, typename B>
void invoke(FUNC f, const A& a, const B& b)
{
    f(a, b);
}

template <typename FUNC, typename A, typename B>
void invoke(FUNC f, A& a, const B& b)
{
    f(a, b);
}
template <typename FUNC, typename A, typename B>
void invoke(FUNC f, const A& a, B& b)
{
    f(a, b);
}
template <typename FUNC, typename A, typename B>
void invoke(FUNC f, A& a, B& b)
{
    f(a, b);
}

相信你已经意识到问题在哪了~如果我们到支持N个参数，就需要重载2^N个方法，这对于开发人员来说就是噩梦！！
这时完美转发（Perfect Forwarding）就应运而生了哈哈，那我们来看看该如何改造
~~~~c++
template <typename FUNC, typename A, typename B>
void invoke(FUNC f, A&& a, B&& b)
{
f(a, b);
}

改造之后可以正常运行，且代码明显精简很多了哈哈，**但实际上，上面改造还存在问题！！**

首先我们来回顾一个知识点，请问：`void invoke(FUNC f, A&& a, B&& b)`中的a是左值引用还是右值引用？
相信大部分同学会脱口而出**右值引用**，因为类型是`A&&`。很好~可惜回答错误，**a是一个左值引用**!

我在再来看看左值引用的定义：
> 非临时的对象即有分配内存且有名字的对象就是左值

因此，如果我们需要转发一个右值引用时，上面的改造显然是不够的，这时候我们就需要引入一个转发的重量级方法`std::forward`
最终改造如下：
~~~~c++
template <typename FUNC, typename A, typename B>
void invoke(FUNC f, A&& a, B&& b)
{
    f(std::forward<A>(a), std::forward<B>(b));
}

我们来看看std::forwark的定义
~~~~c++
template<class _Ty>
_NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept
{ // forward an rvalue as an rvalue
static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
return (static_cast<_Ty&&>(_Arg));
}


`std::forward`也只是做了类型转换，为什么`A&&`可以实现完美转发呢？这里面就涉及到两个概念``万能引用``和``引用折叠``

### 万能引用
`T&&`就是一个万能引用，即可以接受任何类型的参数，`T`为模板类型T。我们都知道`T`是一个类型占位符，因此`T`可以是`&&`、`&`、`const &`等。进而可以知道会推导成`T&& &&`、`T& &&`、`const T& &&`。我们都知道cpp编译器是不允许构建引用的引用这个类型的，那这些`T&& &&`、`T& &&`、`const T& &&`是什么呢？这就是我们下面要介绍的**引用折叠**的内容

### 引用折叠
这些“引用的引用”就是cpp11编译器在推导`万能引用`的具体类型时的中间状态，具体推导规则如下

| 中间状态 | 推导类型 |
| -- | -- |
| T& && | T& |
| T&& & | T& |
| T& & | T& |
| T&& && | T&& |

有了以上的推导规则构成完美转发的基础

## 参考文章
* [C++11: Perfect forwarding | De C++ et alias OOPscenitates](https://oopscenities.net/2014/02/01/c11-perfect-forwarding/)
* [聊聊C++中的完美转发 - 知乎](https://zhuanlan.zhihu.com/p/161039484)