移动语义和右值引用

右值引用：

c++的传统引用（现在成为左值引用）使得时标符关联到左值。左值是一个表示数据的表达式（如变量名或解除引用的指针），程序可以获取其地址。

C++11新增了右值引用，用&&表示。右值引用可以关联到右值，即可出现在赋值表达式的右边，但不能对其应用地址运算符的值。右值包括字面常量、如x+y等表达式以及返回值的函数：

int x =10;

int y = 23;

int &&r1= 13;

int &&r2 = x+y;

double && r3 = std::sqrt(2.0);

注意：r2关联到的是当时计算x+y得到的结果。也就是说，r2关联到的是23，即使以后修改了x或y,也不会影响到r2。

下面代码简要演示了关于右值引用的要点：

#include <iostream>
#include <string>
using namespace std;

inline double f(double tf)
{
	return 5.0*(tf - 32.0) / 9.0;
}

int main()
{
	using namespace std;

	double tc = 21.5;
	double && rd1 = 7.07;
	double && rd2 = 1.8*tc + 32.0;
	double && rd3 = f(rd2);
	cout << "tc value and address: " << tc << ", " << &tc << endl;
	cout << "rd1 value and address: " << rd1 << ", " << &rd1 << endl;
	cout << "rd2 value and address: " << rd2 << ", " << &rd2 << endl;
	cout << "rd3 value and address: " << rd3 << ", " << &rd3 << endl;
	cin.get();

	return 0;
}

输出：

tc value and address: 21.5, 008FF910
rd1 value and address: 7.07, 008FF8F4
rd2 value and address: 70.7, 008FF8D8
rd3 value and address: 21.5, 008FF8BC
 

引入右值引用的主要目的之一是实现移动语义。

移动语义：

为什么要移动语义：

vector<string> allcaps(const vector<string> &vs)
{
    vector<string> temp;
    ....
    ........
    return temp;
}

接下来，以这种方式使用它：

vector<string> vstr;

vector<string> vstr_copy1(vstr);                       //#1
vector<string> vstr_copy2(allcaps(vstr));              //#2

深入探索这段代码，发现allcaps（）创建了对象temp，该对象管理着20000000个字符；vector和string的复制构造函数创建这20000000个字符的副本，然后程序删除allcaps（）返回的临时对象。这里的重点是：做了大量的无用功！因为临时对象被删除了，如果编译器将对数据的所有权直接转让给vstr_copy2，不是更好吗？这类似于在计算机中移动文件的情形，实际文件还留在原来的地方，只修改记录。这种方法被称为移动语义。

实现移动语义：

下来我们来说说如何实现移动语义。要实现移动语义，需要采用某种方式，让编辑器知道什么时候需要复制，什么时候不需要。

（1）常规的复制构造函数。使用const左值引用作为参数，这个引用关联到左值实参。

（2）移动构造函数。使用右值引用作为实参，该引用关联到右值实参。

复制构造函数构造函数可以进行深度复制，而移动构造函数只调整记录。所谓的“窃取”资源。

实例：

#include<iostream>
#include<utility>
using namespace std;

class Useless
{
private:
	int n;
	char *pc;
	static int ct;
	void ShowObject()const;

public:
	Useless();
	explicit Useless(int k);
	Useless(int k, char ch);
	Useless(const Useless &f);
	Useless(Useless && f);
	~Useless();

	Useless operator+(const Useless & f)const;

	Useless & operator=(const Useless & f);
	
	Useless & operator=(Useless && f);

	void ShowData()const;

};

int Useless::ct = 0;

Useless::Useless()
{
	++ct;
	n = 0;
	pc = nullptr;
	//cout << "default constructor called; number of objects: " << ct << endl;
	//ShowObject();
}

Useless::Useless(int k) :n(k)
{
	++ct;
	//cout << "int constructor called;number of objects: " << ct << endl;
	pc = new char[n];
	//ShowObject();
}

Useless::Useless(int k, char ch) :n(k)
{
	++ct;
	//cout << "int, char constructor called; number of objects: " << ct << endl;
	pc = new char[n];
	for (int i = 0; i < n; i++)
		pc[i] = ch;
	//ShowObject();
}

Useless::Useless(const Useless & f) :n(f.n)
{
	++ct;
	//cout << "copy const called; number of objects: " << ct << endl;
	pc = new char[n];
	for (int i = 0; i < n; i++)
		pc[i] = f.pc[i];
	//ShowObject();
}

Useless::Useless(Useless && f) :n(f.n)
{
	++ct;
	//cout << "move constructor called; number of objects: " << ct << endl;
	pc = f.pc;
	f.pc = nullptr;
	f.n = 0;
	//ShowObject();
}

Useless::~Useless()
{
	cout << "destructor called; objects left: " << --ct << endl;
	cout << "deleted object:\n";
	ShowObject();
	delete[] pc;
}

Useless & Useless::operator=(const Useless & f)
{
	std::cout << "copy assigment operator called:\n";
	if (this == &f)
		return *this;

	delete[]pc;

	n = f.n;
	pc = new char[n];
	for (int i = 0; i < n; i++)
		pc[i] = f.pc[i];

	return *this;
}

Useless & Useless::operator=(Useless && f)
{
	std::cout << "move assignment operator called:\n";
	if (this == &f)
		return *this;
	delete [] pc;

	n = f.n;
	pc = f.pc;
	f.n = 0;
	f.pc = nullptr;

	return *this;
}

Useless Useless::operator+(const Useless & f)const
{
	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];

	cout << "temp object:\n";
	cout << "Leaving operator+()\n";

	return temp;
}

void Useless::ShowObject()const
{
	std::cout << "Number of elements: " << n;
	std::cout << " Data address: " << (void *)pc << std::endl;
}

void Useless::ShowData()const
{
	if (n == 0)
		std::cout << "(object empty)";
	else
		for (int i = 0; i < n; i++)
			std::cout << pc[i];

	std::cout << std::endl;
}

实例选自于c++ primer plus

调用函数：

版本1：

int main()
{
	{
		Useless one(10, 'x');
		Useless two = one;
		Useless three(20, 'o');
		Useless four(one + three);
		cout << "object one: ";
		one.ShowData();
		cout << "object two: ";
		two.ShowData();
		cout << "object three: ";
		three.ShowData();
		cout << "object four: ";
		four.ShowData();
	}

	return 0;

}

版本2：

int main()
{
	{
		Useless one(10, 'x');
		Useless two = one + one;
		cout << "object one: ";
		one.ShowData();
		cout << "object two: ";
		two.ShowData();
		Useless three, four;
		cout << "three = one\n";
		three = one;
		cout << "now object three = ";
		three.ShowData();
		cout << "and object one = ";
		one.ShowData();
		cout << "four = one + two\n";
		four = one + two;
		cout << "now object four = ";
		four.ShowData();
		cout << "four = move(one)\n";
		four = move(one);
		cout << "now object four = ";
		four.ShowData();
		cout << "and object one = ";
		one.ShowData();

	}
}

先来看看移动构造函数：

Useless::Useless(Useless && f) :n(f.n)
{
	++ct;
	//cout << "move constructor called; number of objects: " << ct << endl;
	pc = f.pc;
	f.pc = nullptr;
	f.n = 0;
	//ShowObject();
}

他让pc指向现有的数据，获取这些数据的所有权。此时，pc和f.pc指向相同的数据，调用析构函数会带来麻烦，因为程序不可能delete两次。为避免这种问题，随后将原来的指针(f.pc)设置为空。这种夺取所有权的方式常被称为“窃取”。

由于要修改原始的对象数据，所有这要求不能再函数参数声明中，使用const。

在版本一中，下面这个语句调用了这个移动构造函数：

Useless four(one + three);

表达式one+three调用了Useless::operator+()，而右值引用f将关联到该方法返回的临时对象。

版本一调用结果：

Useless::operator+()中创建的对象的数据地址，与four存储的数据地址相同（都是007C7C40），其中对象four是由移动复制构造函数创建的。另外，创建four对象之后，为临时对象调用了析构函数。

移动构造函数发生条件：

要让移动语义发生，需要两个步骤，首先，右值引用让编译器知道何时可使用移动语义：

Useless two = one;     //Useless::Useless(const Useless &)

Useless four(one + three);    //Useless::Useless(Useless &&)

对象one是左值，而表达式one+three是右值，与右值引用匹配。

第二步骤是：编写移动构造构造函数。

那么问题来了：上述代码如果没有移动构造函数呢？结果会怎样？其实也很简单，稍微想想就是答案。我去掉移动构造函数之后，输出如下：

这里我跟书上的结果不太一样，应该是编辑器优化的问题，自动消除额外的一些工作，具体在c++ primer plus 808页。但是仍然可以反映出问题，最后调用的是拷贝构造函数。

版本二：

多了使用移动复制运算符，以及move。

Useless & Useless::operator=(const Useless & f)
{
	std::cout << "copy assigment operator called:\n";
	if (this == &f)
		return *this;

	delete[]pc;

	n = f.n;
	pc = new char[n];
	for (int i = 0; i < n; i++)
		pc[i] = f.pc[i];

	return *this;
}

move：上述我们说到，移动构造函数和移动复制运算符，参数使用右值。那么如果要让她使用左值怎么办呢？

我们可以使用static_cast<>将对象强制转为Useles&&，或者更简便的方式-使用Move（）.

版本二输出如下：

本文实例选自c++ primer plus。简单的说明了移动语义和右值引用，并没有高级的写法，比如考虑异常等信息。