左值与右值，以及与其相关的c++11的重要特性1。-CSDN博客

int a=1;
double b=0.32;
//自定义的类型，也是左值
//下式中的右边全是右值，右值又分为：内置类型称为纯右值：一个数字或一个字面值或一个常量，它并不标识任何位置。
//自定义类型称为将亡值。
int c=a+b;
string str="adffadsf";
//函数返回值也是右值
int add(int a,int b){
    int c=a+b;
    return c;
}
//返回c时，将c拷贝给一个临时变量，这个临时变量就是右值。

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。

2. 但是const左值引用既可引用左值，也可引用右值。

int main()
 {
 // 左值引用只能引用左值，不能引用右值。
 int a = 10;
 int& ra1 = a;   
// ra为a的别名
//int& ra2 = 10;   // 编译失败，因为10是右值
// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
 const int& ra4 = a;
 return 0;
 }

右值引用总结：

1. 右值引用只能右值，不能引用左值。

2. 但是右值引用可以move以后的左值。

int main()
 {
 // 右值引用只能右值，不能引用左值。
int&& r1 = 10;
 // error C2440: “初始化”: 无法从“int”转换为“int &&”
 // message : 无法将左值绑定到右值引用
int a = 10;
 int&& r2 = a;
 // 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
 return 0;
 }

细节：对于常量的右值引用不是取别名，而是生成对象，由地址可以看出。

对于数字常量不可取地址。

右值引用使用场景和意义：

1、左值引用的使用场景：

做参数和做返回值都可以提高效率。

void func1(bit::string s)
 {}
 void func2(const bit::string& s)
 {}
 int main()
 {
 bit::string s1("hello world");
 // func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
func1(s1);
 func2(s1);
 }
 // string operator+=(char ch)  传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
s1 += '!';
 return 0;
}

编译器优化1：

一般编译器会优化省略返回值到中间变量这次拷贝

2、移动构造与移动赋值：
// 拷贝构造
string(const string& s) : _str(nullptr) {
    cout << "string(const string& s) -- 深拷贝" << endl;
    string tmp(s._str);
    swap(tmp);
}
// 赋值重载
string& operator=(const string& s) {
    cout << "string& operator=(string s) -- 深拷贝" << endl;
    string tmp(s);
    swap(tmp);
    return *this;
}
// 移动构造
string(string&& s) : _str(nullptr), _size(0), _capacity(0) {
    cout << "string(string&& s) -- 移动语义" << endl;
    swap(s);
}
// 移动赋值
string& operator=(string&& s) {
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    swap(s);
    return *this;
}
上面的代码可知：采用右值引用作为形参接受实参的构造函数和赋值运算符重载被称为移动构造和移动赋值。

当构造新对象和赋值对象时，用右值(自定义类型是将亡值)进行时，会调用移动构造和移动赋值。可以发现本质是当前构造或赋值对象与右值进行交换，这个交换会交换两值在栈区的值，右值在堆区上的内容没有改变，只是指向的指针变成了构造或赋值的对象，综上，当这条构造或赋值语句结束后，拷贝的空间仅有栈区上的指针和其他信息，也就是浅拷贝实现了深拷贝的功能，右值生命周期结束时，销毁的是构造或者赋值对象的空间。
如果拷贝构造和普通的赋值运算符重载的话，会进行深拷贝，将堆区上的内容也要拷贝一次，
由此可见，尤其是对象比较大时（堆区上存放实际信息），移动构造和移动赋值极大的减少了时间复杂度。

3、右值引用的使用场景：

namespace bit {
bit::string to_string(int value) {
    bool flag = true;
    if (value < 0) {
        flag = false;
        value = 0 - value;
    }
    bit::string str;
    while (value > 0) {
        int x = value % 10;
        value /= 10;
        str += ('0' + x);
    }
    if (flag == false) {
        str += '-';
    }
}
} // namespace bit

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造，)

编译器优化2：

虽然返回值str是局部变量为左值，因为这种应用场景十分常见，所以编译器会将str识别成右值，实现右值引用，调用移动拷贝和移动赋值.

右值引用和移动语义解决上述问题：在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

4、右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move 函数将左值转化为右值。C++11中，std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

5、完美转发

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。

template<typename T>
 void PerfectForward(T&& t)
 {
 Fun(t);
 }

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{
	Fun(std::forward<T>(t));
}

int main()
{
	PerfectForward(10);
	
	int a;
	PerfectForward(a);
	// 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);
	// 右值
	// const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

总结：

c++11增加右值引用这一语法，实现移动拷贝和移动赋值，从而避免了很多场景下的将亡值（右值）在堆区空间资源的拷贝，对右值的堆区资源的掠夺，优化了时间复杂度。STL容器插入接口函数也增加了右值引用版本，并且采用了完美转发，避免右值退化成左值。

新的类功能

(新增加的两个函数):

原来C++类中，有6个默认成员函数：

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。

         针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

        如果你没有自己实现移动构造函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

        如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似) 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

成员变量初始缺省值

类成员变量初始化 C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化，这个我们在雷和对象默认就讲了，这里就不再细讲了。

强制生成默认函数的关键字default:

强制生成默认函数的关键字default: C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。
class Person {
public:
    Person(const char* name = "", int age = 0) : _name(name), _age(age) {}
    Person(const Person& p) : _name(p._name), _age(p._age) {}
    Person(Person&& p) = default;

private:
    bit::string _name;
    int _age;
};
int main() {
    Person s1;
    Person s2 = s1;
    Person s3 = std::move(s1);
    return 0;
}

禁止生成默认函数的关键字delete

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
class Person {
public:
    Person(const char* name = "", int age = 0) : _name(name), _age(age) {}
    Person(const Person& p) = delete;

private:
    bit::string _name;
    int _age;
};
int main() {
    Person s1;
    Person s2 = s1;
    Person s3 = std::move(s1);
}
return 0;