极客教程

Appearance

共 962 字预计阅读约 3 分钟

C++ 移动语义的汇编视角 ​

更新时间：2026-08-27。本文是 languages/cpp/ 主题专家层第 5 篇。前面讲移动语义都是"源码层面"，这篇下沉到汇编：std::move 编译后是什么指令？移动构造和拷贝构造差几条指令？vector 扩容时，移动真的比拷贝快吗？答案可能出乎意料：对 POD 类型，move 和 copy 的汇编一模一样——移动语义的价值只在"指针/句柄类"上体现。

本文要回答的问题 ​

  • std::move 编译成什么？它是零成本的吗？
  • 移动构造 vs 拷贝构造的汇编差在哪？
  • 为什么对 int/double 等 POD，move 和 copy 没区别？
  • noexcept 移动构造对 vector 扩容有什么影响？

std::move 的汇编：什么都不是 ​

先看最反直觉的事实：

cpp
int main() {
    int a = 42;
    int b = std::move(a);   // move 一个 int
    return b;
}

编译（g++ -O2 -S）后：

asm
main:
        mov     eax, 42      ; 常量折叠：a 和 b 都没了
        ret

std::move 编译后"什么都不做"——它只是 static_cast<int&&>(a)，一个纯编译期类型转换，不生成任何指令。move 的全部意义在于"改变后续重载决议的方向"，运行期零开销。

cpp
// 更直接的证明
template <typename T>
constexpr T&& move(T& t) noexcept {
    return static_cast<T&&>(t);
}
// 这就是 std::move 的完整实现：一条 static_cast，无运行时成本

移动 vs 拷贝：关键在"指针" ​

对值类型（int、double、普通 struct），移动和拷贝的汇编完全一样：

cpp
struct Point { int x, y; };
Point a{1, 2};

Point b = a;              // 拷贝
Point c = std::move(a);   // 移动 → 汇编与拷贝相同！

两者都是"复制 8 字节"（两个 int），编译器看不出区别。对 POD 类型，移动语义是"无感"的——移动构造函数根本不会被特殊生成。

2.1 真正的差异在"指针类" ​

cpp
#include <utility>

struct Buffer {
    int *ptr;     // 指向堆内存
    size_t size;

    // 拷贝构造：深拷贝（分配新内存 + 复制数据）
    Buffer(const Buffer& o)
        : ptr(new int[o.size]), size(o.size) {
        memcpy(ptr, o.ptr, size * sizeof(int));
    }

    // 移动构造：偷指针（只复制指针，不分配内存）
    Buffer(Buffer&& o) noexcept
        : ptr(o.ptr), size(o.size) {
        o.ptr = nullptr;   // 置空源对象
        o.size = 0;
    }
};
C++ 移动语义的汇编视角 示意图
类型拷贝构造汇编移动构造汇编差异
int / POD struct复制值复制值（无特殊移动）无
std::string深拷贝（malloc+memcpy）拷贝指针+置空移动快得多
std::vector深拷贝拷贝指针+置空移动快得多
unique_ptr删除（不可拷贝）拷贝指针+置空移动是唯一选择

vector 扩容时的移动优化 ​

vector 扩容要搬运全部元素。C++11 起，如果元素的移动构造是 noexcept，vector 扩容用移动；否则用拷贝。

cpp
#include <vector>
#include <iostream>

struct ThrowMove {
    ThrowMove() {}
    ThrowMove(ThrowMove&&) { }   // 可能抛异常（没写 noexcept）
    int data[16];
};

struct NoThrowMove {
    NoThrowMove() {}
    NoThrowMove(NoThrowMove&&) noexcept { }   // 保证不抛
    int data[16];
};

int main() {
    std::vector<ThrowMove> v1;    // 扩容：拷贝！(移动可能抛，不安全)
    std::vector<NoThrowMove> v2;  // 扩容：移动！(noexcept)
    v1.reserve(1); v1.emplace_back();
    v1.reserve(100);   // 扩容，搬运 1 个元素
    v2.reserve(1); v2.emplace_back();
    v2.reserve(100);
}

为什么？ vector 扩容时如果移动构造抛异常，新旧状态交错，无法保证强异常安全（对象可能已半移走）。noexcept 让标准库确信不会抛，才敢用移动。

工程结论：自定义类型的移动构造/移动赋值，几乎总是应该声明 noexcept。 这不只是性能优化，还影响容器正确性（vector 是否敢移动你）。

cpp
class MyClass {
public:
    MyClass(MyClass&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    // 移动后源对象必须处于"可析构、可赋值"状态
};

拷贝省略与移动的汇编关系 ​

移动和 拷贝省略 是"接力"关系：

cpp
std::vector<int> make() {
    std::vector<int> v(1000, 1);
    return v;    // 优先：拷贝省略（零指令）
                 // 其次：移动（拷贝指针）
                 // 最次：拷贝（深拷贝）
}
asm
; 开启 -O2 后，make() 的返回通常被优化为"直接构造"
; 没有 malloc 深拷贝，也没有额外 move 指令
优化级别返回局部对象汇编成本
拷贝省略直接就地构造零指令
移动复制指针 + 置空几指令
拷贝（兜底）深拷贝O(size)

noexcept 移动 + 拷贝省略 + RVO，是现代 C++ "返回大对象零成本"的三重保障。

与本站性能主线衔接 ​

  • 汇编对照：用 objdump -S 或 g++ -S 查看移动/拷贝的汇编差异，衔接 汇编与反汇编。
  • 性能剖析：热路径中的深拷贝表现为 memcpy/malloc 热点，用 perf 定位，再决定是否加 noexcept 移动。
  • 编译器优化：-O2 下的常量折叠、省略都依赖 编译选项。
  • 容器性能：vector 扩容的移动/拷贝选择直接关系 容器选型 的性能。

一句话总结 ​

std::move 编译后零指令（纯类型转换）；移动语义的价值只在指针/句柄类上体现——拷贝是 O(size) 深拷贝、移动是 O(1) 偷指针；POD 类型的 move 与 copy 汇编相同，自定义类型的移动构造务必加 noexcept，vector 扩容才敢用移动。

上一篇：C++ ABI 与 name mangling　下一篇：模板实例化机制