C++11：右值引用、移动语义和完美转发

2024-08-21 03:44
文章标签 c++ 引用 转发 完美 移动 语义 右值

本文主要是介绍C++11：右值引用、移动语义和完美转发，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

前言

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. 引用范围

左值引用范围

  1. 左值引用一般情况下只能引用左值。
  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;
}

右值引用范围：

  1. 右值引用一般情况下只能引用右值。
  2. 但是右值引用可以引用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";elsestr += "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";elsestr += "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]; //errorreturn 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 curprev->_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 curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}private:Node* _head;};

我们尝试运行下面的代码。我把代码分为五个部分，每个部分都有对应的解释。

int main()
{//1.创建一个list类变量ltRustle::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//模版实例化是右值引用，右值引用属性会退化成左值，转换成右值属性在传参给FunFun(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。

总结

经过长篇累牍的讲解，相信大家对右值引用和移动语义的概念有了初步的认识。通过对这些特性的学习，我们可以编写出更加高效和精炼的代码。如果亲自上手敲写上述示例代码，会有更加深刻的理解。

创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！

ee192b61bd234c87be9d198fb540140e.png

这篇关于C++11：右值引用、移动语义和完美转发的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1092030。

相关文章

C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
Debian 13升级后网络转发等功能异常怎么办? 并非错误而是管理机制变更

Debian 13升级后网络转发等功能异常怎么办? 并非错误而是管理机制变更

《Debian13升级后网络转发等功能异常怎么办?并非错误而是管理机制变更》很多朋友反馈，更新到Debian13后网络转发等功能异常，这并非BUG而是Debian13Trixie调整... 日前 Debian 13 Trixie 发布后已经有众多网友升级到新版本，只不过升级后发现某些功能存在异常，例如网络转
阅读更多...
504 Gateway Timeout网关超时的根源及完美解决方法

504 Gateway Timeout网关超时的根源及完美解决方法

《504GatewayTimeout网关超时的根源及完美解决方法》在日常开发和运维过程中,504GatewayTimeout错误是常见的网络问题之一,尤其是在使用反向代理（如Nginx）或... 目录引言为什么会出现 504 错误？1. 探索 504 Gateway Timeout 错误的根源 1.1 后端
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
C++ STL-string类底层实现过程

C++ STL-string类底层实现过程

《C++STL-string类底层实现过程》本文实现了一个简易的string类,涵盖动态数组存储、深拷贝机制、迭代器支持、容量调整、字符串修改、运算符重载等功能,模拟标准string核心特性,重点强... 目录实现框架一、默认成员函数1.默认构造函数2.构造函数3.拷贝构造函数(重点)4.赋值运算符重载函数
阅读更多...
C++ vector越界问题的完整解决方案

C++ vector越界问题的完整解决方案

《C++vector越界问题的完整解决方案》在C++开发中,std::vector作为最常用的动态数组容器,其便捷性与性能优势使其成为处理可变长度数据的首选,然而,数组越界访问始终是威胁程序稳定性的... 目录引言一、vector越界的底层原理与危害1.1 越界访问的本质原因1.2 越界访问的实际危害二、基
阅读更多...
c++日志库log4cplus快速入门小结

c++日志库log4cplus快速入门小结

《c++日志库log4cplus快速入门小结》文章浏览阅读1.1w次，点赞9次，收藏44次。本文介绍Log4cplus，一种适用于C++的线程安全日志记录API，提供灵活的日志管理和配置控制。文章涵盖... 目录简介日志等级配置文件使用关于初始化使用示例总结参考资料简介log4j 用于Java，log4c
阅读更多...
C++归并排序代码实现示例代码

C++归并排序代码实现示例代码

《C++归并排序代码实现示例代码》归并排序将待排序数组分成两个子数组,分别对这两个子数组进行排序,然后将排序好的子数组合并,得到排序后的数组,：本文主要介绍C++归并排序代码实现的相关资料,需要的... 目录1 算法核心思想2 代码实现3 算法时间复杂度1 算法核心思想归并排序是一种高效的排序方式，需要用
阅读更多...
把Python列表中的元素移动到开头的三种方法

把Python列表中的元素移动到开头的三种方法

《把Python列表中的元素移动到开头的三种方法》在Python编程中,我们经常需要对列表（list）进行操作,有时,我们希望将列表中的某个元素移动到最前面,使其成为第一项,本文给大家介绍了把Pyth... 目录一、查找删除插入法1. 找到元素的索引2. 移除元素3. 插入到列表开头二、使用列表切片（Lis
阅读更多...
使用Python构建智能BAT文件生成器的完美解决方案

使用Python构建智能BAT文件生成器的完美解决方案

《使用Python构建智能BAT文件生成器的完美解决方案》这篇文章主要为大家详细介绍了如何使用wxPython构建一个智能的BAT文件生成器,它不仅能够为Python脚本生成启动脚本,还提供了完整的文... 目录引言运行效果图项目背景与需求分析核心需求技术选型核心功能实现1. 数据库设计2. 界面布局设计3
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2