C++技能系列 ( 7 ) - 右值引用、移动语意、完美转发

- 日理万妓 2024-03-16 21:19 37阅读 0赞

![在这里插入图片描述][475acfa0e4d24c59b75e31ddb6056bfb.png_pic_left]

***`现在的一切都是为将来的梦想编织翅膀，让梦想在现实中展翅高飞。`***  
***`Now everything is for the future of dream weaving wings, let the dream fly in reality.`***

#### 右值引用、移动语意、完美转发 ####

*  1、右值引用
 *  2、完美转发

## 1、右值引用 ##

右值引用（rvalue reference）是 C++11 为了实现移动语意（move semantic）和完美转发（perfect forwarding）而提出来的。  
右值引用，简单说就是绑定在右值上的引用。右值的内容可以直接移动（move）给左值对象，而不需要进行开销较大的深拷贝（deep copy）。  
移动语义  
下面这个例子：  
v2 = v1 调用的是拷贝赋值操作符，v2 复制了 v1 的内容 —— 复制语义。  
v3 = std::move(v1) 调用的是移动赋值操作符，将 v1 的内容移动给 v3 —— 移动语义。

std::vector<int> v1{
        1, 2, 3, 4, 5}; 
      std::vector<int> v2; 
      std::vector<int> v3; 
    
      v2 = v1; 
      std::cout << v1.size() << std::endl;  // 输出 5
      std::cout << v2.size() << std::endl;  // 输出 5
    
      v3 = std::move(v1); // move
      std::cout << v1.size() << std::endl;  // 输出0
      std::cout << v3.size() << std::endl;  // 输出 5

为了实现移动语意，C++ 增加了与拷贝构造函数（copy constructor）和拷贝赋值操作符（copy assignment operator）对应的移动构造函数（move constructor）和移动赋值操作符（move assignment operator），通过函数重载机制来确定应该调用拷贝语意还是移动语意（参数是左值引用就调用拷贝语意；参数是右值引用就调用移动语意）。 再来看一个简单的例子：

#include <iostream>
    #include <string>
    #include <vector>
    
    class Foo {
        
     public:
      // 默认构造函数
      Foo() {
         std::cout << "Default Constructor: " << Info() << std::endl; }
    
      // 自定义构造函数
      Foo(const std::string& s, const std::vector<int>& v) : s_(s), v_(v) {
        
        std::cout << "User-Defined Constructor: " << Info() << std::endl;
      }
    
      // 析构函数
      ~Foo() {
         std::cout << "Destructor: " << Info() << std::endl; }
    
      // 拷贝构造函数
      Foo(const Foo& f) : s_(f.s_), v_(f.v_) {
        
        std::cout << "Copy Constructor: " << Info() << std::endl;
      }
    
      // 拷贝赋值操作符
      Foo& operator=(const Foo& f) {
        
        s_ = f.s_;
        v_ = f.v_;
        std::cout << "Copy Assignment: " << Info() << std::endl;
        return *this;
      }
    
      // 移动构造函数
      Foo(Foo&& f) : s_(std::move(f.s_)), v_(std::move(f.v_)) {
        
        std::cout << "Move Constructor: " << Info() << std::endl;
      }
    
      // 移动赋值操作符
      Foo& operator=(Foo&& f) {
        
        s_ = std::move(f.s_);
        v_ = std::move(f.v_);
        std::cout << "Move Assignment: " << Info() << std::endl;
        return *this;
      }
    
      std::string Info() {
        
        return "{" + (s_.empty() ? "'empty'" : s_) + ", " +
               std::to_string(v_.size()) + "}";
      }
    
     private:
      std::string s_;
      std::vector<int> v_;
    };
    
    int main() {
        
      std::vector<int> v(1024);
    
      std::cout << "================ Copy =======================" << std::endl;
      Foo cf1("hello", v);
      Foo cf2(cf1);  // 调用拷贝构造函数
      Foo cf3;
      cf3 = cf2;  // 调用拷贝赋值操作符
      
      std::cout << "================ Move =========================" << std::endl;
      Foo f1("hello", v);
      Foo f2(std::move(f1));  // 调用移动构造函数
      Foo f3;
      f3 = std::move(f2);  // 调用移动赋值操作符
      return 0;
    }

简单封装了一个类 Foo，重点是实现：  
拷贝语意：拷贝构造函数 Foo(const Foo&) 、拷贝赋值操作符 Foo& operator=(const Foo&) 。  
移动语意：移动构造函数 Foo(Foo&&) 、移动赋值操作符 Foo& operator=(Foo&&) 。  
拷贝语意相信大部分人都比较熟悉了，也比较好理解。在这个例子中，每次都会拷贝 s\_ 和 v\_ 两个成员，最后 cf1、cf2、cf3 三个对象的内容都是一样的。 每次执行移动语意，是分别调用 s\_ 和 v\_ 的移动语意函数——理论上只需要对内部指针进行修改，所以效率较高。执行移动语意的代码片段了出现了一个标准库中的函数 std::move —— 它可以将参数强制转换成一个右值。本质上是告诉编译器，我想要 move 这个参数——最终能不能 move 是另一回事——可能对应的类型没有实现移动语意，可能参数是 const 的。 有一些场景可能拿到的值直接就是右值，不需要通过 std::move 强制转换，比如：

Foo GetFoo() {
        
      return Foo("GetFoo", std::vector<int>(11));
    }
    ....
    Foo f3("world", v3);
    ....
    f3 = GetFoo(); // GetFoo 返回的是一个右值，调用移动赋值操作符

## 2、完美转发 ##

C++ 通过了一个叫 std::forward 的函数模板来实现完美转发。这里直接使用 Effective Modern C++ 中的例子作为说明。在前面的例子上，我们增加如下的代码：

// 接受一个 const 左值引用
    void Process(const Foo& f) {
        
      std::cout << "lvalue reference" << std::endl;
      // ...
    }
    
    // 接受一个右值引用
    void Process(Foo&& f) {
        
      std::cout << "rvalue reference" << std::endl;
      // ...
    }
    
    template <typename T>
    void LogAndProcessNotForward(T&& a) {
        
      std::cout << a.Info() << std::endl;
      Process(a); 
    }
    
    template <typename T>
    void LogAndProcessWithForward(T&& a) {
        
      std::cout << a.Info() << std::endl;
      Process(std::forward<T>(a));
    }
    
     LogAndProcessNotForward(f3);                         // 输出 lvalue reference
     LogAndProcessNotForward(std::move(f3));  // 输出 lvalue reference
    
     LogAndProcessWithForward(f3);                        // 输出 lvalue reference
     LogAndProcessWithForward(std::move(f3));  // 输出 rvalue reference

LogAndProcessNotForward(f3); 和 LogAndProcessWithForward(f3); 都输出 “lvalue reference”，这一点都不意外，因为 f3 本来就是一个左值。  
LogAndProcessNotForward(std::move(f3)); 输出 “lvalue reference” 是因为虽然参数 a 绑定到一个右值，但是参数 a 本身是一个左值。  
LogAndProcessWithForward(std::move(f3)); 使用了 std::forward 对参数进行转发，std::forward 的作用就是：当参数是绑定到一个右值时，就将参数转换成一个右值。  
左值？右值？  
到底什么时候是左值？什么时候是右值？是不是有点混乱？ 在 C++ 中，每个表达式（expression）都有两个特性：  
has identity? —— 是否有唯一标识，比如地址、指针。有唯一标识的表达式在 C++ 中被称为 glvalue（generalized lvalue）。  
can be moved from? —— 是否可以安全地移动（编译器）。可以安全地移动的表达式在 C++ 中被成为 rvalue。  
根据这两个特性，可以将表达式分成 4 类：  
has identity and cannot be moved from - 这类表达式在 C++ 中被称为 lvalue。  
has identity and can be moved from - 这类表达式在 C++ 中被成为 xvalue（expiring value）。  
does not have identity and can be moved from - 这类表达式在 C++ 中被成为 prvalue（pure rvalue）。  
does not have identity and cannot be moved -C++ 中不存在这类表达式。  
简单总结一下这些 value categories 之间的关系：  
可以移动的值都叫 rvalue，包括 xvalue 和 prvalue。  
有唯一标识的值都叫 glvalue，包括 lvalue 和 xvalue。  
std::move 的作用就是将一个 lvalue 转换成 xvalue。

[475acfa0e4d24c59b75e31ddb6056bfb.png_pic_left]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a9b67d87026b470a8026d4397919a006.png