当你在学习语言的时候，是否经常听到过一种说法,"="左边的叫做左值，"="右边的叫做右值。这句话对吗？从某种意义上来说，这句话只是说对了一部分。
---前言
一、什么是左右值?
通常认为:
左值是一个表示数据的表达式(如变量名或解引用的指针)， 我们可以 获取它的地址 + 可以对它赋
值(使用空间) ，左值可以出现赋值符号的左边，也可以出现在等号右边。
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值等等。右值 可以出现在赋值符号的右边 ，但是 不能出现在赋值符号的左边 ， 右值不能取地址 。
//x \ y 都是左值 都可以取地址
double x = 1.1, y = 2.2;
int a = 10,b = 20;
//以下都是右值 都不用取地址
10;
x + y;
func();二、左右值引用
(1)左值引用
type& x;
在我们学习引用的时候，一定会和C语言的指针联系到一起。我们来看看下面的swap代码吧。
void SwapByPtr(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void SwapByVal(int a, int b)
{
int tmp = a;
a = b;
b = a;
}
结果我想你一定知道的！函数传值与函数传地址是不同的！一个是一份拷贝，一个是记录的地址，可以访问原变量。
但是我们知道，指针是有它的缺陷，如果不是一位资深程序员，甚至你是，也得对指针的使用报以"敬畏之心"。因此，在C++中引入了新的语法，"引用"。虽然它底层仍然是用指针实现的，但是却比指针用起来更加方便。
void SwapByRef(int& a,int& b)
{
int tmp = a;
a = b;
b = a;
}
(2)右值引用
我们时常说"引用","引用"，其实都是"左值引用"。为了区别左值引用呢，右值引用的语法格式上是这样的。
type &&;
int a = 10;
int& ra = a; //左值引用
int&& rra = 10; //右值引用(3)左右值引用的特性
左值引用:
①只能引用左值，不能引用右值
②但是const左值引用 可以引用右值也可以引用左值
int a = 10;
int& ra = a; //只能引用左值
int& rb1 = 10; //不能引用右值 ×
//既可以引用左值、也可以引用右值
const int& rb2 = a;
const int& rb2 = 10; 右值引用:
①右值引用只能引用右值，不能引用左值
②标准库中提供move()函数，可以将一个左值变为右值
int a = 10;
int&& rra1 = 10; //只能引用右值
int&& rra2 = a; //不能引用左值 ×
//move后可以 a变成了右值
int&& rra3 = std::move(a);右值不能取地址，但是右值引用能够取地址!!
右值当然没有地址，但是我们给右值取引用时，那么这个右值引用就该有它的地址，并且可以对它引用的对象进行修改。如果你不想允许让对右值引用的值发生改变，请给它+"const"吧。
为什么这么设计呢？这和右值引用的场景有关，也就是我们之后要细讲的。
当然，这很符合我们的预期。
三、左右值引用的应用场景
也许你会疑问，已经有了左值引用，为什么还需要右值引用呢？右值引用一定有它存在必要的场景。在此之前，我们就先来列举列举左值引用的使用场景吧。
左值引用场景:
①函数传参防拷贝。
②函数返回值 引用返回。
//函数传参防拷贝
vector<int>& Func(vector<int>& ret)
{
ret.push_back(1);
//...
//函数引用返回值
return ret;
}当要进行左值引用返回时，唯一一个条件时，该对象出了作用域仍然存在！那如果该对象就是在函数体内创建的，出了作用域它就会销毁，但其拷贝的代价又很大。遇到这样的情况，我们应该怎么处理呢？
(1)移动赋值与移动构造
我们首先实现一个to_string的函数，用来将一个数字，转换为自定义字符串。
//to_string函数
string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
dy::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;
}//自定义string 类
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)
{
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 = nullptr;
size_t _size = 0;
size_t _capacity = 0; // 不包含最后做标识的\0
};我们此时用一个整数，使用to_string函数，得到一个自定义string类型。
int main()
{
int x = 1234;
dy::string ret = dy::to_string(x);
return 0;
}
但是，我们为了一个在to_string函数类，一个出作用域就会销毁的对象，为了得到它其中的资源，就得付出"深拷贝"一份的代价，未免有些太大。
如果仅仅是拷贝内置类型来说，那么微乎其微，但如果深拷贝对象是map、set呢？也许你仅仅只需要得到这个即将销毁对象的"根节点"即可，而非是在return返回时，让该对象拷贝构造临时对象而付出巨大代价。
秉持这样的想法，我们为该自定义类设计一个新的拷贝构造函数。
//移动赋值与移动构造
string(string&& s)
{
cout << "string(string&& s): 移动构造" << endl;
swap(s);
}
string& operator=(string&& s)
{
cout << "string& operator=(string s) 移动赋值" << endl;
swap(s);
return *this;
}我们为该类增加这两个函数，并再次运行相同的代码。
这是为什么？？该对象的"拷贝"没有选择去调用"深拷贝"？那么，我们不得不搞懂以下的三个问题！
能够搞懂上述的问题，我们也就能够预知编译器会选择怎样做。
那如果是以下这样的调用，会打印出什么呢？
int main()
{
dy::string ret2;
ret2 = dy::to_string(123);
return 0;
}
小结:
左值引用与右值引用减少拷贝的方式是不一样的：
左值引用是直接起作用的，就是给一个变量取别名。
右值引用是间接起作用的，利用移动构造、移动赋值 实现的是一种资源的转移。而被转移的资源也叫做 "将亡值"。也就是出了这个作用域，就会销毁的对象。
四、左右值引用的其他应用
(1)完美转发
在前文已经提到过，一旦给右值取别名时，那么该右值引用名义上虽然是右值的别名，但本质是一个可以取地址、甚至可以改变的左值。我们来看看如下的代码。
void Func(int& x)
{
cout << "左值引用" << endl;
}
void Func(int&& x)
{
cout << "右值引用" << endl;
}
void GetFunc(int&& x)
{
Func(x);
}
int main()
{
int a = 10;
GetFunc(10);
return 0;
}唔，我们分别重载了两个函数Func,一个是用来接收左值引用的、一个是来接收右值引用的，我们传进来的是一个右值10，那么很显然调用后打印的是 "右值引用"。
当右值引用作为参数时，虽然名义上接收的是右值，但是向下传递时，已经改变为了左值。但是我们就想让它保持原有的属性。
C++库中给提供了一个函数转发
std::forward<type>();
我们也就可以看到如我们的预期结果。
(2)万能引用
函数参数有左值引用、也有右值引用，C++中也有模板，那是否模板也有模板左值引用与模板右值引用呢？ 是的！
template<class T>
void PerfectFunc(T& x)
{
Func(x);
}
template<class T>
void PerfectFunc(const T& x)
{
Func(x);
}
但其实这都用得不多。因为接下来的操作可能会惊掉你的下把。
template<class T>
void PerfectFunc(T&& x)
{
Func(x);
}
这什么鬼？？？
在有模板的情况下;
template<class T>
void Func(T&& ..);
就叫做 "万能引用！"
当然，如果你没好好阅读上文，你可能还会惊奇，为什么只会调用左值引用与const左值引用。我们只需要让向下传入的值保持原属性即可。
由此可见，我们能万能引用的情况下，肯定不会去选择"T&"这单调的左值引用参数。
总结:
①左右值区分的最根本方法是，能否取地址，能否使用它的空间。
②左值引用只能引用左值,右值引用只能引用右值。但是const 左值引用可以引用左值 也可以引用右值。
③右值一定没有地址并且不能修改，但是右值引用有它自己的地址，非const可以进行修改。
④左值引用的防拷贝方式更加直接显著。右值引用防拷贝的方式是间接的，也叫"资源转移"。
⑤std::move()可以将一个左值变为右值。std::forward<T>()能保持参数的原属性。
本篇到此结束，感谢你的阅读。
祝你好运，向阳而生~
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
