【C++】C++11——左右值|右值引用|移动语义|完美转发

一、左值与右值

1.概念

左值是什么？右值是什么？

左值是一个表示数据的表达式（如变量名或解引用的指针）

我们可以获取它的地址，可以对它赋值.（const修饰后的左值不能给它赋值）

注意：左值既可以出现在赋值符号的左边，也可以出现在赋值符号的右边

int main()
{//左值int a = 10;const int c = 20;a = c;int* p = new int(0);return 0;
}

右值也是一个表示数据的表达式，如：字面常量、表达式返回值、函数返回值（不能是左值引用返回）。

右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。

int main()
{double x = 1.1, y = 2.2;//右值10;x + y;func(x + y);return 0;
}

2.引用

左值引用与右值引用

C++11中新增了右值引用的特性，为了区分，把C++11之前的引用称为左值引用。

无论是左值引用还是右值引用，本质都是在给对象取别名

• 左值引用

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

int main()
{//左值int* p = new int(0);int a = 1;const int b = 2;//左值引用int*& rp = p;int& rrp = *p;int& ra = a;const int& rb = b;return 0;
}

• 右值引用

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

int main()
{//右值double x = 1.1, y = 2.2;10;x + y;func(x, y);//右值引用int&& r1 = 10;double&& r2 = x + y;double&& r3 = func(x, y);return 0;
}

3.注意

注意：

• 左值引用右值问题

左值不能引用右值，这会导致权限放大，右值可读不可写，而左值可读可写

但是有const修饰左值引用就能保证被引用的数据不会被修改了，所以const左值引用可以引用右值

所以const左值引用既可以引用左值，也可以引用右值:

int main()
{int a = 10;int& ra1 = a;//int& ra2 = 10;//10是右值,不能被左值引用//const左值引用既可以引用左值，也可引用右值const int& ra4 = a;const int& ra3 = 10;return 0;
}

• 右值引用左值问题

右值引用只能引用右值，不能引用左值

但是右值引用可以引用move以后的左值

move函数是C++11提供的一个函数，被move后的左值就能被赋值给右值引用

int main()
{//右值引用右值int&& r1 = 10;//右值引用move后的左值int a = 10;int&& r2 = move(a);return 0;
}

了解一下：

为什么要有const右值引用：我们知道右值引用不可改变，那const右值引用有什么作用：
右值不可以取地址，但是右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，如果不想rr1被修改，那就可以用const int&&rr1去引用。右值不能取地址，引用之后变成左值了

int main()
{double x = 1.1, y = 2.2;//右值引用int&& rr1 = 10;const double&& rr2 = x + y;rr1++;//可以被修改//rr2++;//不可以被修改cout<<&rr1<<endl;cout<<&rr2<<endl;return 0;
}

所以const右值引用的意义在于：右值不可修改，不可取地址；右值引用之后开空间存储下来，对于引用而言是左值，可以取地址，可以改变，这是为了移动构造，去移动换取资源，具体移动构造可见后面。

---

二、右值引用的意义

1.左值引用意义

左值引用的意义：

1.做函数参数：减少拷贝，提高效率，可做输出型参数2.做函数返回值：减少拷贝，提高效率。引用返回，可修改返回对象

但是左值引用并没有彻底的解决问题：

左值引用左返回值时，并不能避免函数返回对象时不必要的拷贝操作

如果函数的返回的是一个局部的对象，该对象出了函数作用域就被销毁了，这种情况下就不能用左值引用作为返回值了，只能以传值的方式返回（深拷贝），这是左值引用的缺陷。

//左值引用尚未解决的问题场景
template<class T>
T func3(const T& x)
{T ret;//...return ret;//返回局部对象，出作用域就会销毁
}
int main()
{func3(v1);return 0;
}

又比如to_string的模拟实现：

	string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}hwc::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;}

str是局部变量，除了作用域就会销毁：

hwc::string ret = hwc::to_string(-1234);

此时如果调用，就会调用string的拷贝构造函数

**所以C++11自然就会出手引出了右值引用：右值引用的意义之一就是为了补齐左值引用的这个短板：传值返回的拷贝问题。**其二对于插入一些插入右值数据，也可以减少拷贝。

2.右值引用和移动语义

C++11对右值进行了区分：纯右值与将亡值

• 内置类型表达式的值 —— 纯右值
• 自定义类型表达式的值—— 将亡值

移动构造：移动构造也是一个构造函数，该构造函数的参数是右值引用，移动构造实际就是把传入右值的资源转移过来，避免了深拷贝，所以称为移动构造，就是移动别人的资源来进行构造

//拷贝构造
string(const string& s):_str(nullptr), _size(0), _capacity(0){cout << "string(const string& s)->深拷贝" << endl;string tmp(s._str);swap(tmp);//this->swap(tmp)}//移动构造string(string&& s)//右值引用:_str(nullptr),_size(0),_capacity(0){cout << "string(const string& s) -- 移动拷贝" << endl;swap(s);}

int main()
{hwc::string s1("hello world");hwc::string s2(s1);//拷贝构造//move之后变成右值。将亡值hwc::string s3(move(s1));//移动构造return 0;
}

把s1移动到s3中去了，移动将亡值。

移动构造的意义:

没有移动构造之前，拷贝构造采用const左值引用来接收，所以无论是左值还是右值都会调用拷贝构造

有了移动构造之后，采用的是右值引用接收，如果传入右值，就会调用移动构造

string的拷贝构造是深拷贝，而移动构造是通过swap函数移动资源，所以调用移动构造的代价消耗更小

这个时候成本大大降低，无需深拷贝，直接资源转移。

编译器优化问题，这是之前说过的，这里重新复习一下：

如果返回局部对象时，会先用这个局部对象拷贝构造出一个临时对象，然后再用这个临时对象来拷贝构造我们接收返回值的对象；

编译器会优化成：只需要一次拷贝构造：

ps:右值引用swap()的是将亡值，拷贝构造中不能直接swap,因为对象不是将亡值：

int main()
{hwc::string s1("12345");hwc::string s2(s1);return 0;
}

移动赋值

移动赋值就是一个赋值运算符重载函数，参数是右值引用类型，移动赋值就是将传入右值的资源转移过来，这样就避免了深拷贝，这也是移动赋值的由来。

//operator=string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}//移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s)->移动赋值拷贝" << endl;swap(s);return *this;}

int main()
{hwc::string ret;ret = hwc::to_string(-1234);
}

移动赋值的意义:

没有移动赋值前，原先operator=采用的是const左值引用接收参数，所以无论赋值时传入左值还是右值都会调用原来的operator=。但是移动赋值采用了右值引用接收参数，所以如果赋值时传入的是右值，那么调用的就是移动赋值函数。而string原来的operator=是深拷贝，而移动赋值通过swap把资源进行转移，代价比原先的operator=代价小。

to_string返回局部对象时，调用移动构造生成一个临时对象，然后在调用移动赋值将临时对象资源转移到接收返回值的对象上，这个过程调用了两个函数但却只是资源的移动，不需要进行深拷贝。（右值引用延长生命周期：资源延长了）

总结：右值引用和左值引用减少拷贝的原理不太一样。左值引用是取别名直接起作用，右值引用是间接起作用，实现移动构造和移动赋值，在拷贝的场景中如果是右值（将亡值），转移资源。

3.容器新增

C++11之后，STL中容器就增加了移动构造与移动赋值：

比如string新增移动构造

比如string新增移动赋值

另外，C++11为STL容器的插入接口也增加了右值引用：

我们来看一看区别：在hwc命名空间里list插入接口没有实现右值引用：

在std里list插入接口实现了右值引用：

string类提供了移动构造函数，并且容器的push_back接口提供了右值引用版本，如果push_back函数传入的参数string对象也是一个右值，那么push_back函数就可以通过string的移动构造函数来进行资源的转移，避免了深拷贝，提高效率。

---

三、万能引用

右值引用本身是左值。

模板中&&并不是右值引用，而是万能引用，既能接收左值也能接收右值，同时也能接收const左值、const右值：

//万能引用
template <typename T>
void PerfectForward(T&& t)
{}
int main()
{int x = 1;PerfectForward(x);//左值PerfectForward(10);//右值PerfectForward(move(x));//右值const int y = 20;PerfectForward(y);//const左值PerfectForward(move(y));//const右值return 0;
}

万能引用会根据传入实参的类型进行推导，如果传入的实参是一个左值，那么这里的形参t就是左值引用，如果传入的实参是一个右值，那么这里的形参t就是右值引用，同时t是可以++的，而如果加上const左值、cosnt右值t就不可以++。举个例子：

void Func(int& x)
{cout << "左值引用" << endl;
}
void Func(const int& x)
{cout << "const 左值引用" << endl;
}
void Func(int&& x)
{cout << "右值引用" << endl;
}
void Func(const int&& x)
{cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{Func(t);
}
int main()
{int x = 1;PerfectForward(x);//左值PerfectForward(10);//右值，右值引用再传递时属性是左值PerfectForward(move(x));//右值const int y = 20;PerfectForward(y);//const左值PerfectForward(move(y));//const右值return 0;
}

PerfectForward传递的参数分别是左值、右值、右值、const左值、const右值，但是结果都是左值

这是因为右值引用后会导致右值被存储到特定的位置，此时右值具有左值的属性，可以被取地址也可以被修改，所以PerfectForward函数调用Func函数会将t识别为左值。

而如果想要在传递参数的过程之中保持右值的属性，这就需要用到完美转发了。

---

四、完美转发

如果想要在参数传递的过程中保持其原有的属性，则需要在传参时调用forward函数：

void Func(int& x)
{cout << "左值引用" << endl;
}
void Func(const int& x)
{cout << "const 左值引用" << endl;
}
void Func(int&& x)
{cout << "右值引用" << endl;
}
void Func(const int&& x)
{cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{Func(std::forward<T>(t));
}
int main()
{int x = 1;PerfectForward(x);//左值PerfectForward(10);//右值，右值引用再传递时属性是左值PerfectForward(move(x));//右值const int y = 20;PerfectForward(y);//const左值PerfectForward(move(y));//const右值return 0;
}

用完美转发给简化list提供右值引用的push_back与insert接口：

namespace hwc
{template <class T>struct list_node{list_node<T>* _next;list_node<T>* _prev;T _data;list_node(const T& x):_next(nullptr), _prev(nullptr), _data(x){}//右值引用list_node(T&& x):_next(nullptr), _prev(nullptr), _data(forward<T>(x))//完美转发{}};template<class T, class Ref, class Ptr>struct __list_iterator{typedef list_node<T> node;typedef __list_iterator<T, Ref, Ptr> Self;node* _pnode;__list_iterator(node*p):_pnode(p){}//......};template<class T>class list{typedef list_node<T> node;public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;iterator begin(){return iterator(_head->_next);}iterator end(){return iterator(_head);}void empty_initialize(){_head = new node(T());_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_initialize();}//左值引用void push_back(const T& x){insert(end(), x);}//右值引用void push_back(T&& x){insert(end(), forward<T>(x));//完美转发}//左值引用iterator insert(iterator pos,const T& x){node* newnode = new node(x);node* cur = pos._pnode;node* prev = cur->_prev;newnode->_prev = prev;prev->_next = newnode;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}//右值引用iterator insert(iterator pos, T&& x){node* newnode = new node(forward<T>(x));//完美转发node* cur = pos._pnode;node* prev = cur->_prev;newnode->_prev = prev;prev->_next = newnode;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}private:node* _head;size_t _size;};
}

int main()
{hwc::list<hwc::string> lt;hwc::string s1("111111");lt.push_back(s1);//左值——深拷贝lt.push_back(hwc::string("222222"));lt.push_back("3333333");return 0;
}

---

本篇结束…