1. 右值引用和移动语义

1.1 左值和右值

左值 local value：存储在内存中、有明确存储地址（可寻址）的数据（x、y、z）
右值 read value：不一定可以寻址，例如存储于寄存器中的数据；通常字面量都是右值，除了字符串常量（1、3）

int x = 1;
int y = 3;
int z = x + y;

　对于x++和++x虽然都是自增操作，但x++编译器首先生成一份临时值，然后对x自增，最后返回临时内容，所以x++是右值；++x是对x递增后返回自身，所以++x是左值

x++;    // 右值引用
++x;    // 左值引用
int *p1 = &x++;    // 右值引用所以编译失败
int *p2 = &++x;    // 左值引用可以编译成功

1.2 左值引用和右值引用

左值引用：必须引用一个左值。
常量左值引用：可以引用左值或右值。因为右值的生命周期被延长了，但这种引用存在一个问题，常量左值引用导致无法修改对象内容。

int &x1 = 7;         // 非常量左值引用 编译错误
const int &x = 11;   // 语句结束后，11的生命周期被延长了
const int x = 11;    // 语句结束后，11立刻被销毁

右值引用：引用右值且只能引用右值的方法

int &&k = 11;    // 右值引用（延长右值的生命周期）

　　对于数字的表示可能不太清晰，因为数字本身就有些虚无缥缈，下面用一个类的例子来更好解释右值引用的优势，可以减少复制构造来优化性能（但实际上编译器会帮我们优化）

优化前：MyClass&& mc = make_myclass(); 调用后
- ctor: 调用mc的构造函数
- copy ctor:返回值时调用mc的拷贝函数
- dtor: 返回值后将mc销毁调用析构函数（注意这里的复制构造函数会存在问题：如果是浅复制，此时销毁的对象会把堆区内存销毁导致新的对象空引用，所以还是强调必须重写复制构造函数）
- 由于右值引用，延长了右值的生命周期
- dtor: main函数结束再调用一次析构函数

编译器优化后：MyClass&& mc = make_myclass(); 调用后
- ctor: 调用构造函数
- dtor: 调用析构函数

MyClass mc = make_myclass(); 该函数调用后
- ctor: 调用mc的构造函数
- copy ctor: 返回值调用mc的拷贝函数
- dtor: 返回值后销毁mc 调用析构函数
- copy ctor: 为了构造mc2 调用构造函数
- dtor: 销毁返回值临时变量调用析构函数
- dtor: main函数结束后再调用一次析构函数

#include <iostream>
using namespace std;
class MyClass {
public:
    char* pc;
    MyClass();
    MyClass(const MyClass& myclass);
    ~MyClass() { cout << "dtor" << endl; delete pc; }
    void show() { cout << "Show: " << pc << endl; }
};

MyClass::MyClass() {
    cout << "ctor" << endl;
    pc = new char[10];
    for (int i = 0; i < 10; i++)
        pc[i] = 'c';
}

MyClass::MyClass(const MyClass& myclass) {
    cout << "copy ctor" << endl;
    pc = myclass.pc;
    for (int i = 0; i < 10; i++)
        pc[i] = myclass.pc[i];
}

MyClass make_myclass() {
    MyClass mc;    // 1.构造函数     3.析构函数（此时如果是浅复制，新的对象指向的内存也将为空
    return mc;     // 2.拷贝函数
}

int main() {
    MyClass&& mc = make_myclass();    // 返回值的生命周期被延长
    mc.show();
    cout << endl;
    MyClass mc2 = make_myclass();    // 再次调用拷贝构造函数
    mc2.show();
}

1.3 移动语义

　　上面其实已经用到了移动语义，移动语义主要就是解决C++复制构造对性能的影响。但也存在问题，例如移动构造函数运行过程中发生了异常，这会造成源对象和目标对象都不完整。这里再用一个例子说明，该Useless类内有一个元素个数为 n 的 char 数组，静态变量 ct 记录了对象个数。

Useless one(20, 'o'); 调用 int char 构造函数
Useless one(20, 'c'); 调用 int char 构造函数
Useless three(one + two);
- one + two 调用 operator+ 运算符重载，在内部调用 int 构造函数构造了对象 temp
- 返回值后调用移动语义构造函数，夺走 temp 里指针指向的内容并把它的指针设置为空，这样它在销毁时不会把堆区内存清空
- 临时对象 temp 被销毁

class Useless {
public:
    int n;            // 元素个数
    char* pc;        // 数据指针
    static int ct;    // 对象个数
    void ShowObject()const;
    Useless(int k);
    Useless(int k, char ch);
    Useless(Useless&& f);        // 移动构造
    ~Useless();
    Useless operator+(const Useless& f)const;
    void ShowData() const;
};
int Useless::ct = 0;
Useless::Useless(int k) :n(k) {
    printf("int 参数的构造函数; 对象个数为: %d\n", ++ct);
    pc = new char[n];
    ShowObject();
}
Useless::Useless(int k, char ch) :n(k) {
    printf("int char参数的构造函数; 对象个数为: %d\n", ++ct);
    pc = new char[n];
    for (int i = 0; i < n; i++){
        pc[i] = ch;
    }
    ShowObject();
}
Useless::Useless(Useless&& f) :n(f.n) {
    printf("移动构造函数; 对象个数为: %d\n", ++ct);
    pc = f.pc;
    f.pc = nullptr;
    f.n = 0;
    ShowObject();
}

Useless::~Useless() {
    printf("析构函数调用; 元素个数为: %d\n", --ct);
    ShowObject();
    delete[] pc;
}

Useless Useless::operator+(const Useless& f)const {
    printf("进入 operator+\n");
    Useless temp = Useless(n + f.n);
    for (int i = 0; i < n; i++)
        temp.pc[i] = pc[i];
    for (int i = n; i < temp.n; i++)
        temp.pc[i] = f.pc[i - n];
    printf("离开 operator+\n");
    return temp;
}

void Useless::ShowObject() const {
    printf("元素个数: %d, 数据地址: %x\n", n, (void*)pc);
}

void Useless::ShowData()const {
    if (n == 0)
        printf("元素个数为空\n");
    else
        for (int i = 0; i < n; i++)
            printf("%c ", pc[i]);
    printf("\n");
}

int main()
{
    Useless one(20, 'o');    // int char 构造函数 对象个数1
    printf("\n");
    Useless two(20, 'c');    // int char 构造函数 对象个数2
    printf("\n");
    Useless three(one + two);    // 1. operator+ 调用 int 构造函数 对象个数3;  2. operator+ 返回右值, 调用移动构造函数(减少了复制的次数) 对象个数4;  3.临时对象被销毁 对象个数3
    printf("\n");
    printf("object one: \n");
    one.ShowData();
    printf("object two: \n");
    two.ShowData();
    printf("object three: \n");
    three.ShowData();
    printf("\n");
}

1.4 强制移动

　　移动构造函数和移动赋值运算符都必须使用右值，但如果让他们使用左值就需要一些特殊处理

Useless choices[10];
Useless best;
int pick = 5;
best = chioces[pick];    // 由于这里是左值，所以会调用普通的复制赋值运算符

　　可以使用C++11头文件utility中提供的move函数来实现将左值转换为右值，但是注意右值的字段会被夺走，并且必须定义了移动赋值运算符或移动构造函数

#include <iostream>
#include <utility>
#include <vector>
#include <string>
int main()
{
    std::string str = "Hello";
    std::vector<std::string> v;
    //调用常规的拷贝构造函数，新建字符数组，拷贝数据
    v.push_back(str);
    std::cout << "After copy, str is \"" << str << "\"\n";
    //调用移动构造函数，掏空str，掏空后，最好不要使用str
    v.push_back(std::move(str));
    std::cout << "After move, str is \"" << str << "\"\n";
    std::cout << v[0] << ", " << v[1] << "\n";
}

2. 万能引用

　　很多时候我们希望传递的是一个引用而非通过拷贝构造传递，这可以提高程序效率；但仅仅通过fn(className& c)来传递引用会导致不能传递右值，fn(const className& c)又会导致传递进来的参数不能被修改，所以提出了万能引用的概念

2.1 引用折叠

　　万能引用实际上就是发生了类型推导，如果源对象是一个左值，则推导出左值引用；如果源对象是一个右值，则推导出右值引用。

void foo(int &&i) {}    // i为右值引用
template<class T> void bar(T &&t) {}    // t为万能引用
template<class T> void bar(vector<T> &&t) {}    // 非万能引用，必须是直接的T
int get_val() {return 5;}
int &&x = get_val();    // x 为右值引用
auto &&y = get_val();   // y 为万能引用

　　C++11 通过一套引用叠加推导的规则来实现万能引用——引用折叠，可以注意到实际类型是左值引用，则最终类型一定是左值引用；只有引用类型是一个非引用类型或者右值引用，最后推导出来的才是一个右值引用

　　通过下面几行代码理解引用折叠，首先是C++11规定的展开时的定义

实参类型为T的左值, 则模板T展开为T& int => int&(T)
- 此时Test形参的类型为 T& &&，经过折叠后为 T& 左值引用
- 此时static_cast<T&>(t) 将t转为左值引用，所以调用左值引用的函数
实参类型为T的右值, 则模板T展开为T int => int(T)
- 此时Test形参的类型为 T &&，所以为右值引用
- 此时static_cast<T&&>(t) 将t转为右值引用，所以调用右值引用的函数

#include <iostream>
void process(int& i) {
    std::cout << "左值引用" << std::endl;
}
void process(int&& i) {
    std::cout << "右值引用" << std::endl;
}
template<class T>
void Test(T&& t) {
    process(static_cast<T&&>(t));
}
int main() {
    int a = 1;
    Test(a);    // C++11规定 实参类型为T的左值, 则模板T展开为T& int => int&(T)
    Test(1);    // C++11规定 实参类型为T的右值, 则模板T展开为T  int => int(T)
}

2.2 完美转发

　　通过 std::forward<T>() 可以实现完美转发，不论左值还是右值都可以通过引用的方式传参，提高程序运行的效率。下面给出了一个完美转发的例子，打印了 T 的实际类型，并通过修改 t 的值实现了修改 a 的值（传入左值即左值引用），同样如果传入类的右值一样是右值引用。

#include <iostream>
template<class T>
void show_Type(T&& t) {
    std::cout << "is int&: " << std::is_same_v<T, int&> << std::endl;
    std::cout << "is int : " << std::is_same_v<T, int> << std::endl;
    t = 10;
}

template<class T>
void perfect_forwarding(T&& t) {
    show_Type(std::forward<T>(t));
}

int main()
{
    int a = 5;
    perfect_forwarding(5);    // 该参数在不同函数间始终以右值引用方式传递
    perfect_forwarding(a);    // 该参数在不同函数间始终以左值引用方式传递
    std::cout << a;           // 由于以引用的方式传递, 这里内存中的数值也一样会修改
}