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

//可以取地址对象，就是左值
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);
}