目录
上文介绍了C++11的基本新特性，本文继续介绍C++11重要的特性—— 右值引用和移动语义
左值引用和右值引用
传统的C++语法中就有引用的语法，但是没有什么所谓的左值的概念，而C++11中新增了的右值引用语法特性，所以从现在开始之前学习的引用就叫做左值引用。而无论左值引用还是右值引用，都是给对象取别名。
点睛
左值引用：
左值引用也就是给对象起别名，可以达到减少拷贝的作用，在实际中频繁使用，可以有效提升程序的效率，但是也有左值引用无法解决的问题；如：返回一个临时对象，这时就无法使用左值引用了，只能使用传值的方法，这样就不可避免的会出现多余的拷贝问题。于是乎C++11推出了右值引用的新语法解决该问题，进一步提升程序的效率，也进一步体现了C++作为高效性编程语言的特点。
右值引用：
右值引用是C++11的重大更新之一，它的出现很好的解决了临时资源浪费的问题，同时也给类和对象做了一个全面升级，使其规避了很多低效拷贝问题，由此特性也引出了接下来的移动语义。
什么是左值？什么是左值引用？
左值是一个表示数据的表达式(如变量名或解引用的指针)：
- 我们可以获取它的地址+可以对它赋值（定义时
const修饰符后的左值不能给它再次赋值） - 左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。
左值引用就是给左值的引用，给左值取别名。
int main()
{
//以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
cout << &p << endl;
cout << &*p << endl;
cout << &b << endl;
cout << &c << endl;
//以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}
什么是右值？什么是右值引用？
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等
- 右值不能取地址，也无法被修改
- 右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，
右值引用就是对右值的引用，给右值取别名。
引用的语法
左值引用的用法是在类型后面加一个&，如：int&，double&，string&。
右值引用的用法则是类型后面加两个&&，如：int&&，double&&，string&&。
int main()
{
double x = 1.1, y = 2.2;//左值
// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);//一个函数
// 以下几个都是对右值的右值引用
cout << typeid(fmin(x, y)).name() << endl;
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
return 0;
}
注意，左值是可以放在=的左右任意一边的，右值只能出现在=的右边，不能出现在=的左边，否则会出现下面的编译报错。
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值,右值必须在=右边
//10 = 1;
//x + y = 1;
//fmin(x, y) = 1;
总结
从语法层面看，区分左右值的最根本就是看其能否取地址，能取地址的则为左值，反之则为右值
对于常量16而言，是无法进行取地址操作的，编译器不会允许这种写法，因为16是常量，为右值。但是取不了地址不代表常量16没有自己的空间，它也有存放自己的地址空间，一般为代码段。
所以左值右值只是语法层的定义，对于实际操作的编译器底层来说，根本就没有什么左右值的概念，只是为了学习时更好理解，在语法层做出解释。所以对于左值右值，只需要按照语法定义的来理解就可以了，不必深究。
右值引用实现的机制
给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。 如果不想rr1被修改，可以用const int&& rr1 去引用，但实际中右值引用的使用场景，这个特性也不重要。
int main()
{
double x = 1.1, y = 2.2;
int&& rr1 = 10;
const double&& rr2 = x + y;
rr1 = 20;
rr2 = 5.5; // 报错
return 0;
}
以下是MSVC实现右值引用的机制。也是上述右值引用能够被修改的原因。但是这并不是右值引用的意义；右值引用这样实现的目的是为了支持接下来所要学习的移动语义；为了实现移动构造，那么右值引用本身必须是可修改的，也就是所说的退化为左值了。
如下图：分别使用r1引用一个左值，rr1引用一个右值，通过查看汇编可以看到，编译器在编译这些代码时，做的是一模一样的操作，左值都知道会有自己的空间，那么右值同理也应该有自己的空间，只是在语法层编译器不会允许你去对右值取地址的操作。
左值引用与右值引用比较
左值引用总结：
- 左值引用只能引用左值，不能引用右值。
- 但是const左值引用既可引用左值，也可引用右值
int main()
{
// 左值引用只能引用左值，不能引用右值。
int a = 10;
int& ra1 = a; //ra为a的别名
//int& ra2 = 10; // 编译失败，因为10是右值
// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
return 0;
}
const左值可以引用右值：这里会涉及权限是否放大的问题，右值在语法层是不允许取地址，不允许被修改的，一般多为常量，但左值加上const后，可以保证所引用的实体不被修改，在语法层也就通过编译器的检查了，所以const左值可以引用右值。
右值引用总结：
- 右值引用只能右值，不能引用左值。
- 但是右值引用可以move以后的左值
int main()
{
// 右值引用只能右值，不能引用左值。
int&& r1 = 10;
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
//int&& r2 = a;//err
// 右值引用可以引用move以后的左值,move只将a标识为右值，本质是强转
int&& r3 = move(a);
int&& rr3 = (int&&)a;//强转
return 0;
}
move
move是一个函数模板：其作用为返回对参数的右值引用，从而右值引用能引用move以后的左值。具体请看——move参考文档
右值引用除了引用move以后的左值，也可以引用强转之后的左值。且move的本质实际上就是强转。
static_cast<remove_reference<decltype(arg)>::type&&>(arg)
- 注意，move以后会返回该对象的右值，允许其资源被窃取，但该对象本身仍是左值，只不过其资源有可能比被转移了，再去访问该对象可能会导致未定义行为，所以使用move时需要谨慎；
以上就是左右值引用的语法，通过特定方法可以互相引用，接下来就是右值引用的应用场景。
右值引用使用场景和意义
通过上述介绍，我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！
借助我们之前实现的string来观察；注意，在拷贝构造和赋值重载函数开头加上打印语句来直观看出调用了该函数
namespace djs
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
string(const char* str = "")
:_size(strlen(str))
{
//cout << "string(const char* str = "") 构造" << endl;
_capacity = _size == 0 ? 3 : _size;//防止空串+=问题。空串提前开好空间
_str = new char[_capacity + 1];
strcpy(_str, str);
}
string(const string& s)
:_str(nullptr)
{
//方便观察
cout << "string(const string& s) -- 深拷贝" << endl;
string tmp(s._str);
swap(tmp);
}
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
_capacity = _size = 0;
}
string& operator= (const string& str)
{
//方便观察
cout << "string& operator= (const string& str) 深拷贝" << endl;
if (str._size > _capacity)
{
reserve(str._size);
}
strcpy(_str, str._str);
_size = str._size;
return *this;
}
string& operator= (char c)
{
//方便观察
cout << "string& operator= (const string& str) 深拷贝" << endl;
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
_str[_size++] = c;
_str[_size] = '\0';
return *this;
}
const char* c_str()
{
return _str;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin()const
{
return _str;
}
const_iterator end()const
{
return _str + _size;
}
void reserve(size_t n = 0)
{
if (n > _capacity)//大于才开
{
char* tmp = new char[n + 1];//记得开'\0'的位置
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;//将容量设置好
}
}
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
char& operator[](size_t pos)
{
assert(pos <= _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos <= _size);
return _str[pos];
}
string& operator+=(char c)
{
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
_str[_size++] = c;//_size记得++
_str[_size] = '\0';
return *this;
}
string& operator+= (const char* s)
{
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, s);
_size += len;//_size记得++
return *this;
}
void push_back(char c)
{
*this += c;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
static size_t npos;
};//string
size_t string::npos = -1;
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 += ('0' + x);
}
if (flag == false)
{
str += '-';
}
reverse(str.begin(), str.end());
return str;
}
}
左值引用的使用场景：
做参数和做返回值都可以提高效率，减少不必要的拷贝。
只有func1需要进行拷贝且该拷贝是没有意义的，使用引用传参更为合理，程序效率更高。
void func1(djs::string s)//会导致深拷贝
{}
void func2(const djs::string& s)
{}
int main()
{
djs::string s("hello world");
func1(s); //值传参
func2(s); //左值引用传参
s += 'X'; //左值引用返回
return 0;
}
左值引用的短板：
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：djs::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少一次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
int main()
{
///在djs::string to_string(int value)函数中可以看到，这里
//只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
djs::string ret1 = djs::to_string(1234);
cout << endl;
djs::string ret2 = djs::to_string(-1234);
cout << endl;
return 0;
}
传值返回理论上会进行两次拷贝构造，但比较新的编译器会优化成一次拷贝构造。
- 注意：赋值重载是相对于已存在的对象而言，此处虽说是=，但却不是赋值重载，而是拷贝构造。
那么函数to_string的返回值是左值还是右值呢？看看下面这段代码：对Fun函数的返回值进行++，发现要求必须是左值才能++，所以从这段代码可以看出，函数的返回值是右值，右值的函数返回值仅作为向调用者提供一个结果，再无其它用途，仅作告知作用。
int Fun(int x)
{
return x;
}//传值返回，会在上一层栈帧中将x交给寄存器，再由寄存器拷贝给a
int main()
{
int a = Fun(10)++;//err
return 0;
}
函数返回值是如何返回的
补充一个小知识点：函数返回值是如何返回的？
不需要看得懂太多的汇编指令，只需要理解这个概念：由于两个函数位于不同栈帧，当Fun函数结束时，会释放Fun栈帧中的所有资源，所以其返回值只能先保存在寄存器如eax当中，等返回到main函数栈帧时，再将eax里的值拷贝给对象，完成值的返回。其中编译器优化了的那一次拷贝就是交给寄存器这一次。而寄存器作为计算机硬件资源，不能对其取地址或进行后续修改，所以值传递的函数返回值为右值。
当然，返回值使用临时对象保存再返回也是一种策略。
以下为AI解答：C++函数返回值的临时对象一般是寄存器吗？
在C++中，函数返回值的临时对象一般不是直接存储在寄存器中的，而是存储在内存中的某个位置，通常是栈上。然而，编译器可能会对返回值进行优化，以减少不必要的拷贝和移动操作，这包括使用寄存器来传递小型的返回值。
总之，值传递的函数返回值为右值。
思考
而临时变量的生命周期由编译器管理，通常在函数返回后立即销毁，那么能否好好利用这个临时变量呢？
右值引用和移动语义
在djs::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己
移动构造
移动构造，就是窃取别人的资源来构造自己，所以，直接使用string的swap交换这个临时对象即可
string(string&& s)//右值引用
{
//提示作用
cout << "string(const string&& s) 移动构造" << endl;
swap(s);
}
此时再跑这段代码，发现，这里没有调用深拷贝的拷贝构造，而是调用了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了，而且原本的临时对象本就是将要销毁的，现在充分利用了这个资源，属实是榨满了。
int main()
{
///在djs::string to_string(int value)函数中可以看到，这里
//只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
djs::string ret1 = djs::to_string(1234);
cout << endl;
djs::string ret2 = djs::to_string(-1234);
cout << endl;
return 0;
}
不仅仅有移动构造，还有移动赋值；
//移动赋值
string& operator= ( string&& str)
{
cout << "string& operator= ( string&& str) 移动赋值" << endl;
swap(str);
return *this;
}
在djs::string类中增加移动赋值函数，再去调用djs::to_string(1234)，不过这次是将djs::to_string(1234)返回的右值对象赋值给ret1对象，这时调用的是移动构造。
int main()
{
djs::string ret1;
ret1 = djs::to_string(1234);
return 0;
}
这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。djs::to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为djs::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值
STL中的容器新增移动构造和移动赋值
如
右值引用引用左值及其一些更深入的使用场景分析
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
move的使用要小心，不然一不小心就会给人把你的资源窃取了。如下面的s1。
int main()
{
djs::string s1("hello world");
// 这里s1是左值，调用的是拷贝构造
djs::string s2(s1);
// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
// 资源被转移给了s3，s1被置空了。
djs::string s3(std::move(s1));
return 0;
}
可以看到，s1被move之后，被标记为右值，一旦碰到移动构造或者移动赋值，就可以将move后对象的资源交换。这样s1的资源就没有保障了，最终被转移到s3上了，而s1则是空空如也。
所以要谨慎使用move，否则就可能会造成意想不到结果
完美转发
现在思考一个问题， 右值引用本身是左值还是右值？
参考下面这段代码
PerfectForward这个函数模板中的参数T&&的&&不是右值引用，而是万能引用
- 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
- 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
- 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值
template<typename T>
void PerfectForward(T&& t)//万能引用
{
Fun(t);
}
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
template<typename T>
void PerfectForward(T&& t)
{
Fun(t);
}
int main()
{
PerfectForward(10);// 右值
int a;
PerfectForward(a);// 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b);// const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
}
由于右值在传递的过程中会发生退化，变为左值，也就是说函数PerfectForward中的参数t无论接收的是左值还是右值，由于退化的缘故，t都为左值；所以以上程序的结果为：左值引用
我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
forward
函数模板std::forward ，即完美转发在传参的过程中保留对象原生类型属性。，向下传递时，继续保留其左右值的属性，确保其不会退化成左值。
在向下传参时借助forward即可。
Fun(std::forward<T>(t));
具体细节请看——forward参考文档
完美转发实际中的使用场景暨容器新增接口
除了移动构造或者移动赋值增加了右值引用的接口，各大容器中的插入接口都增加了右值引用的接口。具体请自行查阅——容器新增右值引用接口
以list的右值引用的push_back接口为例
为演示效果，提供一个模拟实现的list，并在对应函数打上提示语句展示效果。
#pragma once
#include<iostream>
#include<assert.h>
using std::cout;
using std::endl;
using std::initializer_list;
namespace djs
{
template<class T>
struct list_node
{
T _data;//数据
list_node<T>* _prev;//前驱指针
list_node<T>* _next;//后继指针
list_node(const T& x = T())//const左值引用右值，x本身就是左值，所以此处的会匹配到string的深拷贝构造函数
:_data(x)//此处的_data为string
,_prev(nullptr)
,_next(nullptr)
{}
};
template<class T,class Ref,class Ptr>//用一个类封装迭代器去模拟指针的行为，该类的成员函数为运算符重载函数（模拟指针行为）
struct __list_iterator
{
typedef list_node<T> Node;
typedef __list_iterator<T,Ref,Ptr> self;
Node* _node;
__list_iterator(Node* node)
:_node(node)
{}
//前置
self& operator++()
{
_node = _node->_next;
return *this;
}
self& operator--()
{
_node = _node->_prev;
return *this;
}
//后置
self operator++(int)
{
Node* tmp(_node);
_node = _node->_next;
return tmp;
}
self operator--(int)
{
Node* tmp(_node);//
_node = _node->_prev;
return tmp;
}
bool operator==(const self& it)//it为迭代器，_node为节点
{
return _node == it._node;
}
bool operator!=(const self& it)
{
return _node != it._node;
}
Ref operator*()
{
return _node->_data;//返回引用
}
Ptr operator->()
{
return &_node->_data;//返回其地址
}
};
template<class T>
class list
{
typedef list_node<T> Node;
//构造时以下操作多，设为私有不公开
void list_init()//开好头节点
{
_head = new Node();//*
//_head = new Node(T());//移动构造
_head->_next = _head;
_head->_prev = _head;
}
public:
typedef __list_iterator<T,const T&,const T*> const_iterator;//使用那个迭代器就实例化哪一个迭代器
typedef __list_iterator<T,T&,T*> iterator;
list()
{
list_init();//开好头节点
}
~list()
{
clear();
delete _head;
_head->_next = _head->_prev = nullptr;
}
list(const list<T>& lt)
{
list_init();
for (const auto& e : lt)
{
push_back(e);
}
}
list& operator= (list<T> lt)
{
swap(lt);
return *this;
}
iterator begin()
{
//return _head->_next;
return iterator(_head->_next);
}
iterator end()
{
return _head;
}
const_iterator begin()const
{
return _head->_next;
}
const_iterator end()const
{
return _head;
}
iterator insert(iterator position, const T& val)
{
assert(position._node);//防止空指针
Node* node = new Node(val);
Node* pos = position._node;
node->_prev = pos->_prev;
node->_next = pos;
pos->_prev->_next = node;
pos->_prev = node;
return node;
}
iterator insert(iterator position, T&& val)
{
assert(position._node);//防止空指针
//Node* node = new Node(move(val));
Node* node = new Node(forward<T>(val));
Node* pos = position._node;
node->_prev = pos->_prev;
node->_next = pos;
pos->_prev->_next = node;
pos->_prev = node;
return node;
}
void push_back(const T& val)
{
insert(end(), val);
}
void push_back( T&& val)
{
insert(end(), forward<T>(val));
}
void swap(list& lt)
{
std::swap(_head, lt._head);
}
void clear()
{
auto it = begin();
while (it != end())
{
it = erase(it);//erase返回下一个节点
}
}
private:
Node* _head;//头节点
};
}
为了方便演示，这里直接使用之前模拟实现的list和string，均封在djs的命名空间中。
在 djs::list<djs::string>中，list存储的类型为string，那么list的push_back的尾插的数据类型可以这样写；
- 一个string对象：左值
- 匿名string对象：右值
- 常量字符串 ：右值
djs::list<djs::string> lt1;
std::list<djs::string> lt2;
djs::string s1("111111111111");
lt1.push_back(s1);//对象：左值
lt1.push_back(djs::string("111111111111"));//匿名对象：右值
lt2.push_back("1111111111");//常量字符串：右值
在没有移动构造之前，由于const左值能够引用右值的特性，所以，以上的写法最后统统都会匹配到进行深拷贝。但是今时不同往日，我们已经学习了移动构造了；对于插入匿名对象，常量这种右值为何不参考移动构造将这里资源充分利用，从而提高效率呢？
有了移动构造这种语法先例，还需要一个硬性条件去支持——右值属性，移动构造的核心就是能够识别出右值，才能进行资源转移，但是像list<string>这种需要保证右值在传递过程中保持右值的属性，这就需要用到forward完美转发保持右值的属性，这样才能够被右值版本的insert 或者push_back所捕获。这也是forward完美转发的应用场景。
以下为该过程流程图
所以需要增加三个右值版本的函数实现这一目的。forward完美转发也可以使用move，不过forward完美转发比move更安全，也更智能。推荐forward
//节点类list_node中
list_node( T&& x)
//:_data(move(x))
:_data(forward<T>(x))
, _prev(nullptr)
, _next(nullptr)
{}
//list类中
iterator insert(iterator position, T&& val)//右值版本
{
assert(position._node);//防止空指针
//Node* node = new Node(move(val));
Node* node = new Node(forward<T>(val));
Node* pos = position._node;
node->_prev = pos->_prev;
node->_next = pos;
pos->_prev->_next = node;
pos->_prev = node;
return node;
}
void push_back( T&& val)//右值版本
{
//复用了insert
insert(end(), forward<T>(val));
}
从此以后，我们就推荐使用这种写法了，效率更高。
lt2.push_back("1111111111");//常量字符串：右值
扫一扫
659
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
