深入浅出 C++ 11 右值引用

您所在的位置：网站首页 › that为什么可以省略 › 深入浅出 C++ 11 右值引用

深入浅出 C++ 11 右值引用

2023-05-29 17:52| 来源: 网络整理| 查看: 265

彻底搞清楚：右值引用/移动语义/拷贝省略/通用引用/完美转发 —— 以最短的篇幅，介绍常见误解（什么时候要用 move？什么时候不能 move？为什么 move 失败？）和基础知识（为什么右值引用变量是左值？为什么会调用移动构造函数？），一步步解释“为什么/是什么/怎么做”。写在前面如果你还不知道 C++ 11 引入的右值引用是什么，可以读读这篇文章，看看有什么启发；如果你已经对右值引用了如指掌，也可以读读这篇文章，看看有什么补充。

尽管 C++ 17 标准已经发布了，很多人还不熟悉 C++ 11 的右值引用/移动语义/拷贝省略/通用引用/完美转发等概念，甚至对一些细节有所误解（包括我 [emoji]）。

本文将以最短的篇幅，一步步解释关于右值引用的为什么/是什么/怎么做。先分享几个我曾经犯过的错误。

误解：返回前，移动局部变量 ES.56: Write std::move() only when you need to explicitly move an object to another scope std::string base_url = tag->GetBaseUrl(); if (!base_url.empty()) { UpdateQueryUrl(std::move(base_url) + "&q=" + word_); } LOG(INFO) return ret; }

上述代码的问题在于：没必要使用 std::move() 移动非引用返回值。

C++ 会把即将离开作用域的非引用类型的返回值当成右值（参考 [sec|值类别 vs 变量类型]），对返回的对象进行 [sec|移动语义] 移动构造（语言标准）；如果编译器允许 [sec|拷贝省略] 拷贝省略，还可以省略这一步的构造，直接把 ret 存放到返回值的内存里（编译器优化）。

Never apply std::move() or std::forward() to local objects if they would otherwise be eligible for the return value optimization. —— Scott Meyers, Effective Modern C++

另外，误用 std::move() 会阻止编译器的拷贝省略优化。不过聪明的 Clang 会提示 -Wpessimizing-move/-Wredundant-move 警告。

误解：不移动右值引用参数 F.18: For “will-move-from” parameters, pass by X&& and std::move() the parameter std::unique_ptr bar(std::unique_ptr&& val) { //... return val; // not compile // -> return std::move/forward(val); }

上述代码的问题在于：没有对返回值使用 std::move()（编译器提示 std::unique_ptr(const std::unique_ptr&) = delete 错误）。

If-it-has-a-name Rule: Named rvalue references are lvalues. Unnamed rvalue references are rvalues.

因为不论左值引用还是右值引用的变量（或参数）在初始化后，都是左值（参考 [sec|值类别 vs 变量类型]）：

命名的右值引用(named rvalue reference)变量是左值，但变量类型却是右值引用在作用域内，左值变量可以通过变量名(variable name)被取地址、被赋值

所以，返回右值引用变量时，需要使用 std::move()/std::forward() 显式的 [sec|移动转发] 移动转发或 [sec|完美转发] 完美转发，将变量 “还原” 为右值（右值引用类型）。

误解：手写错误的移动构造函数 C.20: If you can avoid defining default operations, doC.21: If you define or =delete any default operation, define or =delete them allC.80: Use =default if you have to be explicit about using the default semanticsC.66: Make move operations noexcept

实际上，多数情况下：

如果没有定义拷贝构造/拷贝赋值/移动构造/移动赋值/析构函数的任何一个，编译器会自动生成移动构造/移动赋值函数（rule of zero）如果需要定义拷贝构造/拷贝赋值/移动构造/移动赋值/析构函数的任何一个，不要忘了移动构造/移动赋值函数，否则对象会不可移动（rule of five）尽量使用=default 让编译器生成移动构造/移动赋值函数，否则容易写错如果需要自定义移动构造/移动赋值函数，尽量定义为 noexcept 不抛出异常（编译器生成的版本会自动添加），否则不能高效使用标准库和语言工具

例如，标准库容器 std::vector 在扩容时，会通过 std::vector::reserve() 重新分配空间，并转移已有元素。如果扩容失败，std::vector 满足 ef="https://en.cppreference.com/w/cpp/language/exceptions#Exception_safety">强异常保证 (strong exception guarantee)，可以回滚到失败前的状态。

为此，std::vector 使用 std::move_if_noexcept() 进行元素的转移操作：

优先使用 noexcept 移动构造函数（高效；不抛出异常）其次使用拷贝构造函数（低效；如果异常，可以回滚）再次使用非 noexcept 移动构造函数（高效；如果异常，无法回滚）最后如果不可拷贝、不可移动，编译失败

如果没有定义移动构造函数或自定义的移动构造函数没有 noexcept，会导致 std::vector 扩容时执行无用的拷贝，不易发现。

基础知识

之所以会出现上边的误解，往往是因为 C++ 语言的复杂性和使用者对基础知识的掌握程度不匹配。

值类别 vs 变量类型

划重点 —— 值 (value) 和变量 (variable) 是两个独立的概念：

值只有类别(category) 的划分，变量只有类型(type) 的划分值不一定拥有身份(identity)，也不一定拥有变量名（例如表达式中间结果 i + j + k）

值类别 (value category) 可以分为两种：

左值(lvalue, left value) 是能被取地址、不能被移动的值右值(rvalue, right value) 是表达式中间结果/函数返回值（可能拥有变量名，也可能没有） C++ 17 细化了 prvalue/xvalue/lvalue 和 rvalue/glvalue 类别，本文不详细讨论。

引用类型属于一种变量类型 (variable type)，将在 [sec|左值引用 vs 右值引用 vs 常引用] 详细讨论。

在变量初始化 (initialization) 时，需要将初始值 (initial value) 绑定到变量上；但引用类型变量的初始化和其他的值类型（非引用类型）变量不同：

创建时，必须显式初始化（和指针不同，不允许空引用(null reference)；但可能存在悬垂引用(dangling reference)）相当于是其引用的值的一个别名(alias)（例如，对引用变量的赋值运算(assignment operation) 会赋值到其引用的值上）一旦绑定了初始值，就不能重新绑定到其他值上了（和指针不同，赋值运算不能修改引用的指向；而对于 Java/JavaScript 等语言，对引用变量赋值可以重新绑定）左值引用 vs 右值引用 vs 常引用

引用类型可以分为两种：

左值引用(l-ref, lvalue reference) 用 & 符号引用左值（但不能引用右值）右值引用(r-ref, rvalue reference) 用 && 符号引用右值（也可以移动左值） void f(Data& data); // 1, data is l-ref void f(Data&& data); // 2, data is r-ref Data data; Data& data1 = data; // OK Data& data1 = Data{}; // not compile: invalid binding Data&& data2 = Data{}; // OK Data&& data2 = data; // not compile: invalid binding Data&& data2 = std::move(data); // OK f(data); // 1, data is lvalue f(Data{}); // 2, data is rvalue f(data1); // 1, data1 is l-ref type and lvalue f(data2); // 1, data2 is r-ref type but lvalue 左值引用变量 data1 在初始化时，不能绑定右值 Data{} 右值引用变量 data2 在初始化时，不能绑定左值data 但可以通过 std::move() 将左值转为右值引用（参考 [sec|移动转发]）右值引用变量 data2 被初始化后，在作用域内是左值（参考 [sec|误解：不移动右值引用参数]），所以匹配 f() 的重载 2

另外，C++ 还支持了常引用 (c-ref, const reference)，同时接受左值/右值进行初始化：

void g(const Data& data); // data is c-ref g(data); // ok, data is lvalue g(Data{}); // ok, data is rvalue

常引用和右值引用都能接受右值的绑定，有什么区别呢？

通过右值引用/常引用初始化的右值，都可以将生命周期扩展 (lifetime extension) 到绑定该右值的引用的生命周期初始化时绑定了右值后，右值引用可以修改引用的右值，而常引用不能修改 const Data& data1 = Data{}; // OK: extend lifetime data1.modify(); // not compile: const Data&& data2 = Data{}; // OK: extend lifetime data2.modify(); // OK: non-const 引用参数重载优先级

如果函数重载同时接受右值引用/常引用参数，编译器优先重载右值引用参数 —— 是 [sec|移动语义] 移动语义的实现基础：

void f(const Data& data); // 1, data is c-ref void f(Data&& data); // 2, data is r-ref f(Data{}); // 2, prefer 2 over 1 for rvalue

针对不同左右值实参 (argument) 重载引用类型形参 (parameter) 的优先级如下：

数值越小，优先级越高；如果不存在，则重载失败如果同时存在传值(by value) 重载（接受值类型参数 T），会和上述传引用(by reference) 重载产生歧义，编译失败常右值引用(const rvalue reference)const T;; 一般不直接使用（参考）引用折叠

引用折叠(reference collapsing)（是 [sec|移动转发] std::move() 和 [sec|完美转发] std::forward() 的实现基础：

using Lref = Data&; using Rref = Data&&; Data data; Lref& r1 = data; // r1 is Data& Lref&& r2 = data; // r2 is Data& Rref& r3 = data; // r3 is Data& Rref&& r4 = Data{}; // r4 is Data&& 移动语义

在 C++ 11 强化了左右值概念后，提出了移动语义 (move semantic) 优化：由于右值对象一般是临时对象，在移动时，对象包含的资源不需要先拷贝再删除，只需要直接从旧对象移动到新对象。

同时，要求被移动的对象处于合法但未指定状态（参考 [sec|误解：被移动的值不能再使用]）：

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

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

避免先拷贝再释放资源

一般通过重载构造/赋值函数实现移动语义。例如，std::vector 有：

以常引用作为参数的拷贝构造函数(copy constructor) 以右值引用作为参数的移动构造函数(move constructor) template class vector { public: vector(const vector& rhs); // copy data vector(vector&& rhs) noexcept; // move data ~vector(); // dtor private: T* data_ = nullptr; size_t size_ = 0; }; vector::vector(const vector& rhs) : data_(new T[rhs.size_]) { auto &lhs = *this; lhs.size_ = rhs.size_; std::copy_n(rhs.data_, rhs.size_, lhs.data_); // copy data } vector::vector(vector&& rhs) noexcept { auto &lhs = *this; lhs.size_ = rhs.size_; lhs.data_ = rhs.data_; // move data rhs.size_ = 0; rhs.data_ = nullptr; // set data of rhs to null } vector::~vector() { if (data_) // release only if owned delete[] data_; }

上述代码中，构造函数 vector::vector() 根据实参判断（重载优先级参考 [sec|引用参数重载优先级]）：

实参为左值时，拷贝构造，使用 new[]/std::copy_n 拷贝原对象的所有元素（本方案有一次冗余的默认构造，仅用于演示）实参为右值时，移动构造，把指向原对象内存的指针 data_、内存大小 size_ 拷贝到新对象，并把原对象这两个成员置 0

析构函数 vector::~vector() 检查 data_ 是否有效，决定是否需要释放资源。

此处省略拷贝赋值/移动赋值函数，但建议加上。（参考 [sec|误解：手写错误的移动构造函数]）

此外，类的成员函数还可以通过ef="https://en.cpprefhttp://erence.com/w/cpp/language/member_functions#const-.2C_volatile-.2C_and_ref-qualified_member_functions">引用限定符(reference qualifier)，针对当前对象本身的左右值状态（以及 const-volatile）重载：

class Foo { public: Data data() && { return std::move(data_); } // rvalue, move-out Data data() const& { return data_; } // otherwise, copy }; auto ret1 = foo.data(); // foo is lvalue, copy auto ret2 = Foo{}.data(); // Foo{} is rvalue, move 转移不可拷贝的资源在之前写的资源管理小记提到：如果资源是不可拷贝 (non-copyable) 的，那么装载资源的对象也应该是不可拷贝的。

如果资源对象不可拷贝，一般需要定义移动构造/移动赋值函数，并禁用拷贝构造/拷贝赋值函数。例如，智能指针 std::unique_ptr 只能移动 (move only)：

template 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; }

上述代码中，unique_ptr 的移动构造过程和 vector 类似：

把指向原对象内存的指针 data_ 拷贝到新对象把原对象的指针 data_ 置为空反例：不遵守移动语义

移动语义只是语言上的一个概念，具体是否移动对象的资源、如何移动对象的资源，都需要通过编写代码实现。而移动语义常常被误认为，编译器自动生成移动对象本身的代码（[sec|拷贝省略] 拷贝省略）。

为了证明这一点，我们可以实现不遵守移动语义的 bad_vec::bad_vec(bad_vec&& rhs)，执行拷贝语义：

bad_vec::bad_vec(bad_vec&& rhs) : data_(new T[rhs.size_]) { auto &lhs = *this; lhs.size_ = rhs.size_; std::copy_n(rhs.data_, rhs.size_, lhs.data_); // copy data }

那么，一个 bad_vec 对象在被 move 移动后仍然可用：

bad_vec v_old { 0, 1, 2, 3 }; auto v_new = std::move(v_old); v_old[0] = v_new[3]; // ok, but odd :-) assert(v_old[0] != v_new[0]); assert(v_old[0] == v_new[3]);

虽然代码可以那么写，但是在语义上有问题：进行了拷贝操作，违背了移动语义的初衷。

拷贝省略

尽管 C++ 引入了移动语义，移动的过程仍有优化的空间 —— 与其调用一次没有意义的移动构造函数，不如让编译器直接跳过这个过程 —— 于是就有了 ref="https://en.cppreference.com/w/cpp/language/copy_elision">拷贝省略(copy elision)。

然而，很多人会把移动语义和拷贝省略混淆：

移动语义是语言标准提出的概念，通过编写遵守移动语义的移动构造函数、右值限定成员函数，逻辑上优化对象内资源的转移流程拷贝省略是（C++ 17 前）非标准的编译器优化，跳过移动/拷贝构造函数，让编译器直接在移动后的对象内存上，构造被移动的对象（例如 [sec|误解：移动非引用返回值] 的代码，直接在函数返回值对象的内存上，构造函数局部对象 ret —— 在不同作用域里，共享同一块内存）

C++ 17 要求编译器对纯右值 (prvalue, pure rvalue) 进行拷贝省略优化。（参考）

Data f() { Data val; // ... throw val; // ... return val; // NRVO from lvalue to ret (not guaranteed) // if NRVO is disabled, move ctor is called } void g(Date arg); Data v = f(); // copy elision from prvalue (C++ 17) g(f()); // copy elision from prvalue (C++ 17)

初始化局部变量、函数参数时，传入的纯右值可以确保被优化 —— Return Value Optimization (RVO)；而返回的将亡值 (xvalue, eXpiring value) 不保证被优化 —— Named Return Value Optimization (NRVO)。

通用引用和完美转发揭示 std::move()/std::forward() 的原理，需要读者有一定的模板编程基础。为什么需要通用引用

C++ 11 引入了变长模板的概念，允许向模板参数里传入不同类型的不定长引用参数。由于每个类型可能是左值引用或右值引用，针对所有可能的左右值引用组合，特化所有模板是不现实的。

假设没有通用引用的概念，模板 std::make_unique 至少需要两个重载：

template unique_ptr make_unique(const Args&... args) { return unique_ptr { new T { args... } }; } template unique_ptr make_unique(Args&&... args) { return unique_ptr { new T { std::move(args)... } }; } 对于传入的左值引用 const Args&… args，只要展开 args… 就可以转发这一组左值引用对于传入的右值引用 Args&&… args，需要通过 [sec|移动转发] std::move() 转发出去，即 std::move(args)…（为什么要转发：参考 [sec|误解：不移动右值引用参数]）

上述代码的问题在于：如果传入的 args 既有左值引用又有右值引用，那么这两个模板都无法匹配。

通用引用 Item 24: Distinguish universal references from rvalue references. —— Scott Meyers, Effective Modern C++

Scott Meyers 指出：有时候符号 && 并不一定代表右值引用，它也可能是左值引用 —— 如果一个引用符号需要通过左右值类型推导（模板参数类型或 auto 推导），那么这个符号可能是左值引用或右值引用 —— 这叫做通用引用 (universal reference)。

// rvalue ref: no type deduction void f1(Widget&& param1); Widget&& var1 = Widget(); template void f2(vector&& param2); // universal ref: type deduction auto&& var2 = var1; template void f3(T&& param);

上述代码中，前三个 && 符号不涉及引用符号的左右值类型推导，都是右值引用；而后两个 && 符号会根据初始值推导左右值类型：

对于var2 因为 var1 是左值，所以 var2 也是左值引用推导不会参考 var1 的变量类型对于T&& 如果 param 传入左值，T;; 是左值引用 std::remove_reference_t; 如果 param 传入右值，T;; 是右值引用 std::remove_reference_t;;

基于通用引用，[sec|为什么需要通用引用] 的模板 std::make_unique 只需要一个重载：

template unique_ptr make_unique(Args&&... args) { return unique_ptr { new T { std::forward(args)... } }; }

其中，std::forward() 实现了针对不同左右值参数的转发 —— 完美转发。

完美转发

什么是完美转发 (perfect forwarding)：

如果参数是左值引用，直接以左值引用的形式，转发给下一个函数如果参数是右值引用，要先 “还原” 为右值引用的形式，再转发给下一个函数

因此，std::forward() 定义两个不涉及左右值类型推导的模板（不能使用通用引用参数）：

template T&& forward(std::remove_reference_t& val) noexcept { // #1 // forward lvalue as either lvalue or rvalue return static_cast(val); } template T&& forward(std::remove_reference_t&& val) noexcept { // #2 // forward rvalue as rvalue (not lvalue) static_assert(!std::is_lvalue_reference_v, "Cannot forward rvalue as lvalue."); return static_cast(val); }

实参/返回值重载l-ref 返回值r-ref 返回值l-ref 实参#1完美转发移动转发r-ref 实参#2语义错误完美转发

尽管初始化后的变量都是左值（参考 [sec|误解：不移动右值引用参数]），但原始的变量类型仍会保留因此，可以根据实参类型选择重载，和模板参数 `T` 的类型无关返回值类型static_cast(val) 经过模板参数 T;; [sec|引用折叠] 引用折叠实现完美转发/移动转发，和实参类型无关 “将 l-ref 实参转发为 r-ref 返回值” 等价于 [sec|移动转发] std::move() 移动转发移动转发

类似的，std::move() 只转发为右值引用类型：

template std::remove_reference_t&& move(T&& val) noexcept { // forward either lvalue or rvalue as rvalue return static_cast(val); }

实参/返回值r-ref 返回值l-ref 实参移动转发r-ref 实参移动转发（完美转发）

接受通用引用模板参数 T&&（无需两个模板，使用时不区分 T 的引用类型）返回值 static_cast

【本文地址】

深入浅出 C++ 11 右值引用

深入浅出 C++ 11 右值引用

今日新闻

推荐新闻