深入理解C++中的move和forward！
导语 | 在C++11标准之前，C++中默认的传值类型均为Copy语义，即：不论是指针类型还是值类型，都将会在进行函数调用时被完整的复制一份！对于非指针而言，开销极其巨大！因此在C++11以后，引入了右值和Move语义，极大地提高了效率。本文介绍了在此场景下两个常用的标准库函数：move和forward。
一、特性背景
（一）Copy语义简述
C++中默认为Copy语义，因此存在大量开销。
以下面的代码为例：
0_copy_semantics.cc
-
#include <iostream>
-
#include <vector>
-
-
-
class Object {
-
public:
-
Object() {
-
std::cout << "build this object!" << std::endl;
-
}
-
-
-
virtual ~Object() {
-
std::cout << "destruct this object!" << std::endl;
-
}
-
};
-
-
-
void f(const Object obj) {}
-
-
-
int main() {
-
Object obj{};
-
-
-
// function calling
-
f(obj);
-
-
-
// vector
-
std::vector<Object> v;
-
v.push_back(obj);
-
}
最终的输出结果为：
-
build this object!
-
destruct this object!
-
destruct this object!
-
destruct this object!
第一个为显式调用构造函数创建obj时的输出。
后面的输出说明存在三个对象，因此调用了三次析构函数。
即：除了我们显式构造的函数之外，我们在调用函数、将对象加入vector的时候，也创建了新的对象！
并且这个对象不是通过构造函数创建的，事实上是通过复制构造函数创建的！
当尝试将复制构造函数禁用后，上面的代码将无法编译：
Object (const Object& object) = delete;
（二）临时值（右值）简述
Copy语义虽然用起来很方便，但是很多时候我们并不想将值（尤其是一些临时变量）Copy一遍再使用！
例如：
-
func("some temporary string"); // 尽管直接将一个常量传入函数中, C++还是大概率会创建一个string的复制
-
v.push_back(X()); // 初始化了一个临时X, 然后被复制进了vector
-
a = b + c; // b+c是一个临时值, 然后被赋值给了a
-
x++; // x++操作也有临时变量的产生（++x则不会产生）
-
a = b + c + d; //c+d是一个临时变量, b+(c+d)是另一个临时变量
另外还有函数在返回时：
-
vector<string> str_split(const string& s) {
-
vector<string> v;
-
// ...
-
return v; // v是左值，但优先移动，不支持移动时仍可复制
-
}
注意：上面的函数在返回时，实际上编译器会对返回值进行优化，并不会先析构v，再在str_split 函数的调用栈中对整个v进行Copy。
但是之前的C++的确是这么做的，因此会出现类似于下面的代码：
void str_split(const string& s, vector<string>* vec);
即：将返回值也作为一个输入参数。
上面编译器的优化有一个非常学术的名字：RVO (Return Value Optimization)，返回值优化。
感兴趣的可以看看下面的文章：
C++ 编译器优化之RVO与NRVO
https://www.yhspy.com/2019/09/01/C-%E7%BC%96%E8%AF%91%E5%99%A8%E4%BC%98%E5%8C%96%E4%B9%8B-RVO-%E4%B8%8E-NRVO/
上面的这些临时值，在C++中被统一定义为：右值(rvalue)，因为在编译器的角度，实际上并没有对应的变量名存储这些变量值。
对面上面提到的一些临时值的场景都有一些共性：
临时变量的内容先被复制一遍。
被复制的内容覆盖到成员变量指向的内存。
临时变量用完了再被回收。
其实这里是可以优化的：
临时变量其实最终都是要被回收的，如果能把临时变量的内容直接“移入”成员变量中，此时就不需要调用复制构造函数了！
即：
成员变量内部的指针指向”temporary str1”所在的内存。
临时变量内部的指针指向成员变量以前所指向的内存。
最后临时变量指向的那块内存再被回收。
上面的操作即可避免一次对象Copy的发生，实际上它就是所谓的Move语义。
对于使用过Rust的开发者来说，这里他们是非常熟悉的。因为Rust丧心病狂的将所有赋值操作都默认定义为了Move语义！
二、使用move函数
（一）move函数的基本使用
对比之前的例子，这里我们使用move语义对其进行优化：
1_move_semantics.cc
-
#include <iostream>
-
#include <utility>
-
#include <vector>
-
#include <string>
-
-
-
class Object {
-
public:
-
explicit Object(std::string str) : _str(std::move(str)) {
-
std::cout << "build this object, address: " << this << std::endl;
-
}
-
-
-
virtual ~Object() {
-
std::cout << "destruct this object, address: " << this << std::endl;
-
}
-
-
-
Object(const Object &object) : _str(object._str) {
-
std::cout << "copy this object, address: " << this << std::endl;
-
}
-
-
-
Object(Object &&object) noexcept: _str(std::move(object._str)) {
-
std::cout << "move this object!" << std::endl;
-
}
-
-
-
std::string _str;
-
};
-
-
-
void f_copy(Object obj) {
-
std::cout << "copy function, address: " << &obj << std::endl;
-
}
-
-
-
void f_move(Object &&obj) {
-
Object a_obj(std::move(obj));
-
std::cout << "move function, address: " << &a_obj << std::endl;
-
}
-
-
-
int main() {
-
Object obj{"abc"};
-
-
-
// function calling
-
f_copy(obj);
-
f_move(std::move(obj));
-
-
-
// std::cout << obj._str << std::endl; // danger!
-
-
-
std::cout << "============== end ================" << std::endl;
-
-
-
return 0;
-
}
这里的用法其实是没有意义的，只是为了演示强行使用了move
为了方便演示，这里给Object类增加了一个string类型的成员，并且输出了Object的内存地址。
代码输出：
-
build this object, address: 000000FD546FF5A8 // Object obj{"abc"}
-
copy this object, address: 000000FD546FF620 // f_copy(obj)
-
copy function, address: 000000FD546FF620 // Object(const Object &object)
-
destruct this object, address: 000000FD546FF620 // f_copy(obj) End
-
move this object! // Object a_obj(std::move(obj));
-
move function, address: 000000FD546FF508 // f_move(Object &&obj)
-
destruct this object, address: 000000FD546FF508 // f_move(Object &&obj) End
-
============== end ================
-
destruct this object, address: 000000FD546FF5A8 // main End
可以看到，相比于Copy，我们直接使用了move函数将变量移入了函数中，此时是没有调用复制构造函数的！
实际上，C++中的move函数只是做了类型转换，并不会真正的实现值的移动！
因此，对于自定义的类来说，如果要实现真正意义上的 “移动”，还是要手动重载移动构造函数和移动复制函数。
即：我们需要在自己的类中实现移动语义，避免深拷贝，充分利用右值引用和std::move的语言特性。
实际上，通常情况下C++编译器会默认在用户自定义的class和struct中生成移动语义函数。
但前提是：用户没有主动定义该类的拷贝构造等函数！
同时也要注意到：使用一个已经被move过的函数是非常危险的事情！
（二）move语义下的析构函数
在上面的测试在，可能你也注意到了一点就是：
-
destruct this object, address: 000000FD546FF508 // f_move(Object &&obj) End
-
============== end ================
-
destruct this object, address: 000000FD546FF5A8 // main End
对象被move了之后，仍然会在其离开作用域之后调用他的析构函数？
这是因为：
虽然将obj的资源给了a_obj ，但是obj并没有立刻析构，只有在obj离开了自己的作用域的时候才会析构；因此，如果继续使用str2的m_data变量，可能会发生意想不到的错误。
也正因为如此，在自己实现移动构造函数的时候，需要将原对象中的值手动置为空，以防止同一片内存区域被多次释放！
此外还需要注意：
如果我们没有提供移动构造函数，只提供了拷贝构造函数，std::move()会失效但是不会发生错误，因为编译器找不到移动构造函数就去寻找拷贝构造函数，这也是拷贝构造函数的参数是const T&常量左值引用的原因！
c++11中的所有容器都实现了move语义，move只是转移了资源的控制权，本质上是将左值强制转化为右值使用，以用于移动拷贝或赋值，避免对含有资源的对象发生无谓的拷贝。
move对于拥有如内存、文件句柄等资源的成员的对象有效，如果是一些基本类型，如int和char[10]数组等，如果使用move，仍会发生拷贝（因为没有对应的移动构造函数），所以说move对含有资源的对象说更有意义。
上面的例子只是对move语义的简单介绍，下面给出了一个真正需要自己手动管理资源（内存地址）的例子：
1_move_and_destructor.cc
-
#include <iostream>
-
#include <utility>
-
#include <vector>
-
-
-
class MyString {
-
public:
-
// Constructor
-
explicit MyString(const char *data) {
-
if (data != nullptr) {
-
_data = new char[strlen(data) + 1];
-
strcpy(_data, data);
-
} else {
-
_data = new char[1];
-
*_data = '\0';
-
}
-
-
-
std::cout << "built this object, address: " << this << std::endl;
-
}
-
-
-
// Destructor
-
virtual ~MyString() {
-
std::cout << "destruct this object, address: " << this << std::endl;
-
delete[] _data;
-
}
-
-
-
// Copy constructor
-
MyString(const MyString &str) {
-
std::cout << "copy this object, address: " << this << std::endl;
-
_data = new char[strlen(str._data) + 1];
-
strcpy(_data, str._data);
-
}
-
-
-
// Move constructor
-
MyString(MyString &&str) noexcept
-
: _data(str._data) {
-
std::cout << "move this object" << std::endl;
-
str._data = nullptr; // Very important!
-
}
-
-
-
// Copy assignment
-
MyString& operator=(const MyString& str){
-
if (this == &str) // 避免自我赋值!!
-
return *this;
-
-
-
delete[] _data;
-
_data = new char[ strlen(str._data) + 1 ];
-
strcpy(_data, str._data);
-
return *this;
-
}
-
-
-
// Move assignment
-
MyString& operator=(MyString&& str) noexcept{
-
if (this == &str) // 避免自我赋值!!
-
return *this;
-
-
-
delete[] _data;
-
_data = str._data;
-
str._data = nullptr; // 不再指向之前的资源了
-
return *this;
-
}
-
-
-
public:
-
char *_data;
-
};
-
-
-
void f_move(MyString &&obj) {
-
MyString a_obj(std::move(obj));
-
std::cout << "move function, address: " << &a_obj << std::endl;
-
}
-
-
-
int main() {
-
MyString obj{"abc"};
-
-
-
f_move(std::move(obj));
-
-
-
// std::cout << obj._data << std::endl; // danger!
-
-
-
std::cout << "============== end ================" << std::endl;
-
-
-
return 0;
-
}
最终输出：
-
built this object, address: 000000843D0FFD78
-
move this object
-
move function, address: 000000843D0FFD08
-
destruct this object, address: 000000843D0FFD08
-
============== end ================
-
destruct this object, address: 000000843D0FFD78
这里需要注意，在移动构造函数和移动赋值函数中，我们将当前待移动对象的资源赋值为了空（str._data=nullptr），这里就是我们手动实现了 资源的移动！
下面我们尝试修改两个地方，来导致报错：
使用资源被move后的对象。
在实现移动构造函数时不赋值为nullptr。
使用资源被move后的对象
将注释打开：
// std::cout << obj._data << std::endl; // danger!
此时执行代码会疯狂报错：
Exception: Exception 0xc0000005 encountered at address 0x7ff62a4f245a: Access violation reading location 0x00000000
因为此时obj中的内容已经为空了！
在实现移动构造函数时不赋值为nullptr
将这里注释掉：
-
MyString(MyString &&str) noexcept
-
: _data(str._data) {
-
std::cout << "move this object" << std::endl;
-
// str._data = nullptr; // Very important!
-
}
此时再执行代码，整个程序会直接崩溃，因为：我们未将已经move掉的资源设置为空值，最终会导致这里的资源被释放两次！
三、什么又是foward函数
有了move函数之后，我们又遇到了一个新的问题：
按照上面的写法，处理临时变量用右值引用T&&，处理普通变量用const引用const T&，我们需要分别建立两个函数，然后入参使用不同的类型，每个函数都要写两遍。
那么能不能避免重复，将T &&类型和const T &类型合二为一呢？
答案就是：forward函数，std::forward也被称为完美转发，即：保持原来的值属性不变：
如果原来的值是左值，经std::forward处理后该值还是左值。
如果原来的值是右值，经std::forward处理后它还是右值。
这样一来，我们就可以使用forward函数对入参进行封装，从而保证了入参的统一性，从而可以实现一个方法处理两种类型！
正因为如此，forward函数被大量用在了入参值类型情况不确定的C++模板中！
2_forward.cc
-
template<typename T>
-
void f_forward(T &&t) {
-
-
-
Object a = std::forward<T>(t);
-
-
-
std::cout << "forward this object, address: " << &a << std::endl;
-
}
-
-
-
int main() {
-
Object obj{"abc"};
-
f_forward(obj);
-
-
-
f_forward(Object("def"));
-
-
-
return 0;
-
}
紧接着上面的例子，我们构建了一个模板函数f_forward。
在里面我们调用了std::forward<T>(t)来创建一个新的对象。
在main函数中，我们分别使用一个左值和一个右值调用了该模板函数。
结果如下：
-
build this object, address: 000000CFAE8FFC78
-
copy this object, address: 000000CFAE8FFBD8
-
forward this object, address: 000000CFAE8FFBD8
-
destruct this object, address: 000000CFAE8FFBD8
-
build this object, address: 000000CFAE8FFCB8
-
move this object!
-
forward this object, address: 000000CFAE8FFBD8
-
destruct this object, address: 000000CFAE8FFBD8
-
destruct this object, address: 000000CFAE8FFCB8
-
destruct this object, address: 000000CFAE8FFC78
一个调用了复制构造函数，另一个调用了移动构造函数。
forward函数成功的识别到了我们的入参，并完成了转发，即：
如果外面传来了右值临时变量，它就转发右值并且启用move语义。
如果外面传来了左值，它就转发左值并且启用copy，同时它也还能保留const。
四、move和forward函数的区别
从上面的分析我们可以看出，基本上forward可以cover所有的需要move的场景，毕竟forward函数左右值通吃。
那为什么还要使用move呢？原因主要有两点：
首先，forward函数常用于模板函数这种入参情况不确定的场景中，在使用的时候必须要多带一个模板参数forward<T>，代码略复杂。
此外，明确只需要move临时值的情况下如果使用了forward，会导致代码意图不清晰，其他人看着理解起来比较费劲。
实际上从实现的角度上来说，他们都可以被static_cast替代。
注意：为什么不用static_cast呢？也是为了阅读和使用起来更方便。
五、move和forward函数的实现
（一）C++11后加入的一些新规则
引用折叠规则
如果间接的创建一个引用的引用，则这些引用就会“折叠”，在所有情况下（除了一个例外），引用折叠成一个普通的左值引用类型。
一种特殊情况下，引用会折叠成右值引用，即右值引用的右值引用：T&& &&。
即：
X& &、X& &&、X&& &都折叠成X&。
X&& &&折叠为X&&。
右值引用的特殊类型推断规则
当将一个左值传递给一个参数是右值引用的函数，且此右值引用指向模板类型参数(T&&)时，编译器推断模板参数类型为实参的左值引用，如：
-
template<typename T>
-
void f(T&&);
-
-
-
int i = 42;
-
f(i)
上述的模板参数类型T&&最终将被推断为int&类型，而非int！
若将这两个规则结合起来，则意味着可以传递一个左值int i给f，编译器将推断出T的类型为int&。
再根据引用折叠规则 void f(int& &&)将推断为void f(int&)，因此，f将被实例化为: void f<int&>(int&)。
从上述两个规则可以得出结论：如果一个函数形参是一个指向模板类型的右值引用，则该参数可以被绑定到一个左值上。
即类似下面的定义：
-
template<typename T>
-
void f(T&&);
可以通过static_cast显式地将一个左值转换为一个右值
虽然不能隐式的将一个左值转换为右值引用，但是可以通过static_cast显式地将一个左值转换为一个右值。
C++11中为static_cast新增的转换功能。
（二）move函数解析
标准库中move的定义如下：
-
template <class _Ty>
-
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
-
return static_cast<remove_reference_t<_Ty>&&>(_Arg);
-
}
move函数的参数T&&是一个指向模板类型参数的右值引用（见上方新规则），通过引用折叠，此参数可以和任何类型的实参匹配！
因此move函数的入参既可以传递一个左值，也可以传递一个右值！
右值情况，std::move(string("hello"))调用解析：
首先，根据模板推断规则，确地T的类型为string，typename remove_reference_t<_Ty>&&的结果为string &&，因此，move 函数的返回值参数类型为string&&。
同时，对于static_cast<string &&>(_Arg)来说，_Arg已经是 string&&，于是类型转换什么都不做，直接返回string&&。
左值情况，string s1("hello"); std::move(s1); 调用解析：
首先，根据模板推断规则，确定T的类型为string&，typename remove_reference_t<_Ty>&& 的结果为string&，因此move函数的参数类型为string& &&，引用折叠之后为string&。
同时，对于static_cast<string &&>(_Arg)来说，_Arg是string&，经过static_cast之后转换为string&&，返回string&&。
因此，从move函数的实现可以看出，move自身除了做一些参数的推断之外，返回右值引用本质上还是靠static_cast<T&&>完成的。
因此下面两个调用是等价的，std::move就是个语法糖
-
void func(int&& a) {
-
cout << a << endl;
-
}
-
-
-
int a = 6;
-
func(std::move(a));
-
-
-
int b = 10;
-
func(static_cast<int&&>(b));
需要注意的是：std::move函数仅仅执行到右值类型的无条件转换；就其本身而言，它没有“move”任何东西。
（三）forward函数解析
标准库中forward函数的定义如下：
-
template <class _Ty>
-
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
-
return static_cast<remove_reference_t<_Ty>&&>(_Arg);
-
}
当传递一个lvalue或者const lvaue时：
传递一个lvalue，模板推导之后_Ty=_Ty&。
传递一个const lvaue, 模板推导之后_Ty=const_Ty&。
随后，_Ty& && 将折叠为_Ty&，即_Ty& && 折叠为 _Ty&，即最终返回 _Ty&类型。
std::forward<_Ty&>(_Arg)将返回一个左值，最终调用拷贝构造函数。
类似的，当传递一个rvalue时：
remove_reference_t<_Ty>&& move(_Ty&& _Arg) 将返回一个右值，最终调用移动构造函数。
六、总结
首先，std::move和std::forward本质都是转换：
std::move执行强制到右值的无条件转换。
std::forward只有在它的参数绑定到一个右值上的时候，才转换它的参数到一个右值。
std::move没有move任何东西，std::forward没有转发任何东西。
整个类型转变的实现是在编译期完成的，在运行期，它们没有做任何事情。
它们没有为移动或者复制产生需要执行的代码，一byte都没有；（换言之，我们需要通过重载移动相关操作函数来自己处理move语义）
在使用场景方面：
一般在模板元编程里面，由于入参的值类型不确定，因此对于forward使用比较多。
在一般的函数中，如果可以确定传入的一定是右值（临时值），可以直接使用move函数，强调使用场景。
源代码：
https://github.com/JasonkayZK/cpp-learn/tree/value
参考资料：
1.C++11特性之move和forward应用与区别
2.C++11std::move和std::forward
3.C++右值引用与move
文章来源: blog.csdn.net，作者：程序员编程指南，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/weixin_41055260/article/details/126277295
- 点赞
- 收藏
- 关注作者
评论（0）