C++概念:右值引用,移动语义,完美转发

3,759 阅读6分钟

1. 右值引用

C++11以前,右值被认为是无用的资源,所以在C++11中引入了右值引用,就是为了重用右值。定义右值引用需要使用&&。 右值引用一定不能被左值所初始化,只能用右值初始化。那么为什么呢?因为右值引用的目的是为了延长用来初始化对象的生命周期,对于左值,其生命周期与其作用域有关,你没有必要去延长。既然是延长,那么就出现了下面的情况:

int x = 20;   // 左值
int&& rx = x * 2;  // x*2的结果是一个右值,rx延长其生命周期
int y = rx + 2;   // 因此你可以重用它:42
rx = 100;         // 一旦你初始化一个右值引用变量,该变量就成为了一个左值,可以被赋值

1.1. 右值引用作用

1.1.1. 延长生命周期

在C++11以前,我们常写如下例子:

class A
{
public:
    A() : m_ptr(new int(0))
    {
        cout << "construct" << endl;
    }
    A(const A& rhs) : m_ptr(new int(*rhs.m_ptr)) // 拷贝构造函数
    {
        cout << "copy construct" << endl;
    }
    ~A()
    {
        cout << "destruct" << endl;
        delete m_ptr;
    }
private:
    int* m_ptr;
};

A Get(bool flag)
{
    A a, b;
    if (flag)
    {
        return a;
    }
    return b;
}

int main()
{
    A a = Get(false);//调用拷贝构造函数
    return 0;
}

执行结果:
construct
construct
copy construct
destruct
destruct
destruct

问题:上述例子中Get函数会返回临时变量,然后通过这临时变量拷贝构造一个新的对象a,临时变量在拷贝构造完成之后就销毁了,如果堆内存很大,这个拷贝构造就比较消耗时间,带来性能的损耗,是否有方法避免临时对象的拷贝构造呢?即改成如下形式:

class A
{
public:
    A() : m_ptr(new int(0))
    {
        cout << "construct" << endl;
    }
    A(const A& rhs) : m_ptr(new int(*rhs.m_ptr)) // 拷贝构造函数
    {
        cout << "copy construct" << endl;
    }
    A(A&& rhs) : m_ptr(rhs.m_ptr) //移动构造函数
	{
  		rhs.m_ptr = nullptr;
 		 cout << "move construct" << endl;
	}
    ~A()
    {
        cout << "destruct" << endl;
        delete m_ptr;
    }
private:
    int* m_ptr;
};

A Get(bool flag)
{
    A a, b;
    if (flag)
    {
        return a;
    }
    return b;
}

int main()
{
    A a = Get(false);//调用拷贝构造函数
    return 0;
}

执行结果:
construct
construct
move construct
destruct
destruct
destruct

改进之后,不再调用拷贝构造函数,而是调用了移动构造函数(move construct)。从移动构造函数的实现可以看到,它的参数是一个右值引用类型的参数T&&,这里没有深拷贝,只有浅拷贝,这样就避免了对临时对象的深拷贝,和资源的重复申请和释放,提高了性能;延长了临时对象的生命周期,即上述例子中把返回值临时对象的生命周期交由给main函数中的a对象。

1.1.2. 转移不可拷贝的资源

如果资源是 不可拷贝 (non-copyable) 的,那么装载资源的对象也应该是不可拷贝的。 如果资源对象不可拷贝,一般需要定义 移动构造/移动赋值 函数,并禁用 拷贝构造/拷贝赋值 函数。例如,智能指针 std::unique_ptr只能移动 (move only)

template<typename T>
class unique_ptr {
 public:
  unique_ptr(const unique_ptr& rhs) = delete;
  unique_ptr(unique_ptr&& rhs) noexcept;  // move only
 private:
  T* data_ = nullptr;
};

unique_ptr::unique_ptr(unique_ptr&& rhs) noexcept {
  auto &lhs = *this;
  lhs.data_ = rhs.data_;
  rhs.data_ = nullptr;
}

1.2. 右值引用几点说明

  • 右值引用就是对一个右值进行引用的类型,因为右值不具名,因此只能通过引用的方式找到它;
  • 通过右值引用的声明,该右值又“重获新生(生命周期延长,原本是生命周期是要结束)”,其生命周期与右值引用类型变量的生命周期一样;
  • 无论声明为右值引用还是左值引用都必须立即初始化;

1.3. 右值引用解决如下问题

1.3.1. 移动语义std::move

移动语义是通过右值引用来匹配临时值的,那么,普通的左值是否也能借助移动语义来优化性能呢?

  • C++11 为了解决上述问题,提供了std::move方法来将左值转换为右值,从而方便应用移动语义,即无论你传给它的是左值还是右值,通过std::move之后都变成了右值;
  • move实际上并不能移动任何东西,他唯一的功能是将一个左值强制转换为一个右值引用,使我们可以通过右值引用使用该值;
 class string {
 public:
  string(const string& other);  // Copy constructor, exists pre C++11

  string(string&& other) {      // Move constructor, new in C++11
    length = other.length;
    capacity = other.capacity;
    data = other.data;
    other.data = nullptr; // 将临时对象的指针设置为空,other.data = nullptr;。若不将other.data设置为空,other.data 将被释放两次,导致程序异常。
  }

 private:
  size_t length;
  size_t capacity;
  const char* data;
};

int main(){
  string a(get_string());  // move constructor
  string b(a);             // copy constructor
  string c(std::move(b));  // move constructor
  return 0;
}

**注意:**若string中没有移动构造函数string(string&& other),上述的string c(std::move(b))仍然将调用拷贝构造函数进行构造,因为string(const string& other)的参数是const reference

C++11中,编译器将会在类中自动添加移动构造函数和移动赋值操作符,因此C++11中,声明一个类,编译器会默认添加构造函数、拷贝构造函数、析构函数、移动构造函数和移动赋值操作,号称类中的"5驾马车",而不是C++11之前的“3驾马车”。

若用户自定义拷贝构造函数,编译器将不会自动添加移动构造函数和移动赋值操作。可以在这些函数之后添加 = delete,显示的阻止编译器自动添加对应的函数。

通过std::move将左值转移成右值后,即原来的变量放弃了内存的所有权,后续代码不能使用该变量来访问对象;如果使用,会出现 未定义行为。

std::string base_url = tag->GetBaseUrl();
if (!base_url.empty()) {
  UpdateQueryUrl(std::move(base_url) + "&q=" + word_); //若执行了,后续base_url不能使用,若使用会出现未定义行为。
}
LOG(INFO) << base_url;  // |base_url| may be moved-from

而被移动的对象处于于合法但未指定状态:

  • 基本要求)能正确析构(不会重复释放已经被移动了的资源,例如 std::unique_ptr::~unique_ptr() 检查指针是否需要 delete
  • (一般要求)重新赋值后,和新的对象没有差别(C++ 标准库基于这个假设)
  • (更高要求)恢复为默认值(例如 std::unique_ptr 恢复为 nullptr
auto p = std::make_unique<int>(1);
auto q = std::move(p);

assert(p == nullptr);  // OK: reset to default
p.reset(new int{2});   // or p = std::make_unique<int>(2);
assert(*p == 2);       // OK: reset to int*(2)

由于基本类型不包含资源,其移动和拷贝相同:被移动后,保持为原有值。

int i = 1;
int j = std::move(i);

assert(i == j)

1.3.2. 完美转发std::forward

完美转发实现了参数在传递过程中保持其值属性的功能,即若是左值,则传递之后仍然是左值,若是右值,则传递之后仍然是右值。

void func(int &arg) {
	std::cout << "func lvalue" << std::endl;
}

void func(int &&arg) {
	std::cout << "func rvalue" << std::endl;
}

template <typename T>
	void wrapper(T &&args) { //无论args是什么引用类型,args都是左值
	func(args);
}

int main() {
	int a = 10; 

	wrapper(a); //传递左值
	wrapper(20); //传递右值

	return 0;
}
以上函数输出:
	func lvalue
	func lvalue

上述例子并没有做到对应的调用,其对应原因是:在wrapper函数中调用func函数时,对应的引用类型不能保持不变,即引用属性不能进行传递。所以,C++11提供了std::forward()函数用于完美转发。即,在转发过程中,左值引用在被转发之后仍然保持左值属性,右值引用在被转发之后依然保持右值属性。修改之后的代码如下:

void func(int &arg) {
  std::cout << "func lvalue" << std::endl;
}

void func(int &&arg) {
  std::cout << "func rvalue" << std::endl;
}

template <typename T>
void wrapper(T &&args) {
  func(std::forward<T>(args));
}

int main() {
  int a = 10; 

  wrapper(a);
  wrapper(20);

  return 0;
}

结果输出如下:
  func lvalue
  func rvalue

2. 拷贝省略

尽管C++引入了移动语义,移动的过程 仍有优化的空间 —— 与其调用一次 没有意义的移动构造函数,不如让编译器 直接跳过这个过程 —— 于是就有了拷贝省略(copy elision)。 然而,很多人会把移动语义和拷贝省略 混淆:

  • 移动语义是 语言标准 提出的概念,通过编写遵守移动语义的 移动构造函数、右值限定成员函数,逻辑上 优化 对象内资源 的转移流程
  • 拷贝省略是(C++ 17 前)非标准的 编译器优化,跳过移动/拷贝构造函数,让编译器直接在 移动后的对象 内存上,构造 被移动的对象
std::unique_ptr<int> foo() {
  auto ret = std::make_unique<int>(1);
  //...
  return std::move(ret);  // -> return ret;
}

没必要使用 std::move() 移动非引用返回值。C++ 会把 即将离开作用域的 非引用类型的 返回值当成 右值,对返回的对象进行移动构造(语言标准);如果编译器允许拷贝省略,还可以省略这一步的构造,直接把 ret 存放到返回值的内存里(编译器优化)。

3. std::move和std::forward的用处

3.1. case1——不移动右值引用参数

std::unique_ptr<int> bar(std::unique_ptr<int>&& val) {
  //...
  return val;    // not compile
                 // -> return std::move/forward(val);
}

上述代码的问题在于:没有对返回值使用 std::move()(编译器提示 std::unique_ptr(const std::unique_ptr&) = delete 错误)。 因为不论 左值引用 还是 右值引用 的变量(或参数)在初始化后,都是左值。所以,返回右值引用变量时,需要使用 std::move()/std::forward() 显式的 移动转发 或 完美转发,将变量 “还原” 为右值(右值引用类型)。

4. 参考文献

深入浅出 C++ 11 右值引用
资源管理小记
聊聊C++中的完美转发