现代 C++:右值引用、移动语意、完美转发

右值引用(rvalue reference)是 C++11 为了实现移动语意(move semantic)和完美转发(perfect forwarding)而提出来的。

右值引用,简单说就是绑定在右值上的引用。右值的内容可以直接移动(move)给左值对象,而不需要进行开销较大的深拷贝(deep copy)。

移动语义

下面这个例子:

  1. v2 = v1 调用的是拷贝赋值操作符,v2 复制了 v1 的内容 —— 复制语义。
  2. 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 返回的是一个右值,调用移动赋值操作符

完美转发

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)都有两个特性:

  1. has identity? —— 是否有唯一标识,比如地址、指针。有唯一标识的表达式在 C++ 中被称为 glvalue(generalized lvalue)。

  2. can be moved from? —— 是否可以安全地移动(编译器)。可以安全地移动的表达式在 C++ 中被称为 rvalue。

根据这两个特性,可以将表达式分成 4 类:

  1. has identity and cannot be moved from - 这类表达式在 C++ 中被称为 lvalue。

  2. has identity and can be moved from - 这类表达式在 C++ 中被称为 xvalue(expiring value)。

  3. does not have identity and can be moved from - 这类表达式在 C++ 中被称为 prvalue(pure rvalue)。

  4. does not have identity and cannot be moved -C++ 中不存在这类表达式。

简单总结一下这些 value categories 之间的关系:

  1. 可以移动的值都叫 rvalue,包括 xvalue 和 prvalue。

  2. 有唯一标识的值都叫 glvalue,包括 lvalue 和  xvalue。

  3. std::move 的作用就是将一个 lvalue 转换成 xvalue。

这些概念其实有点绕。不过就算不是特别清楚这些概念,也不影响我们对移动语义的利用。

参考文档

  • 维基百科:右值引用 - https://zh.wikipedia.org/wiki/%E5%8F%B3%E5%80%BC%E5%BC%95%E7%94%A8

  • Value categories - https://en.cppreference.com/w/cpp/language/value_category

我来评几句
登录后评论

已发表评论数()

相关站点

+订阅
热门文章