一文带你详细介绍c++中的std::move函数

在C++11中，标准库在中提供了一个有用的函数std::move，std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast(lvalue);
 

前言

• 在探讨c++11中的Move函数前，先介绍两个概念（左值和右值）

左值和右值

首先区分左值和右值

左值是表达式结束后依然存在的持久对象(代表一个在内存中占有确定位置的对象)

右值是表达式结束时不再存在的临时对象(不在内存中占有确定位置的表达式）

便携方法：对表达式取地址，如果能，则为左值，否则为右值

1. int val;

2. val = 4; // 正确 ①

3. 4 = val; // 错误 ②

上述例子中，由于在之前已经对变量val进行了定义，故在栈上会给val分配内存地址，运算符=要求等号左边是可修改的左值，4是临时参与运算的值，一般在寄存器上暂存，运算结束后在寄存器上移除该值，故①是对的，②是错的

一个对象被用作右值时，使用的是它的内容(值)，被当作左值时，使用的是它的地址。

引用

        引用是C++语法做的优化，引用的本质还是靠指针来实现的。引用相当于变量的别名。

        引用可以改变指针的指向，还可以改变指针所指向的值。

        引用的基本规则：

1. 声明引用的时候必须初始化，且一旦绑定，不可把引用绑定到其他对象；即引用必须初始化，不能对引用重定义；
2. 对引用的一切操作，就相当于对原对象的操作。

左值引用

左值引用的基本语法：type &引用名 = 左值表达式；

右值引用

右值引用的基本语法type &&引用名 = 右值表达式；

        右值引用在企业开发人员在代码优化方面会经常用到。

        右值引用的“&&”中间不可以有空格。

std::move函数

• std::move作用主要可以将一个左值转换成右值引用，从而可以调用C++11右值引用的拷贝构造函数
• std::move应该是针对你的对象中有在堆上分配内存这种情况而设置的，如下

remove_reference源码剖析

在分析std::move()与std::forward()之前，先看看remove_reference，下面是remove_reference的实现：

1. template

2. struct remove_reference

3. { typedef _Tp type; };

5. // 特化版本

6. template

7. struct remove_reference<_Tp&>

8. { typedef _Tp type; };

10. template

11. struct remove_reference<_Tp&&>

12. { typedef _Tp type; };

remove_reference的作用是去除T中的引用部分，只获取其中的类型部分。无论T是左值还是右值，最后只获取它的类型部分。

std::forward源码剖析

• 转发左值

1. template

2. constexpr _Tp&&

3. forward(typename std::remove_reference<_Tp>::type& __t) noexcept

4. { return static_cast<_Tp&&>(__t); }

先通过获得类型type，定义_t为左值引用的左值变量，通过static_cast进行强制转换。_Tp&&会发生引用折叠，当_Tp推导为左值引用，则折叠为_Tp& &&，即_Tp&，当推导为右值引用，则为本身_Tp&&，即forward返回值与static_cast处都为_Tp&&。

• 转发右值

1. template

2. constexpr _Tp&&

3. forward(typename std::remove_reference<_Tp>::type&& __t) noexcept

4. {

5. static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"

6. " substituting _Tp is an lvalue reference type");

7. return static_cast<_Tp&&>(__t);

8. }

不同于转发左值，_t为右值引用的左值变量，除此之外中间加了一个断言，表示当不是左值的时候，也就是右值，才进行static_cast转换。

std::move()源码剖析

1. // FUNCTION TEMPLATE move

2. template

3. _NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable

4. return static_cast&&>(_Arg);

5. }

std::move的功能是：

• 传递的是左值，推导为左值引用，仍旧static_cast转换为右值引用。

• 传递的是右值，推导为右值引用，仍旧static_cast转换为右值引用。

• 在返回处，直接范围右值引用类型即可。还是通过renive_reference获得_Tp类型，然后直接type&&即可。

所以std::remove_reference<_Tp>::type&&，就是一个右值引用，我们就知道了std::move干的事情了。

小结

• 在《Effective Modern C++》中建议：对于右值引用使用std::move，对于万能引用使用std::forward。
• std::move()与std::forward()都仅仅做了类型转换(可理解为static_cast转换)而已。真正的移动操作是在移动构造函数或者移动赋值操作符中发生的
• 在类型声明当中， “&&” 要不就是一个 rvalue reference ，要不就是一个 universal reference – 一种可以解析为lvalue reference或者rvalue reference的引用。对于某个被推导的类型T，universal references 总是以 T&& 的形式出现。
• 引用折叠是 会让 universal references (其实就是一个处于引用折叠背景下的rvalue references ) 有时解析为 lvalue references 有时解析为 rvalue references 的根本机制。引用折叠只会在一些特定的可能会产生"引用的引用"场景下生效。这些场景包括模板类型推导，auto 类型推导， typedef 的形成和使用，以及decltype 表达式。

std::move使用场景

• 在实际场景中，右值引用和std::move被广泛用于在STL和自定义类中实现移动语义，避免拷贝，从而提升程序性能。 在没有右值引用之前，一个简单的数组类通常实现如下，有构造函数、拷贝构造函数、赋值运算符重载、析构函数等。深拷贝/浅拷贝在此不做讲解。

1. class Array {

2. public:

3. Array(int size) : size_(size) {

4. data = new int[size_];

5. }

7. // 深拷贝构造

8. Array(const Array& temp_array) {

9. size_ = temp_array.size_;

10. data_ = new int[size_];

11. for (int i = 0; i < size_; i ++) {

12. data_[i] = temp_array.data_[i];

13. }

14. }

16. // 深拷贝赋值

17. Array& operator=(const Array& temp_array) {

18. delete[] data_;

20. size_ = temp_array.size_;

21. data_ = new int[size_];

22. for (int i = 0; i < size_; i ++) {

23. data_[i] = temp_array.data_[i];

24. }

25. }

27. ~Array() {

28. delete[] data_;

29. }

31. public:

32. int *data_;

33. int size_;

34. };

该类的拷贝构造函数、赋值运算符重载函数已经通过使用左值引用传参来避免一次多余拷贝了，但是内部实现要深拷贝，无法避免。 这时，有人提出一个想法：是不是可以提供一个移动构造函数，把被拷贝者的数据移动过来，被拷贝者后边就不要了，这样就可以避免深拷贝了，如：

1. class Array {

2. public:

3. Array(int size) : size_(size) {

4. data = new int[size_];

5. }

7. // 深拷贝构造

8. Array(const Array& temp_array) {

9. ...

10. }

12. // 深拷贝赋值

13. Array& operator=(const Array& temp_array) {

14. ...

15. }

17. // 移动构造函数，可以浅拷贝

18. Array(const Array& temp_array, bool move) {

19. data_ = temp_array.data_;

20. size_ = temp_array.size_;

21. // 为防止temp_array析构时delete data，提前置空其data_

22. temp_array.data_ = nullptr;

23. }

26. ~Array() {

27. delete [] data_;

28. }

30. public:

31. int *data_;

32. int size_;

33. };

这么做有2个问题：

• 不优雅，表示移动语义还需要一个额外的参数(或者其他方式)。
• 无法实现！temp_array是个const左值引用，无法被修改，所以temp_array.data_ = nullptr;这行会编译不过。当然函数参数可以改成非const：Array(Array& temp_array, bool move){...}，这样也有问题，由于左值引用不能接右值，Array a = Array(Array(), true);这种调用方式就没法用了。

可以发现左值引用真是用的很不爽，右值引用的出现解决了这个问题，在STL的很多容器中，都实现了以右值引用为参数的移动构造函数和移动赋值重载函数，或者其他函数，最常见的如std::vector的push_back和emplace_back。参数为左值引用意味着拷贝，为右值引用意味着移动。

1. class Array {

2. public:

3. ......

5. // 优雅

6. Array(Array&& temp_array) {

7. data_ = temp_array.data_;

8. size_ = temp_array.size_;

9. // 为防止temp_array析构时delete data，提前置空其data_

10. temp_array.data_ = nullptr;

11. }

14. public:

15. int *data_;

16. int size_;

17. };

如何使用：

1. // 例1：Array用法

2. int main(){

3. Array a;

5. // 做一些操作

6. .....

8. // 左值a，用std::move转化为右值

9. Array b(std::move(a));

10. }

实例：vector::push_back使用std::move提高性能

1. // 例2：std::vector和std::string的实际例子

2. int main() {

3. std::string str1 = "aacasxs";

4. std::vector vec;

6. vec.push_back(str1); // 传统方法，copy

7. vec.push_back(std::move(str1)); // 调用移动语义的push_back方法，避免拷贝，str1会失去原有值，变成空字符串

8. vec.emplace_back(std::move(str1)); // emplace_back效果相同，str1会失去原有值

9. vec.emplace_back("axcsddcas"); // 当然可以直接接右值

10. }

12. // std::vector方法定义

13. void push_back (const value_type& val);

14. void push_back (value_type&& val);

16. void emplace_back (Args&&... args);

在vector和string这个场景，加个std::move会调用到移动语义函数，避免了深拷贝。

除非设计不允许移动，STL类大都支持移动语义函数，即可移动的。 另外，编译器会默认在用户自定义的class和struct中生成移动语义函数，但前提是用户没有主动定义该类的拷贝构造等函数(具体规则自行百度哈)。 因此，可移动对象在<需要拷贝且被拷贝者之后不再被需要>的场景，建议使用std::move触发移动语义，提升性能。

还有些STL类是move-only的，比如unique_ptr，这种类只有移动构造函数，因此只能移动(转移内部对象所有权，或者叫浅拷贝)，不能拷贝(深拷贝)

1. std::unique_ptr ptr_a = std::make_unique();

3. std::unique_ptr ptr_b = std::move(ptr_a); // unique_ptr只有‘移动赋值重载函数‘，参数是&& ，只能接右值，因此必须用std::move转换类型

5. std::unique_ptr ptr_b = ptr_a; // 编译不通过

std::move本身只做类型转换，对性能无影响。 我们可以在自己的类中实现移动语义，避免深拷贝，充分利用右值引用和std::move的语言特性。

1. std::vector b(5);

2. b[0] = 2;

3. b[1] = 2;

4. b[2] = 2;

5. b[3] = 2;

7. // 此处用move就不会对b中已有元素重新进行拷贝构造然后再放到a中,b中元素已转移，不能访问

8. std::vector a = std::move(b);

将vector B赋值给另一个vector A，如果是拷贝赋值，那么显然要对B中的每一个元素执行一个copy操作到A，如果是移动赋值的话，只需要将指向B的指针拷贝到A中即可，试想一下如果vector中有相当多的元素，那是不是用move来代替copy就显得十分高效了呢？建议看一看Scott Meyers 的Effective Modern C++，里面对移动语义、右值引用以及类型推导进行了深入的探索

万能引用

首先，我们先看一个例子

1. #include

3. using std::cout;

4. using std::endl;

7. template

8. void func(T& param) {

9. cout << param << endl;

10. }

13. int main() {

14. int num = 2019;

15. func(num);

16. return 0;

17. }

这样例子的编译输出不存在什么问题，但是如果修改成下面的调用方式呢？

1. int main(){

2. func(2019);

3. return 0;

4. }

编译器会产生错误，因为上面的模板函数只能接受左值或者左值引用（左值一般是有名字的变量，可以取到地址的），我们当然可以重载一个接受右值的模板函数，如下也可以达到效果

1. template

2. void func(T& param) {

3. cout << "传入的是左值" << endl;

4. }

5. template

6. void func(T&& param) {

7. cout << "传入的是右值" << endl;

8. }

10. int main() {

11. int num = 2019;

12. func(num);

13. func(2019);

14. return 0;

15. }

输出结果

1. 传入的是左值

2. 传入的是右值

第一次函数调用的是左值得版本，第二次函数调用的是右值版本。但是，有没有办法只写一个模板函数即可以接收左值又可以接收右值呢？

C++11中有万能引用（Universal Reference）的概念：使用T&&类型的形参既能绑定右值，又能绑定左值

但是注意了：只有发生类型推导的时候，T&&才表示万能引用（如模板函数传参就会经过类型推导的过程）；否则，表示右值引用

所以，上面的案例我们可以修改为

1. template

2. void func(T&& param) {

3. cout << param << endl;

4. }

7. int main() {

8. int num = 2019;

9. func(num);

10. func(2019);

11. return 0;

12. }

引用折叠

万能引用说完了，接着来聊引用折叠（Reference Collapse），因为完美转发（Perfect Forwarding）的概念涉及引用折叠。一个模板函数，根据定义的形参和传入的实参的类型，我们可以有下面四中组合：

• 左值-左值 T& & # 函数定义的形参类型是左值引用，传入的实参是左值引用

1. template

2. void func(T& param) {

3. cout << param << endl;

4. }

6. int main(){

7. int num = 2021;

8. int& val = num;

9. func(val);

10. }

• 左值-右值 T& && # 函数定义的形参类型是左值引用，传入的实参是右值引用

1. template

2. void func(T& param) {

3. cout << param << endl;

4. }

6. int main(){

7. int&& val = 2021;

8. func(val);

9. }

• 右值-左值 T&& & # 函数定义的形参类型是右值引用，传入的实参是左值引用

1. template

2. void func(T&& param) {

3. cout << param << endl;

4. }

6. int main(){

7. int num = 2021;

8. int& val = num;

9. func(val);

10. }

• 右值-右值 T&& && # 函数定义的形参类型是右值引用，传入的实参是右值引用

1. template

2. void func(T&& param) {

3. cout << param << endl;

4. }

6. int main(){

7. int&& val = 4;

8. func(val);

9. }

但是C++中不允许对引用再进行引用，对于上述情况的处理有如下的规则：

所有的折叠引用最终都代表一个引用，要么是左值引用，要么是右值引用。规则是：如果任一引用为左值引用，则结果为左值引用。否则（即两个都是右值引用），结果才是右值引用

即就是前面三种情况代表的都是左值引用，而第四种代表的右值引用

完美转发

下面接着说完美转发（Perfect Forwarding），首先，看一个例子

1. #include

3. using std::cout;

4. using std::endl;

6. template

7. void func(T& param) {

8. cout << "传入的是左值" << endl;

9. }

11. template

12. void func(T&& param) {

13. cout << "传入的是右值" << endl;

14. }

16. template

17. void warp(T&& param) {

18. func(param);

19. }

21. int main() {

22. int num = 2019;

23. warp(num);

24. warp(2019);

25. return 0;

26. }

输出的结果

1. 传入的是左值

2. 传入的是左值

是不是和预期的不一样，下面我们来分析一下原因：

warp()函数本身的形参是一个万能引用，即可以接受左值又可以接受右值；第一个warp()函数调用实参是左值，所以，warp()函数中调用func()中传入的参数也应该是左值；第二个warp()函数调用实参是右值，根据上面所说的引用折叠规则，warp()函数接收的参数类型是右值引用，那么为什么却调用了调用func()的左值版本了呢？这是因为在warp()函数内部，右值引用类型变为了左值，因为参数有了名称，我们也通过变量名取得变量地址

那么问题来了，怎么保持函数调用过程中，变量类型的不变呢？这就是我们所谓的“变量转发”技术，在C++11中通过std::forward()函数来实现。我们来修改我们的warp()函数如下：

1. template

2. void warp(T&& param) {

3. func(std::forward(param));

4. }

则可以输出预期的结果

1. 传入的是左值

2. 传入的是右值

参考博文

现代C++之万能引用、完美转发、引用折叠(万字长文)：现代C++之万能引用、完美转发、引用折叠(万字长文)_guangcheng0312q的博客-CSDN博客

C++ 中的「移动」在内存或者寄存器中的操作是什么，为什么就比拷贝赋值性能高呢？：C++ 中的「移动」在内存或者寄存器中的操作是什么，为什么就比拷贝赋值性能高呢？ - 知乎

一文读懂C++右值引用和std::move：一文读懂C++右值引用和std::move - 知乎

本文作者：shadow_lr

本文链接：https://www.cnblogs.com/shadow-lr/p/Introduce_Std-move.html

版权声明：本作品采用shadow-lr许可协议进行许可。

(1646条消息) 一文带你详细介绍c++中的std::move函数_c++ std::move_双刃剑客的博客-CSDN博客