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

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

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

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

#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();
}

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");
}

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

#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";
}

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 为万能引用

#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)
}

#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;           // 由于以引用的方式传递, 这里内存中的数值也一样会修改
}