C++ 左值引用

1.左右值定义

c++11引入了右值引用。左值与右值是C语言中的概念，但C标准并没有给出严格的区分方式，一般认为：可以放在=左边的，或者能 够取地址的称为左值，只能放在=右边的，或者不能取地址的称为右值，但是也不一定完全正确。

关于左值与右值的区分不是很好区分，一般认为：

1. 普通类型的变量，因为有名字，可以取地址，都认为是左值。

2. const修饰的常量，不可修改，只读类型的，理论应该按照右值对待，但因为其可以取地址(如果只是 const类型常量的定义，编译器不给其开辟空间，如果对该常量取地址时，编译器才为其开辟空间)， C++11认为其是左值。

3. 如果表达式的运行结果是一个临时变量或者对象，认为是右值。（字面常量，返回值（传值返回））

4. 如果表达式运行结果或单个变量是一个引用则认为是左值。 (表达式，变量名等)

总结：

1. 不能简单地通过能否放在=左侧右侧或者取地址来判断左值或者右值，要根据表达式结果或变量的性质判断

2. 能得到引用的表达式一定能够作为引用，否则就用常引用。 C++11对右值进行了严格的区分：

C语言中的纯右值，比如：a+b, 100

将亡值。比如：表达式的中间结果、函数按照值的方式进行返回。

2.左右值引用比较

一般来说左值引用不能引用右值，右值引用也不能引用左值。

const int& a = 10;//加const左值引用可以引用右值
 
int b = 5;
int&& c = move(b);//用move函数可以将左值转换成右值引用

3. 移动拷贝

C++98中，拷贝构造都是深拷贝，在某些情况下就会使效率变得特别低，甚至崩溃的情况发生。在这种情形下，右值引用的作用就体现了出来。接下来模拟实现下string容器

namespace wzz
{     
    class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
 
		iterator end()
		{
			return _str + _size;
		}
 
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;
 
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
 
		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
 
 
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			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()
		{
			delete[] _str;
			_str = nullptr;
		}
 
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
 
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
 
				_capacity = n;
			}
		}
 
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
 
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
 
 
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
 
        
 
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}
 
 
wzz::string operator+(const bit::string& s, char ch)
{
	bit::string ret(s);
	ret += ch;
 
	return ret;
}
 
 
wzz::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 += '-';
	}
 
	std::reverse(str.begin(), str.end());
	return str;
}

在operator+中：ret在按照值返回时，必须创建一个临时对象，临时对象创建好之后，ret就被销毁了，最后使用返回的临时对象构造s，s构造好之后，临时对象就被销毁了。仔细观察会发现：ret、临时对象、s每个对象创建后，都有自己独立的空间，而空间中存放内容也都相同，相当于创建了三个内容完全相同的对象，对于空间是一种浪费，程序的效率也会降低，而且临时对象确实作用不是很大，那能否对该种情况进行优化呢？

C++11提出了移动语义概念，即：将一个对象中资源移动到另一个对象中的方式，可以有效缓解该问题。（就是将ret中的资源转移到临时对象中，再将临时对象中的资源转移到s对象中。不过在这里涉及编译器优化的问题，稍后看一下。)

在C++11中如果需要实现移动语义，必须使用右值引用。对上述string类增加移动构造

// 移动构造
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;
}

int main()
{
    wzz::string s1("123456");
 
    wzz::string s2(s1);
    wzz::string s3(wzz::to_string(123);//这个调用的就是移动构造，因为to_string函数返回的是一个                
                                       //临时对象，难么他就是右值。
}

4.编译器优化对比

同一串代码，看看c++98和c++11编译器是如何优化的

wzz::string s1 = wzz::to_string(123);

C++98下的编译器优化

 C++11下的编译器优化

在c++98下，优化后的效率也是会增加一半；c++11下优化后效率直线上升，没有了深拷贝的构造函数，移动构造的出现真的提升了效率。 

wzz::string s1("123");
 
//情况1
wzz::string s2;
s2 = bit::to_string(123);
 
//情况2
wzz::string s3 = bit::to_string(123);
 
//这两种初始化是不一样的，情况1是先调用构造函数，再调用移动赋值
//而情况2则是直接调用移动构造！
//所以写出移动赋值函数也是很有必要的
//因为赋值重载也是深拷贝