深入理解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