C++ 右值引用(rvalue references)与移动语义(move semantics)深度解析
<div id="navCategory"><h5 class="catalogue">目录</h5><ul class="first_class_ul"><li>一、右值引用（rvalue references）与移动语义（move semantics）设计动机</li><ul class="second_class_ul"><li>1.1 为什么需要移动语义</li><li>1.2 为什么需要右值引用</li><ul class="third_class_ul"><li>C++11 之后共有 5 种值类别：</li></ul></ul><li>二、值类别（value categories）——理解左右值很关键</li><ul class="second_class_ul"></ul><li>三、右值引用与移动构造/赋值（基本定义）</li><ul class="second_class_ul"></ul><li>四、std::move、std::forward与完美转发</li><ul class="second_class_ul"></ul><li>五、RVO / NRVO 与返回值优化</li><ul class="second_class_ul"></ul><li>六、移动语义对标准容器与算法的影响</li><ul class="second_class_ul"></ul><li>七、移动语义和异常安全，为什么noexcept很重要</li><ul class="second_class_ul"></ul><li>八、设计上的注意事项与常见陷阱</li><ul class="second_class_ul"><li>1) 移动后的对象状态</li><ul class="third_class_ul"></ul><li>2) 禁止移动操作（make class non-moveable）</li><ul class="third_class_ul"></ul><li>3) 轻量类型也可移动？是否必要？</li><ul class="third_class_ul"></ul><li>4) 当实现了自定义拷贝/移动时记住 Rule of Five</li><ul class="third_class_ul"></ul><li>5) 完美转发与重载决议</li><ul class="third_class_ul"></ul></ul><li>九、move-only 类型（典型示例：std::unique_ptr）</li><ul class="second_class_ul"></ul><li>十、模板与完美转发的典型模式（emplace与工厂）</li><ul class="second_class_ul"></ul><li>十一、性能分析</li><ul class="second_class_ul"></ul><li>十二、实战建议</li><ul class="second_class_ul"><li>1) 表达式模板 / 延迟求值库（Eigen、std::string 复制优化）</li><ul class="third_class_ul"></ul><li>2) 委托内存池 + move</li><ul class="third_class_ul"></ul><li>3) 多线程注意</li><ul class="third_class_ul"></ul><li>4)std::function与 move-only 可调用对象</li><ul class="third_class_ul"></ul></ul><li>十三、实战注意要点</li><ul class="second_class_ul"></ul><li>十四、典型示例与对比</li><ul class="second_class_ul"></ul><li>十五、总结</li><ul class="second_class_ul"></ul></ul></div><p class="maodian"></p><h2>一、右值引用（rvalue references）与移动语义（move semantics）设计动机</h2><p class="maodian"></p><h3>1.1 为什么需要移动语义</h3>
<p>传统 C++ 的对象拷贝（copy）在管理资源（堆内存、文件句柄、套接字、大数组等）时代价高。以前的做法：</p>
<ul><li>提供拷贝构造/赋值，或</li><li>使用指针/引用共享资源（容易出错）或</li><li>使用 swap 优化复制（代价仍然存在）</li></ul>
<p>移动语义的目标：当可以“窃取”一个临时对象的内部资源而不是逐元素复制时，允许编译器选择把资源从源对象“移动”到目标对象，使得构造与赋值的成本从 O(n) 变为 O(1)。这是通过 <strong>右值引用（</strong><code>T&&</code><strong>）</strong> 与专门的 <strong>移动构造函数 / 移动赋值运算符</strong> 实现的。</p>
<p class="maodian"></p><h3>1.2 为什么需要右值引用</h3>
<p>在 C++11 之前：</p>
<ul><li><strong>返回大对象</strong>（如 <code>std::vector<PointXYZ></code>）会发生昂贵的 <strong>深拷贝（deep copy）</strong>。</li><li>临时对象往往不需要被复制（因为临时对象马上就会销毁）。</li><li>无法区分 “临时对象的引用” 与 “普通左值引用”。</li></ul>
<p>因此：</p>
<div class="jb51code"><pre class="brush:cpp;">std::vector<int> v;
// …
auto x = v;// 必须深拷贝
</pre></div>
<p>深拷贝非常昂贵，尤其对于 SLAM 中：</p>
<ul><li>大规模点云</li><li>特征向量（FPFH、SHOT、Descriptors）</li><li>图优化结构（因子图、Jacobian Blocks）</li></ul>
<p><strong>右值引用</strong> + <strong>移动语义</strong> 就是解决上述性能瓶颈的关键。</p>
<p class="maodian"></p><h2>二、值类别（value categories）——理解左右值很关键</h2>
<p class="maodian"></p><h4>C++11 之后共有 5 种值类别：</h4>
<table><thead><tr><th>类别</th><th>描述</th><th>示例</th></tr></thead><tbody><tr><td><strong>lvalue（左值）</strong></td><td>有名字，可取地址</td><td><code>x</code>、<code>v</code></td></tr><tr><td><strong>xvalue（将亡值）</strong></td><td>即将被销毁的对象，可以“偷资源”</td><td><code>std::move(x)</code>、<code>T&&</code> 某些表达式</td></tr><tr><td><strong>prvalue（纯右值）</strong></td><td>临时值，无名称</td><td><code>T()</code>、<code>3</code>、<code>func()</code> 返回临时</td></tr><tr><td><strong>glvalue（泛左值）</strong></td><td>lvalue + xvalue</td><td>能代表 “对象的定位”</td></tr><tr><td><strong>rvalue（右值）</strong></td><td>xvalue + prvalue</td><td>可移动但不能取地址</td></tr></tbody></table>
<p>记住要点：</p>
<ul><li><strong>左值有身份，不必有值</strong></li><li><strong>右值有值，不必有身份</strong></li></ul>
<p>右值引用就是绑定 <strong>xvalue 与 prvalue</strong> 的一种引用。</p>
<p>关键：右值引用 <code>T&&</code> 能接受 xvalue/prvalue，但不接受 lvalue（除非用 <code>std::move</code> 或模板完美转发）。</p>
<p class="maodian"></p><h2>三、右值引用与移动构造/赋值（基本定义）</h2>
<p>对类 <code>T</code>，推荐实现（rule of five）：</p>
<div class="jb51code"><pre class="brush:cpp;">struct T {
// 构造/析构
T(); // default ctor
T(const T&); // copy ctor
T(T&&) noexcept; // move ctor
T& operator=(const T&);// copy assign
T& operator=(T&&) noexcept; // move assign
~T();
};
</pre></div>
<p><strong>示例 — 简单资源类（动态数组）</strong></p>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <utility> // std::move
struct Buffer {
size_t size_;
double* data_;
Buffer(size_t n=0) : size_(n), data_(n ? new double : nullptr) {}
~Buffer() { delete[] data_; }
// copy
Buffer(const Buffer& o) : size_(o.size_) {
if (size_) {
data_ = new double;
std::copy(o.data_, o.data_ + size_, data_);
} else data_ = nullptr;
std::cout<<"copy ctor\n";
}
// move
Buffer(Buffer&& o) noexcept : size_(o.size_), data_(o.data_) {
o.size_ = 0;
o.data_ = nullptr;
std::cout<<"move ctor\n";
}
// copy assign
Buffer& operator=(const Buffer& o){
if(this==&o) return *this;
delete[] data_;
size_=o.size_;
data_ = size_? new double: nullptr;
std::copy(o.data_, o.data_ + size_, data_);
std::cout<<"copy assign\n";
return *this;
}
// move assign
Buffer& operator=(Buffer&& o) noexcept {
if(this==&o) return *this;
delete[] data_;
size_ = o.size_;
data_ = o.data_;
o.size_ = 0;
o.data_ = nullptr;
std::cout<<"move assign\n";
return *this;
}
};</pre></div>
<p><strong>要点</strong>：</p>
<ul><li>移动构造/赋值<strong>窃取</strong>资源指针并把源对象置于安全的析构态（通常设置为 <code>nullptr</code>、<code>0</code>）。</li><li><code>noexcept</code> 很重要 —— 它允许容器（比如 <code>std::vector<T></code>）在扩容时使用移动而不是拷贝（容器会在异常安全性不保证时退回拷贝策略）。</li></ul>
<p class="maodian"></p><h2>四、std::move、std::forward与完美转发</h2>
<ul><li><code>std::move(x)</code>：<strong>把 lvalue 强制转换成 xvalue（右值）</strong>，告诉编译器“可以窃取 x 的资源”。但它本身不移动；只是类型转换。</li><li><code>std::forward<T>(x)</code>：在模板中保留值类别（完美转发）。当模板参数 <code>T</code> 是 <code>U&&</code> 的情况下，<code>forward</code> 会在 <code>T</code> 为 lvalue-reference 时转成 lvalue，否则转成 rvalue。</li></ul>
<p>示例：</p>
<div class="jb51code"><pre class="brush:cpp;">void take_by_value(Buffer b) { /*...*/ }
Buffer b(100);
take_by_value(b); // copy
take_by_value(std::move(b)); // move (resource stolen)</pre></div>
<p><strong>注意</strong>：对已 <code>std::move</code> 的对象继续使用可能导致未定义语义（安全但不可预测状态），称为 use-after-move。移动后的对象必须处于析构与赋值安全状态，但其具体内容不可依赖，除非类型指定了明确语义。</p>
<p class="maodian"></p><h2>五、RVO / NRVO 与返回值优化</h2>
<p>在很多情况下函数返回临时对象时会有拷贝或移动。现代编译器会做 <strong>（命名）返回值优化</strong>（RVO / NRVO），避免额外拷贝/移动。C++17 更严格地把 prvalue 语义演进，使得通常不会触发移动或拷贝（直接在调用者处构造返回对象）。</p>
<p>示例：</p>
<div class="jb51code"><pre class="brush:cpp;">Buffer make_buffer(size_t n){
Buffer tmp(n);
// ... fill ...
return tmp; // RVO: tmp 在调用处直接构造
}
</pre></div>
<p>即便没有 RVO，若 <code>Buffer</code> 有移动构造，也会用移动构造移动临时对象（开销小）。</p>
<p class="maodian"></p><h2>六、移动语义对标准容器与算法的影响</h2>
<ul><li>容器（<code>std::vector</code>、<code>std::deque</code> 等）会在重新分配时尽量移动元素（若 <code>T</code> 的移动构造 <code>noexcept</code>，容器使用移动；否则可能回退到拷贝）。因此，务必对能移动的大对象提供 <code>noexcept</code> 的移动构造/赋值。</li><li><code>std::move_iterator</code>、<code>std::make_move_iterator</code> 可以把算法变为“移动模式”：例如 <code>std::copy(std::make_move_iterator(first), std::make_move_iterator(last), dest)</code> 会把元素移动到 <code>dest</code>。</li><li><code>std::move_if_noexcept</code>：在条件下选择移动（如果移动抛异常则拷贝）。容器扩容等场景常使用这一策略。</li></ul>
<p class="maodian"></p><h2>七、移动语义和异常安全，为什么noexcept很重要</h2>
<ul><li>如果移动构造有可能抛出异常，容器在重分配时可能无法保证强异常安全，会选择回退到拷贝策略（更安全但更慢）。</li><li>因此 移动构造/赋值应尽可能声明 <code>noexcept</code>。若必须在移动中做可能抛异常的操作，可以将那些操作放在拷贝 / swap 路径中，或保证内部操作不会抛异常。</li></ul>
<p>推荐模式（move via swap）：</p>
<div class="jb51code"><pre class="brush:cpp;">T& operator=(T&& other) noexcept {
swap(*this, other);
return *this;
}</pre></div>
<p>但要确保 <code>swap</code> 本身 <code>noexcept</code>。</p>
<p class="maodian"></p><h2>八、设计上的注意事项与常见陷阱</h2>
<p class="maodian"></p><h3>1) 移动后的对象状态</h3>
<p>移动后对象应该处于<strong>有效但未指定内容</strong>的状态，可安全析构和赋值，但不能假设其值。文档化被移动后对象的可用操作（建议仅能被赋值或析构）是一种好习惯。</p>
<p class="maodian"></p><h3>2) 禁止移动操作（make class non-moveable）</h3>
<p>如果类管理不可转移资源（例如与 OS 绑定的唯一句柄，或禁止移动的语义），可以删掉移动构造：</p>
<div class="jb51code"><pre class="brush:cpp;">T(T&&) = delete;
T& operator=(T&&) = delete;</pre></div>
<p class="maodian"></p><h3>3) 轻量类型也可移动？是否必要？</h3>
<p>对小 POD（如 <code>int</code>, <code>double</code>）移动没有意义；移动语义主要针对“外部资源”。但实现移动构造不会有坏处，只是多写一点代码。</p>
<p class="maodian"></p><h3>4) 当实现了自定义拷贝/移动时记住 Rule of Five</h3>
<p>如果用户定义了任一种：析构（dtor）、拷贝构造、拷贝赋值、移动构造、移动赋值，应考虑同时实现或禁用另外两者以避免编译器生成不合适的默认函数。</p>
<p class="maodian"></p><h3>5) 完美转发与重载决议</h3>
<p>对于函数模板，重载 <code>f(const T&)</code> 与 <code>f(T&&)</code> 时注意：<code>f(T&&)</code> 对于左值不会匹配除非使用模板参数推导或 <code>std::move</code>。这常用于实现 <code>emplace_back</code> 或工厂函数。</p>
<p class="maodian"></p><h2>九、move-only 类型（典型示例：std::unique_ptr）</h2>
<p><code>std::unique_ptr</code> 是只可移动不可拷贝的典型例子。它利用移动语义保证资源唯一性。使用 <code>unique_ptr</code> 可以安全地把资源传递给函数或容器（容器会移动 <code>unique_ptr</code> 对象）。</p>
<div class="jb51code"><pre class="brush:cpp;">std::unique_ptr<Foo> make_foo() {
return std::make_unique<Foo>();
}
std::vector<std::unique_ptr<Foo>> v;
v.push_back(make_foo()); // move into vector</pre></div>
<p>注意：<code>std::vector<T></code> 可以存放 move-only 类型（C++11 起）。</p>
<p class="maodian"></p><h2>十、模板与完美转发的典型模式（emplace与工厂）</h2>
<p><strong>完美转发</strong> 用于把参数原样传递给构造函数或函数，避免不必要拷贝/移动：</p>
<div class="jb51code"><pre class="brush:cpp;">template<typename T, typename... Args>
std::unique_ptr<T> make_unique_impl(Args&&... args){
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}</pre></div>
<p><code>std::vector::emplace_back(args...)</code> 使用完美转发在目标存储处直接构造对象，避免临时对象再移动/拷贝（相对于 <code>push_back(T(args...))</code> 更高效）。</p>
<p class="maodian"></p><h2>十一、性能分析</h2>
<ol><li><strong>测量拷贝 VS 移动</strong>：在 Debug 模式下可能看不到差异（优化关闭），要在 Release 编译并测量真实应用场景（例如大量点云向量移动）。</li><li><strong>profile container reallocation</strong>：如果类型的移动不是 <code>noexcept</code>，<code>std::vector</code> 可能在扩容时拷贝元素造成意外开销。检查移动构造是否 <code>noexcept</code>。</li><li>避免不必要的 <code>std::move</code>：对返回局部变量的 <code>return std::move(local)</code> 会阻止 RVO，并且通常会产生多余的 move。不要在 return 语句中对返回值使用 <code>std::move</code>（C++11/14 中反模式，C++17 prvalue 语义进一步缓解）。</li></ol>
<p class="maodian"></p><h2>十二、实战建议</h2>
<p class="maodian"></p><h3>1) 表达式模板 / 延迟求值库（Eigen、std::string 复制优化）</h3>
<p>大型数学库（Eigen）使用表达式模板避免临时对象。移动语义配合表达式模板可以极大减少分配和复制。</p>
<p class="maodian"></p><h3>2) 委托内存池 + move</h3>
<p>当对象使用自定义内存池（固定内存区域）时，移动构造往往只是指针/偏移值的复制，性能几乎是常数。</p>
<p class="maodian"></p><h3>3) 多线程注意</h3>
<p>在多线程场景中移动对象时要注意竞争：移动操作不是线程安全的；在移动前应保证没有其他线程同时访问/修改该对象。</p>
<p class="maodian"></p><h3>4)std::function与 move-only 可调用对象</h3>
<p><code>std::function</code> 在 C++11 中要求可拷贝目标；若要传递 <code>unique_ptr</code> 到回调，可使用 <code>std::move</code> 包装 lambda 捕获： <code>auto cb = (){ ... };</code>。C++17/20 中有更多灵活性（<code>std::move_only_function</code> 提案/实现）。</p>
<p class="maodian"></p><h2>十三、实战注意要点</h2>
<ul><li>为管理资源的类实现移动构造/移动赋值，且声明 <code>noexcept</code>（如果安全）。</li><li>遵守 Rule of Five：若实现自定义 dtor/copy/move/assign，考虑实现完整五条或禁用不需要的。</li><li>对外部接口尽量接受 <code>T&&</code> 或模板转发参数以便移动（如 <code>push_back(T&&)</code> / <code>emplace_back</code>）。</li><li>在库/容器中使用 <code>std::move_if_noexcept</code> 或合理选择异常策略，以保证强异常安全。</li><li>避免在 <code>return</code> 中使用 <code>std::move(local)</code>（破坏 RVO）。</li><li>文档化移动后对象的状态与可调用操作（明确语义）。</li><li>在调试/性能测量时使用 Release 编译并测量实际热点（容器 reallocation、频繁返回临时等）。</li><li>在多线程中确保移动前后没有并发访问。</li><li>使用 <code>std::unique_ptr</code> 作为首选的 movable-only 智能指针（比裸指针安全）。</li></ul>
<p class="maodian"></p><h2>十四、典型示例与对比</h2>
<p>下面是一个短示例展示 <code>std::vector<Buffer></code> 在 reallocation 时如何受 <code>noexcept</code> 影响：</p>
<div class="jb51code"><pre class="brush:cpp;">#include <vector>
#include <iostream>
struct NoExceptBuffer {
NoExceptBuffer(NoExceptBuffer&&) noexcept { }
NoExceptBuffer& operator=(NoExceptBuffer&&) noexcept { return *this; }
NoExceptBuffer() = default;
};
struct MayThrowBuffer {
MayThrowBuffer(MayThrowBuffer&&) { } // NOT noexcept
MayThrowBuffer& operator=(MayThrowBuffer&&) { return *this; }
MayThrowBuffer() = default;
};
int main(){
std::vector<NoExceptBuffer> v1;
v1.reserve(100);
for(int i=0;i<100;++i) v1.emplace_back();
std::vector<MayThrowBuffer> v2;
v2.reserve(100);
for(int i=0;i<100;++i) v2.emplace_back();
std::cout<<"Done\n";
}</pre></div>
<p>在某些实现中，<code>v1</code> 在扩容时会将元素移动（更快），而 <code>v2</code> 因移动可能抛异常，会退回到拷贝（或触发更复杂安全性处理），性能差异明显。</p>
<p class="maodian"></p><h2>十五、总结</h2>
<ul><li>移动语义 允许“窃取”临时对象资源，极大减少高成本拷贝，提升性能。</li><li>右值引用 <code>T&&</code> 与 <code>std::move</code> / <code>std::forward</code> 是实现移动语义与完美转发的基础工具。</li><li>实现移动时：务必保证移动后对象处于析构/赋值安全状态，并尽量声明 <code>noexcept</code>。</li><li><strong>容器/算法</strong> 会基于可用的移动构造采取不同策略（移动优于拷贝），因此 move/<code>noexcept</code> 的设计会影响库级别性能。</li><li><strong>实践</strong>：用 <code>unique_ptr</code>、<code>emplace</code>、<code>make_move_iterator</code>、完美转发等现代 C++ 工具编写高性能、异常安全的代码。</li></ul>
<p>到此这篇关于C++ 右值引用(rvalue references)与移动语义(move semantics)深度详解的文章就介绍到这了,更多相关C++ 右值引用与移动语义内容请搜索琼殿技术社区以前的文章或继续浏览下面的相关文章希望大家以后多多支持琼殿技术社区！</p>
<div class="art_xg">
<b>您可能感兴趣的文章:</b><ul><li>从C到C++理解右值引用和移动语义的过程解析</li><li>一文带你了解C++中的右值引用与移动语义</li><li>C++11学习之右值引用和移动语义详解</li><li>C++11右值引用和移动语义的实例解析</li><li>C++左值与右值,右值引用,移动语义与完美转发详解</li><li>深入了解c++11 移动语义与右值引用</li><li>详解C++11中的右值引用与移动语义</li></ul>
</div>
</div>
<!--endmain-->
頁:
[1]