目录
前言
1. 左值引用和右值引用
2. 引用范围
3. 左值引用的缺陷
4. 右值引用的作用
5. 右值引用的深入场景
6. 完美转发
总结
前言
C++11作为一次重大的更新，引入了许多革命性的特性，其中之一便是右值引用和移动语义。本文将深入探讨其中引入的右值及其相关概念，帮助读者更好地理解这一特性，从而在编程实践中更有效地利用它。
1. 左值引用和右值引用
C++98中有引用的用法，而C++11中新增了右值引用的语法特性，之前学习的引用都是左值引用。不管是左值引用还是右值引用，都是给对象取别名。那什么左值和左值引用？还有右值和右值引用？
左值是一个表示数据的表达式。
- 具有固定的地址，可以获取它们的地址。
- 可以出现在赋值符号的左侧，对它进行赋值。
- 当用const修饰左值时，不能进行赋值，但是可以取地址。
左值引用就是对左值进行引用。
下面的例子中，有整型变量x，指针变量ptr，const修饰下整型变量y，字符串类变量s。上面的变量都是左值，都可以取地址。
int main()
{
// 以下的x、y、ptr、s都是左值
// 左值：可以取地址
int x = 10;
int* ptr = new int(0);
const int y = 2;
string s("11111");
//左值引用
int& r1 = x;
int*& r2 = ptr;
int& r3 = *ptr;
const int& r4 = y;
string& r5 = s;
return 0;
}右值是一个表示数据的表达式，如字面常量、临时对象、表达式返回值、函数返回值（左值引用类型返回除外）。
- 没有固定的内存地址，不能够获取其地址。
- 可以出现在赋值符号的右边，但是不能出现在赋值符号的左边没有。
右值引用就是对右值进行引用。
int main()
{
//右值：不能取地址
double x = 2.5;
//以下是常见的右值
15; //字面常量
x + 15; //表达式返回值
fmin(x, y); //函数返回值
string("11111"); //临时对象
//右值引用
int&& rr1 = 15;
double&& rr2 = x + 15;
double&& rr3 = fmin(x, y);
string&& rr4 = string("1111111");
return 0;
}2. 引用范围
左值引用范围
- 左值引用一般情况下只能引用左值。
- 但加上const修饰之后，左值引用可以引用左值，还可以引用右值。
字面常量15被引用为整型变量时需要转换类型，中间会产生临时变量，临时变量具有常性。如果使用普通引用，可以对此引用进行修改，会导致权限放大。
int main()
{
//右值：不能取地址
double x = 2.5;
//以下是常见的右值
15; //字面常量
x + 15; //表达式返回值
fmin(x, y); //函数返回值
string("11111"); //临时对象
//右值引用
int&& rr1 = 15;
double&& rr2 = x + 15;
double&& rr3 = fmin(x, y);
string&& rr4 = string("1111111");
//const修饰后，可以引用右值
const int& rx1 = 15;
const double& rx2 = x + 15;
const double& rx3 = fmin(x, y);
const string& rx4 = string("1111111");
return 0;
}右值引用范围：
- 右值引用一般情况下只能引用右值。
- 但是右值引用可以引用move之后的左值。
int main()
{
//右值引用
int&& rr1 = 15;
//无法引用左值，下面会报错
int x = 10;
int&& rr2 = x; //error
//move之后，可以右值引用
int&& rr3 = std::move(x);
return 0;
}3. 左值引用的缺陷
既然已经有左值引用，为什么还要搞出一个右值引用的概念，这是为什么呢？下面是用C++简单实现的string类。如果对字符串类不熟悉，可以转到这篇文章http://t.csdnimg.cn/Znclr。构造函数，拷贝构造函数和赋值重载函数内部都有打印函数原型，方便查看函数调用情况。
#include <assert.h>
namespace Rustle
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
typedef const char* const_iterator;
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)" << endl;
_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)
{
cout << "string(const string& s) -- 深拷贝" << endl;
reserve(s._capacity);
for (const auto& ch : s)
{
push_back(ch);
}
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto& ch : s)
{
push_back(ch);
}
}
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];
if (_str)
{
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';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
//s += 'a'
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
//s += "11111"
string& operator+=(const char* str)
{
append(str);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0; // 不包含最后做标识的\0
};
}左值引用的场景
左值引用给左值取别名。传递函数参数或者返回函数值时，可以减少拷贝，提高效率。
- TestNonLeftRef函数参数类型是string类，函数参数是实参的临时拷贝，如果是自定义类型，会调用相应的拷贝构造，创建新的变量。
- 而TestLeftRef函数参数是string类引用，相当于给传过来的参数取别名，不会调用拷贝构造。
- operator[]函数返回值类型是字符类型的引用，对字符进行取别名，不用进行拷贝。
void TestNonLeftRef(Rustle::string s)
{}
void TestLeftRef(Rustle::string& s)
{}
int main()
{
Rustle::string s("111111");
TestNonLeftRef(s);
TestLeftRef(s);
Rustle::string s1("xxxxxx");
//operator[]返回值类型是
//Rustle::char& operator[](size_t n);
s1[0];
return 0;
}运行结果如下，main函数中创建s变量时调用了构造函数。接受参数为s的两个函数，只有TestNonLeftRef调用了拷贝构造。最后一个构造是创建s1变量调用的。
左值引用的缺陷
当函数返回的值是一个函数内的局部变量时，局部变量出了函数作用域就会被销毁,无法使用左值引用返回，只能进行传值返回。
Rustle::string GetStr(int flag)
{
Rustle::string str;
if (flag)
str += "true";
else
str += "false";
return str;
}
int main()
{
Rustle::string s1;
s1 = GetStr(1);
return 0;
}如上面代码所示，str是一个局部变量，出作用域就销毁，只能使用传值返回。下图中，一般情况下str变量传值返回时，会拷贝此变量来创建一个临时变量，如果是自定义类型就会调用拷贝构造函数。s1会调用拷贝构造函数，拷贝临时变量
但是某些编译器进行优化之后，只用进行一次拷贝构造函数，不产生中间的临时变量。
不过VS2022编译器对这个场景优化的十分厉害。下面是运行结果示意图，只调用了一次构造函数。说明编译器已经识别s1要使用GetStr返回值进行构造。相当于str跟s1是同一个变量。
但如果先创建string类，再使用赋值重载函数拷贝函数返回值。
int main()
{
Rustle::string s2;
s2 = GetStr(0);
return 0;
}运行结果如下，调用了两次构造函数和一个赋值重载函数。mian函数内创建一个string类对象，GetStr函数内创建了一个string类对象。在返回该对象时，本来会产生一个临时对象，调用一个拷贝构造，不过编译器优化掉这一步骤，直接调用赋值重载函数。
4. 右值引用的作用
通过上面的讲述，我们知道左值引用不能解决传值返回的场景，大部分编译器起码至少会调用一次拷贝构造，这样会降低运行效率。右值引用的出现就是为了解决这种场景。
- 右值分为纯右值和将亡值。其中将亡值指的是那些即将被销毁的对象，函数返回值就是将亡值。右值引用可以引用将亡值，虽然左值引用不能当做返回类型，但是右值引用可以当做返回类型。
- 既然右值引用左为函数返回类型，string类就要重载一份右值引用版本的拷贝构造函数和赋值重载函数。这类函数分别叫做移动构造函数和移动赋值函数。
- 如下面代码，移动构造函数的本质是将右值的资源转移，或者叫做“窃取”。这样就不用做深拷贝了，所以叫做移动构造，就是转移别人的资源进行构造。
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动构造" << endl;
swap(s);
return *this;
}增加了移动构造和移动赋值之后，我们测试一下刚才的代码。
Rustle::string GetStr(int flag)
{
Rustle::string str;
if (flag)
str += "true";
else
str += "false";
return str;
}
int main()
{
Rustle::string s2;
s2 = GetStr(0);
return 0;
}调用了两次构造函数，还有一次移动构造。
5. 右值引用的深入场景
前面我们提到右值引用无法直接引用左值，但是move函数可以将左值转换成右值，从而达到左值被引用。std::move函数实际上对左值没有转移任何资源，只是将左值强制转化成右值。
如下面的代码，string类对象正常使用同类进行拷贝构造，不会影响被拷贝的对象。但是被拷贝对象被move之后，强制转化成右值，就会调用移动版本的构造，窃取s1的资源，将s1置空。
int main()
{
Rustle::string s1("xxxxxx");
//调用普通构造函数
Rustle::string s2(s1);
s1[0];
//识别s1为右值，调用移动构造，会转移s1的资源来构造s3
//那么s1就被置空了，无法用[]访问
Rustle::string s3(move(s1));
s1[0]; //error
return 0;
}
左值引用和右值引用本质上都是给变量取别名。我们看下面的代码，s1为左值，通过强制转换成右值。匿名对象本身为右值，也可以通过强制转化成左值。
void func(const Rustle::string& s)
{
cout << "void func(const Rustle::string& s)" << endl;
}
void func(Rustle::string&& s)
{
cout << "void func(Rustle::string&& s)" << endl;
}
//左值和右值属性可以互相切换，在数据层没有差别
int main()
{
//左值
Rustle::string s1("1111111");
func(s1);
//强制转换成右值
func((Rustle::string&&)s1);
//右值
func(Rustle::string("11111111"));
//强制转换成左值
func((Rustle::string&)Rustle::string("11111111"));
return 0;
}运行结果如下：
下面是用C++简单实现的list容器，只包含插入函数相关的部分，其他接口函数已经省略。并且还提供了右值引用版本的插入函数。如果对list容器不熟悉，可以看这篇文章http://t.csdnimg.cn/WWsBs。
namespace Rustle
{
template<class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
ListNode(const T& data = T())//匿名对象,调用的是默认构造
:_next(nullptr)
,_prev(nullptr)
,_data(data)
{}
};
template<class T>
class list
{
typedef ListNode<T> Node;
public:
list()
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
}
void push_back(const T& x)
{
insert(end(), x);
}
//移动插入
void push_back(T&& x)
{
insert(end(), x);
}
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
//prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
iterator insert(iterator pos, T&& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
//prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
private:
Node* _head;
};我们尝试运行下面的代码。我把代码分为五个部分，每个部分都有对应的解释。
int main()
{
//1.创建一个list类变量lt
Rustle::list<Rustle::string> lt;
//2.显示对象插入
Rustle::string s1("1111111111111111");
lt.push_back(s1);
//3.匿名对象
lt.push_back(Rustle::string("1111111111111111"));
//4.字符串类隐式类型转换为string类
lt.push_back("1111111111111111");
//5.通过move函数强制转化s1为右值
lt.push_back(move(s1));
return 0;
}- 运行结果如下。第一个string类的构造函数和拷贝构造函数，是创建list容器变量lt调用的。因为list容器有个哨兵位结点，内部不存储有效数据，用来简化list的插入和删除工作。
- list的默认构造函数会开辟一个ListNode类的结点，ListNode类的构造函数是全缺省的，如果没传参数，会使用缺省值，缺省值是调用string类的默认构造函数。参数列表中拷贝data创建ListNode的_data变量，会调用拷贝构造函数。
ListNode(const T& data = T())//匿名对象,调用的是默认构造
:_next(nullptr)
,_prev(nullptr)
,_data(data)
{}
list()
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
}- 正常来说，序号3之后的代码中push_back参数都是右值，应该调用string类中的移动构造才对，但是全部调用的是拷贝构造，进行深拷贝。这是为什么呢？
尝试运行下面的代码，观察结果。
void TestRightRef(Rustle::string&& str)
{
cout << &str << endl;
}
int main()
{
TestRightRef(Rustle::string("111111111111111"));
Rustle::string&& r1 = Rustle::string("1111111111111111");
cout << &r1 << endl;
//通过测试，发现右值引用本身属性是左值，那为什么会是左值呢？
//因为只有右值引用本身的属性是左值，才能传递参数，转移他的资源
return 0;
}观察运行结果，发现右值引用本身可以取地址，说明右值引用本身属性是左值。第一种是传递右值参数，TestRightRef函数用右值引用接受，可以取地址。第二种是直接对右值引用。
这两种方式都会导致右值被引用之后退化成左值。只有右值引用本身的属性是左值的情况下，才可以进行赋值，做函数参数和做函数返回值的操作。
所以说，函数用右值引用接收右值时，右值引用的属性会退化成左值。
当使用push_back函数，插入右值对象时，会调用移动插入函数。在移动插入函数中，右值引用参数x本身属性已经退化成左值。而移动插入函数主要是复用了insert函数完成尾插的操作，虽然重载了右值引用版本的insert函数，但是由于x属性为左值，还是会调用到左值引用版本的insert函数。
这就导致string类调用的是拷贝构造函数。
namespace Rustle
{
template<class T>
struct ListNode
{
//...
ListNode(const T& data = T())//匿名对象,调用的是默认构造
:_next(nullptr)
,_prev(nullptr)
,_data(data)
{}
};
template<class T>
class list
{
//...
public:
//移动插入
void push_back(T&& x)
{
insert(end(), x);
}
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
//...
return iterator(newnode);
}
iterator insert(iterator pos, T&& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
//...
return iterator(newnode);
}
//...
};那我们该怎么解决呢？根据右值被引用之后属性退化成左值的问题，每次函数使用右值引用参数接收右值后，如果需要使用右值引用，就必须使用move函数改变右值引用的属性。
那么list容器的push_back函数中需要加上move函数，insert函数中也要加上move函数，ListNode的构造函数也需要提供一个右值引用版本的。
namespace Rustle
{
template<class T>
struct ListNode
{
//...
ListNode(const T& data = T())//匿名对象,调用的是默认构造
:_next(nullptr)
,_prev(nullptr)
,_data(data)
{}
ListNode(T&& data)//右值版本
:_next(nullptr)
,_prev(nullptr)
,_data(move(data))
{}
};
template<class T>
class list
{
//...
public:
//移动插入
void push_back(T&& x)
{
insert(end(), move(x));//加上move函数
}
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
//...
return iterator(newnode);
}
iterator insert(iterator pos, T&& x)
{
Node* cur = pos._node;
Node* newnode = new Node(move(x));//加上move函数
Node* prev = cur->_prev;
//...
return iterator(newnode);
}
//...
};运行结果如下：
6. 完美转发
前面提到右值引用的属性是左值，所以一旦要使用右值引用，需要使用move函数强制转换属性。如list的push_back函数，一层一层传递右值，每一层都要重载左值引用和右值引用两个版本的函数，十分麻烦。有什么办法可以解决呢？那就要介绍C++11引入的新特性——完美转发。
完美转发（Perfect Forwarding）是C++11中引入的一个特性，它允许在函数模板中，将参数连同其类型信息一起不变地传递给其他函数。这意味着，无论是左值引用还是右值引用，都能保持其原有的引用类型，在传递过程中不会意外地变成左值引用。
使用完美转发时，尖括号里面是放变量类型，圆括号是放变量。
std::forward<T>(x)下面的代码就是使用完美转发的效果对比。其中模版中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。模版函数可以接收左值和右值，不过第一个模版函数没有使用完美转发，第二个函数使用了完美转发。
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 NonPerfectForward(T&& t)
{
Fun(t);
}
template<typename T>
void PerfectForward(T&& t)
{
//模版实例化是左值引用，保持属性直接传参给Fun
//模版实例化是右值引用，右值引用属性会退化成左值，转换成右值属性在传参给Fun
Fun(forward<T>(t));
}
void Test1()
{
int a;
const int b = 8;
NonPerfectForward(a); // 左值
NonPerfectForward(std::move(a)); // 右值
NonPerfectForward(b); // const 左值
NonPerfectForward(std::move(b)); // const 右值
cout << endl;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
}
int main()
{
Test1();
return 0;
}运行结果如下，第一个模版函数接收右值后，右值引用属性退化成左值，调用的还是左值引用类型的函数。第二个函数使用了完美转发，如果模版实例化是左值引用，保持属性直接传参给Fun，如果实例化后是右值引用，会转换成右值属性在传参给Fun。
总结
经过长篇累牍的讲解，相信大家对右值引用和移动语义的概念有了初步的认识。通过对这些特性的学习，我们可以编写出更加高效和精炼的代码。如果亲自上手敲写上述示例代码，会有更加深刻的理解。
创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！
