【C++干货铺】C++11新特性——右值引用、移动构造、完美转发

=========================================================================

个人主页点击直达：小白不是程序媛

C++系列专栏：C++干货铺

代码仓库：Gitee

=========================================================================

左值与左值引用

右值与右值引用

左值引用和右值引用的比较

左值引用总结：

右值引用总结：

左值引用的作用和意义

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

移动赋值和移动构造

完美转发

std::forward 完美转发在传参的过程中保留对象原生类型属性

编辑新的类功能

默认成员函数

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

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

继承和多态中的final与override关键字

左值与左值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们
之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

//左值与左值引用
int main()
{
	//左值
	//可以取到地址
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	//左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue= *p;
	return 0;
}

右值与右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

//右值与右值引用
int main()
{
	//右值
	//右值不可以被取地址
	double x = 1.1, y = 2.2;
	10;
	x + y;
	fmin(x, y);
	//右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);

	return 0;
}

左值引用和右值引用的比较

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。

右值引用总结：

1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。

//左值引用和右值引用的比较
int main()
{
	//左值引用
	int a = 10;
	int& ra = a;
	//const 左值引用既可以引用左值又可以引用右值
	const int& ra1 = a;
	const int& ra2 = 10;

	//右值引用
	//不可以引用左值
	/*int&& r1 = a;*/
	//使用mova后可以
	int&& r1 = move(a);
	int&& r1 = 10;

	return 0;

}

左值引用的作用和意义

左值引用可以做函数的参数和函数的返回值，这样可以避免在函数传参和函数返回的时候去进行各种拷贝构造，对于一些大对象和需要进行深拷贝的对象来说，这样做可以提高效率。

左值引用的缺陷：当函数返回的对象是一个局部变量时，出了函数的作用域该对象就被销毁了，就不能使用左值引用返回，只能通过传值返回。而传值返回会导致至少调用一次拷贝构造，如果是旧一点的编译器可能是调用两次构造函数。。

    //MyString
    string& to_string(int x)
	{
		string ret;
		while (x)
		{
			int val = x % 10;
			x = x / 10;
			ret += ('0' + val);
		}
		reverse(ret.begin(), ret.end());
		return ret;
	}



int main()
{
	bit::string s; 
	s= to_string(1234);
	return 0;
}

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

其实右值含有两种形式

纯右值：编写程序时所出现的的字面值常属于纯右值
将亡值：自定义类型的临时对象

右值引用的出现完全是为了解决左值引用的缺陷的；

移动赋值和移动构造

还是对上面的代码进行分析

注：上面的代码我们先生成一个临时对象ret，函数调用结束会销毁栈帧；因此ret拷贝构造在生成一个临时对象，在由这个临时对象深拷贝生成String类的s。为了实例化这个对象我们进行了两次临时对象的创建，在由这两个临时对象进行两次深拷贝；对于很大的类时，进行这样的操作是非常浪费时间和空间的；由于中间产生了临时值（这个临时值就是我们上面所说的将亡值），而恰好临时值取不到地址是一个右值，我们可以对其引用使用移动赋值。

string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义" << endl;
	swap(s);
	return *this;
}

只需要重载一个右值引用参数类型的重载函数即可。

函数调用结束需要销毁栈帧编译器识别ret为一个临时值，并且这个临时值需要拷贝在产生一个临时值return返回，调用移动拷贝交换数据即可，释放ret；函数返回的临时值需要赋值给另外一个同类型的值，编译器识别进行移动赋值，交换数据释放临时值；这个过程就是移动赋值，及减少了临时对象的产生（将亡值），又减少了深拷贝。对于一些大的类来说进行连续的赋值节省了空间和时间。

移动构造和移动赋值的原理差不多，这里不进行过度赘述。

注：目前比较新的编译器会对连续的拷贝构造进行优化。

完美转发

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

template<typename T>
void PerfectForward(T&& t)
{
	Fun(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;
}

这是什么情况？

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

注：你也可以这样理解上面的PerfectForward函数其实是左值引用和右值引用是重载的，当传入左值时候重载，直接调用Fun函数；当传入右值时，刚好符合参数进行右值引用，但是右值的右值引用的属性是左值，因此调用Fun函数也是左值引用。

std::forward 完美转发在传参的过程中保留对象原生类型属性

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

template<typename T>
void PerfectForward(T&& t)
{
	//完美转发
	Fun(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++类中，有6个默认成员函数：

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。
C++11 新增了两个：移动构造函数和移动赋值运算符重载。

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

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