·左值既可以出现在表达式的左边也可以出现在表达式的右边

//可以取地址对象，就是左值
int main()
{
	int a = 10;
	int& r1 = a;
	int* p = &a;
	int& r2 = *p;

	const int b = 10;
	const int& r3 = b;

	return 0;
}

什么是右值？

·右值不能被取地址也不能被修改

·右值只能出现在表达式的右边不能出现在表达式左边

//不能取地址对象，就是右值
int main()
{
	double x = 1.1, y = 2.2;

	//常见的右值
	10;
	x + y;
	fmin(x, y);

	//cout << &fmin(x, y) << endl;

	return 0;
}

左值引用与右值引用

传统的C++语法中就有引用的语法，而在C++11中更新了右值引用的语法。为了进行区分，我们将C++11之前的引用叫做左值引用，将C++11之后更新的引用叫做右值引用，不论是左值引用还是右值引用，它们的本质都是 “取别名”。

左值引用

左值引用就是对于左值的引用，即对左值取别名，通过&来声明

下面是一段代码示例

// 以下的p b c *p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;

// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pv= *p;

右值引用

右值引用就是对右值的引用,即对右值取别名,通过&&来声明

下面是一段代码示例

//不能取地址对象，就是右值
int main()
{
	double x = 1.1, y = 2.2;

	//常见的右值
	10;
	x + y;
	fmin(x, y);

	//cout << &fmin(x, y) << endl;

	//右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);

	return 0;
}

左值引用可以引用右值吗？

• 左值引用不能引用右值，左值是可以被修改的而右值是不可以被修改的，这里涉及到一个权限放大的问题
• 如果想要用左值引用来引用右值，需要用到const关键字来修饰左值引用，因为经过const修饰后左值引用就没有修改的权限了

因此const左值引用可以引用左值也可以引用右值

template<class T>
void func(const T& val)
{
	cout << val << endl;
}

int main()
{
	string s("hello");
	func(s);                    //s为变量 左值

	func("world");              // "world"是常量 右值
	return 0;
}

右值引用可以引用左值吗？

• 右值引用只能引用右值不能引用左值
• 如果想要用右值引用来引用左值，需要用到move函数

move函数是C++11标准提供的一个函数，被move后的左值能够被右值引用引用

int main()
{
	//左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;

	//左值引用能否引用右值 -- 不能直接引用，但是const左值引用可以引用右值
	//void push_back(const T& x)
	const int& r1 = 10;
	const double& r2 = x + y;
	const double& r3 = fmin(x, y);

	//右值引用能否引用左值 -- 不能直接引用，但是右值引用可以引用move以后左值
	int*&& rr1 = move(p);
	int&& rr2 = move(*p);
	int&& rr3 = move(b);
	const int&& rr4 = move(c);

	return 0;
}

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

虽然使用const修饰的左值引用能够同时引用左值和右值，但是左值引用终究是存在一些缺陷，而C++11提出的右值引用正是用来解决这些缺陷的

我们写出一个简单string类来

namespace qwe
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_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;
		}

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

		string operator+(char ch)
		{
			string tmp(*this);
			push_back(ch);

			return tmp;
		}

		const char* c_str() const
		{
			return _str;
		}

	private:
		char* _str;
		size_t _size;
		size_t _capacity;   
	};
}

左值引用的使用场景

在说明左值引用的缺陷之前我们先来看它的使用场景

• 做参数--防止传参时进行拷贝构造
• 做返回值--防止返回时对返回对象进行拷贝构造

void func1(shy::string s)
{}

void func2(const shy::string& s)
{}

int main()
{
	shy::string s("hello world");
	func1(s);                       
	func2(s);                        // 左值引用传参
	s += 'X';                        // 左值引用返回
	return 0; 
}

func1它传递的参数是形式参数，他是实际参数的一份临时拷贝

func2它传递的参数是s的别名，是左值引用

最后是+=，它返回的也是一份左值引用

string的拷贝是深拷贝，深拷贝的代价是很高的，所以说这里的左值引用效果很明显

左值引用的缺陷
左值引用虽然能避免不必要的拷贝操作 但是缺不能完全避免

左值引用做参数，能够完全避免传参时的拷贝操作
左值引用做返回值，不能完全避免函数对象返回时的拷贝操作
如果函数返回对象是一个局部变量，那么该变量出了局部作用域就会被销毁

这种情况下不能使用左值引用作为返回值，只能传值返回，这就是左值引用的短板

比如说我们实现一个to_string函数 将字符串转化为int类型 此时它的返回值就必须要是值拷贝 如果使用左值引用返回就会返回一个销毁的局部变量

代码表示如下

namespace qwe 
{
	string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
			str += (x + '0');
		}
		if (flag == false)
		{
			str += '-';
		}
		std::reverse(str.begin(), str.end());
		return str;
	}
}

我们在调用to_string函数返回的时候会调用拷贝构造函数

C++11提出右值引用就是为了解决左值引用的这个缺陷，但是它的解决方法并不是单纯的将右值引用作为返回值

右值引用和移动语义

// 移动构造 
string(string&& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	cout << "string(string&& s)" << endl;
	swap(s);
}