QuanZhou's Wiki

C++ 移动语义

~/ C/C++#C++特性#移动语义#值类别#现代C++

1. 这次拷贝,真的有必要吗?

先写一个 String

一个管理堆内存的类

下面的 String 自己持有一块堆内存,拷贝时要申请新内存,再把字符复制过去:

class String {
public:
    String(const char* s = "")
        : size_(std::strlen(s)), data_(new char[size_ + 1]) {
        std::memcpy(data_, s, size_ + 1);
    }

    ~String() { delete[] data_; }

    String(const String& other)
        : size_(other.size_), data_(new char[size_ + 1]) {
        std::memcpy(data_, other.data_, size_ + 1);
        std::puts("  copy");
    }

    std::size_t size() const { return size_; }
    const char* data() const { return data_; }

private:
    std::size_t size_;
    char* data_;
};

拷贝的成本和字符串长度成正比,还多一次堆分配。这在下面的情况里完全是浪费:

std::vector<String> names;
names.push_back(String("a very long name"));

String("a very long name") 是临时对象,这一行结束就销毁。push_back 却把它的内容完整复制了一份,然后原来那份立刻被释放。

既然来源马上就没用了,为什么不直接把 data_ 指针拿过来?只需要复制一个指针和一个长度,不分配,也不复制字符。这种把资源从来源拿走、而不是复制一份的操作,就是移动。下文说的“偷”都是这个意思。

难点在判断来源

同样是初始化,能不能偷取决于来源

String a("hello");
String b = a;               // a 之后还要用,不能偷
String c = String("hello"); // 来源是临时对象,可以偷

所以语言需要回答两个问题:编译器选择重载时,怎样区分这两种来源?如果程序员明确不再使用 a,怎样主动允许偷?

第一个问题的答案是值类别和右值引用,第二个问题的答案是 std::move。接下来的内容都建立在这两点上。

示例约定

全文以 C++20 为基线,有版本差异的地方会标出。String 只为讲解所写,真实项目应使用 std::string;示例省略了 <cstdio>、<cstring>、<utility>、<vector>、<memory>、<string>、<type_traits>、<concepts> 等头文件。

代码注释里的 copy、move 是 String 打印的内容。文中的输出、编译错误和链接错误都在 Apple clang 21 与 GCC 16(-std=c++20)上核对过,两者只有 sizeof(std::string) 不同,第 7 节会写明。输出来自默认优化级别,打印语句本身不影响选中的重载。第 6 节的测量另行说明环境。

这是现代 C++ 长期学习计划中的一篇。如果对 decltype 和转发引用的推导还不熟,可以先读类型推导文章的第 4 节。

2. 值类别:编译器怎样知道能偷?

三种值类别

值类别属于表达式

编译器判断来源,靠的是表达式的值类别。粗略地说,左值是之后还能继续使用的对象,比如变量 a;右值是用完就没的临时结果,比如 String("hello")。String&& 叫右值引用,专门绑定右值。

先看一个容易想错的例子:

void take(String&& s) {
    String copy = s; // 这里是拷贝,不是移动
}

s 的声明类型是 String&&,但选哪个构造函数要看表达式 s 的值类别。表达式 s 指代一个已经确定的对象,所以是左值。声明类型和值类别是两件事:值类别属于每个表达式,不会保存在变量里。

这个设计是有意的:进入函数后你可能多次使用 s,如果语言自动把它当右值,第一次使用就可能把它搬空。右值引用只表示调用方允许你移动,真正移动要自己写出来。

“有名字就是左值”不够准确

这句话好用,但两个方向都有例外:枚举项 Red 和非类型模板参数 N 有名字,却是纯右值;*p、v[0]、"hello" 没有名字,却是左值。

准确的分类看两件事:表达式是否指向一个具体的对象(术语叫标识对象),以及这个对象的资源是否可以被拿走(术语叫可移动)。两个问题的答案组合出三种类别:

  • 左值:指向一个具体对象,调用方之后还可能使用它,资源不能拿走。
  • 将亡值:同样指向一个具体对象,但代码已经表明它的资源可以拿走。
  • 纯右值:只是一个值,或者一个待创建的对象,还没有对应到具体对象。
类别指向具体对象?资源能拿走?例子
lvalue,左值是否x、*p、v[0]、++x、"hello"、返回 int& 的函数调用
xvalue,将亡值是是std::move(x)、static_cast<int&&>(x)、返回 int&& 的函数调用、S{}.m
prvalue,纯右值否是7、x + 1、x++、nullptr、Red、std::string("a")、返回 int 的函数调用

左值和将亡值合称 glvalue,它们标识对象。将亡值和纯右值合称 rvalue,它们可以被移动。“将亡”不代表对象快销毁了,std::move(x) 之后 x 还活着,它只表示这里可以把资源拿走。标准定义见 [basic.lval]。

让编译器判断

decltype 加双层括号会把值类别写进类型:左值得到 T&,将亡值得到 T&&,纯右值得到 T。

template<class T> struct category      { static constexpr auto v = "prvalue"; };
template<class T> struct category<T&>  { static constexpr auto v = "lvalue";  };
template<class T> struct category<T&&> { static constexpr auto v = "xvalue";  };

#define CATEGORY(e) std::printf("%-14s %s\n", #e, category<decltype((e))>::v)

int x = 1;
int&& named = 2;
CATEGORY(named);        // lvalue
CATEGORY(std::move(x)); // xvalue
CATEGORY(x++);          // prvalue

表格里的每个例子都这样跑过一遍。

引用绑定决定了重载

右值引用让重载能区分来源

以 String 为例,下表回答一个问题:某种实参能不能传给某种引用参数。“优先”表示几个重载都能接时选它。

实参参数是 String&参数是 const String&参数是 String&&
非 const 左值可以,优先可以不可以
const 左值不可以可以不可以
右值不可以可以可以,优先

这张表是整篇文章的基础:const String& 什么都能接,String&& 只接右值,而且右值优先选它。于是拷贝构造函数和移动构造函数可以共存,由来源决定走哪条路。

这里有个问题:纯右值没有对应的具体对象,比如 const String& r = String("a");,引用绑定的是什么?答案是临时量实质化(temporary materialization):编译器先用纯右值创建一个临时对象,引用再绑定到这个对象上,表达式也随之变成将亡值。规则见 [conv.rval]。

3. 移动构造:把资源拿走

给 String 加上移动

移动构造函数

String(String&& other) noexcept
    : size_(other.size_), data_(other.data_) {
    other.size_ = 0;
    other.data_ = nullptr;
    std::puts("  move");
}

这里做两件事:拿走指针,再把来源置空。第二步不能省,否则两个对象指向同一块内存,析构时会重复释放。置空后 delete[] nullptr 是安全的空操作。

String a("hello");
String b = a;            //   copy
String c = std::move(a); //   move
a.size();                // 0

noexcept 不是装饰,第 6 节会看到它决定了 vector 能不能走这条路。

移动赋值

赋值和构造不同,目标对象已经持有资源,要先释放。用临时对象加 swap 可以一次解决释放和自赋值:

void swap(String& other) noexcept {
    std::swap(size_, other.size_);
    std::swap(data_, other.data_);
}

String& operator=(const String& other) {
    String tmp(other);
    swap(tmp);
    return *this;
}

String& operator=(String&& other) noexcept {
    String tmp(std::move(other));
    swap(tmp);
    return *this;
}

旧资源换进 tmp,离开作用域时释放。t = std::move(t) 这样的自移动也安全:tmp 先拿走资源,swap 再换回来,结果 t 不变。

被移动后的对象

我们的 String 还不够有效

被移动的对象没有销毁,之后还会析构,也可能继续使用,所以它必须保持有效。现在的 String 只保证析构安全,再拷贝一次就出问题:

String x("hello");
String y = std::move(x);
String z = x; // ASAN 报告 SEGV

第 1 节的拷贝构造函数默认 data_ 非空,而移动构造函数打破了这个前提,memcpy 从空指针读取。类的不变式是对象始终要满足的条件。加入移动后,不变式从“data_ 非空”变成了“data_ 可以为空”,所有读取它的地方都要重新检查。

String(const String& other)
    : size_(other.size_), data_(other.data_ ? new char[size_ + 1] : nullptr) {
    if (data_) std::memcpy(data_, other.data_, size_ + 1);
    std::puts("  copy");
}

const char* data() const { return data_ ? data_ : ""; }

不在移动时重新分配一个空字符串,是因为分配可能抛异常,移动构造函数就不能标记 noexcept 了。修改后,上面的代码和对 x 重新赋值都能通过 ASAN 与 UBSan。

有效但未指定

标准库类型的约定是“有效但未指定”:对象可以销毁、可以重新赋值,也可以调用对当前状态没有要求的函数,比如 size(),但不能假设它里面是什么内容。

std::string s(100, 'a');
std::string t = std::move(s);

// s.front();   // 不可以:front 要求非空,而 s 可能为空
s.clear();      // 可以
s = "reused";   // 可以,重新赋值后正常使用

实测这里 s.size() 是 0,但这不是标准保证,代码不应依赖它。

编译器什么时候帮你生成?

声明一个函数,移动可能就没了

很多类不需要手写移动。String 这样的成员已经会移动,外层类默认就能逐成员移动:

struct WithDefault {
    String s;
};
struct WithDtor {
    String s;
    ~WithDtor() {}
};

WithDefault a;
WithDefault b = std::move(a); //   move

WithDtor c;
WithDtor d = std::move(c);    //   copy

只是多写了一个空析构函数,std::move 就退化成了拷贝,而且没有任何编译错误。因为声明析构函数后,编译器不再生成移动操作,右值只能绑定到拷贝构造函数的 const 引用上。

这条规则涉及五个特殊成员函数:析构函数、拷贝构造、拷贝赋值、移动构造和移动赋值。下表按“你手写了哪一个”,列出编译器还会不会替你生成其余的函数。“已弃用”指现在仍会生成,但标准不建议依赖这种行为。

你手写了还生成移动操作吗还生成拷贝操作吗实际影响
五个都没写生成生成拷贝和移动都能用
析构函数不生成生成,已弃用std::move 悄悄退化成拷贝
拷贝构造或拷贝赋值不生成另一个生成,已弃用std::move 悄悄退化成拷贝
移动构造或移动赋值另一个不生成不生成,拷贝被删除拷贝时编译错误,没写的那个移动操作也不能用

因此有两个常用原则:能不写就都不写(Rule of Zero),由 std::string、std::vector、std::unique_ptr 这样的成员管理资源;写了其中一个,就把五个都写清楚(Rule of Five),需要默认行为时用 = default。

最后一行也解释了 std::unique_ptr 的只移动特性:声明移动构造后,拷贝被删除。规则见 [class.copy.ctor] 和 [class.copy.assign]。

4. std::move:它什么都没移动

只是一次转换

看实现就明白了

std::move 的核心是一行 static_cast:

template<class T>
constexpr std::remove_reference_t<T>&& move(T&& t) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(t);
}

这里的 T&& 能同时接收左值和右值,原理留到第 8 节,现在只需知道它什么都能接。不管传入什么,返回的都是右值引用。它运行时不做任何事,真正搬动资源的是后面选中的移动构造函数。更准确的名字应该是 rvalue_cast。

移动成员时最常漏的一步

struct Bad {
    String s;
    Bad(String&& v) : s(v) {}
};

struct Good {
    String s;
    Good(String&& v) : s(std::move(v)) {}
};

Bad b(String("x"));  //   copy
Good g(String("x")); //   move

v 的类型是 String&&,但表达式 v 是左值,所以 Bad 走的是拷贝。这是第 2 节那条规则最常见的后果。

std::move 救不了 const

std::vector<std::string> v;
const std::string s = "hello";
v.push_back(std::move(s)); // 实际发生拷贝

std::move(s) 的类型是 const std::string&&。移动构造函数要的是非 const 的 std::string&&,接不住,于是匹配到 const std::string&。std::move 不会去掉 const,编译也不报错。

所以想要移动的变量不要声明成 const。

5. 返回值:大多数时候不用写 move

编译器比你想的更省

三层优化

把 String 从函数返回,实测结果如下:

函数里的写法实际发生为什么
return String("x");不拷贝也不移动对象直接建在调用方接收结果的位置,C++17 起保证
String s("x"); return s;不拷贝也不移动NRVO:局部变量 s 直接建在返回位置,允许但不保证
if (b) return x; return y;,x、y 是局部变量move运行时才知道返回哪个,没法提前把两者都建在返回位置
参数 String s,return s;move参数由调用方构造,没法建在返回位置
return std::move(s);move手动转换后不再是变量名,NRVO 失效
return b ? x : y;copy这是条件表达式,不是“返回变量名”,不触发自动移动

第一行是保证的复制消除:从 C++17 起,纯右值不再创建中间对象,而是直接初始化最终目标,即使类型不可移动也能编译。

第二行是 NRVO:编译器把局部变量 s 直接构造在返回值的位置。它是允许的优化,但不保证发生。

第三、四行是后备方案:对象省略不掉时,return 局部变量名 会先把变量当作右值来选构造函数。所以返回局部变量最差也是移动,不需要自己写 std::move。

return std::move 反而更差

String make() {
    String s("hello");
    return std::move(s); //   move
}

return 后面不再是局部变量名,而是一个表达式,NRVO 的条件不成立,省掉的那次构造变成了一次移动。clang 和 GCC 都会用 -Wpessimizing-move 警告这一行。

什么时候才需要显式写?

自动按右值返回只覆盖 return 后面直接写名字的情况,下面这些要单独判断:

函数return 这样写原因
按值返回右值引用参数:String f(String&& s)return s;C++20 起自动 move,不必写 std::move
返回右值引用:String&& f(String&& s)return std::move(s);只写 return s; 编译不过,s 是左值,不能绑定到返回类型 String&&
返回局部对象的成员 h.mreturn std::move(h.m);只写 return h.m; 是 copy,h.m 不是局部变量名
按值返回转发引用参数(第 8 节介绍):template<class T> String f(T&& x)return std::forward<T>(x);C++20 起只写 return x; 结果相同(右值实参 move,左值实参 copy),写 forward 是为了表明意图

第一行和最后一行都依赖 C++20 把右值引用参数纳入自动移动。-std=c++17 下 GCC 16 对这两行的右值实参执行 copy,Apple clang 21 仍是 move,所以需要兼容旧标准的代码要显式写 std::move 或 std::forward。

6. noexcept:vector 敢不敢移动

同样有移动构造,结果不同

扩容实验

vector 容量不足时要申请新内存,把旧元素搬过去,下文称为搬迁。下面三个类型都有移动构造函数,只差在 noexcept 和拷贝构造函数,看看搬迁时走哪条路:

struct NoexceptMove {
    NoexceptMove() = default;
    NoexceptMove(const NoexceptMove&) { std::puts("copy"); }
    NoexceptMove(NoexceptMove&&) noexcept { std::puts("move"); }
};

struct ThrowingMove {
    ThrowingMove() = default;
    ThrowingMove(const ThrowingMove&) { std::puts("copy"); }
    ThrowingMove(ThrowingMove&&) { std::puts("move"); }
};

struct MoveOnly {
    MoveOnly() = default;
    MoveOnly(const MoveOnly&) = delete;
    MoveOnly(MoveOnly&&) { std::puts("move"); }
};

template<class T>
void grow() {
    std::vector<T> v;
    v.reserve(2);
    v.emplace_back();
    v.emplace_back();
    v.emplace_back(); // 容量不足,搬迁旧的两个元素
}

分别调用 grow<T>(),第三次 emplace_back 搬迁两个旧元素时的输出如下:

调用搬迁第 1 个旧元素搬迁第 2 个旧元素
grow<NoexceptMove>()movemove
grow<ThrowingMove>()copycopy
grow<MoveOnly>()movemove

为什么不加 noexcept 会退化成拷贝?

push_back 有强异常保证:如果扩容失败,vector 保持原样。

用拷贝搬迁时,新内存里某个元素抛异常,旧元素完好无损,释放新内存就能回滚。用移动搬迁时,移动到一半抛异常,部分旧元素已经被搬空,移动回去也可能再抛异常,回滚不了。

所以 vector 用 std::move_if_noexcept 判断:移动构造是 noexcept 才移动,否则宁可拷贝。没有拷贝构造可用时,比如 MoveOnly,只能移动,这时放弃强保证。

如果 String 的移动构造忘了写 noexcept,一个大 vector<String> 每次扩容都会深拷贝所有字符串,功能完全正常,只有性能悄悄变差。

测一下差多少

用一个 37 字符的字符串类型,构造函数和拷贝都走堆分配,只切换移动构造的 noexcept,然后向空 vector 插入 100 万个元素:

移动构造搬迁时 copy搬迁时 move字符串堆分配次数耗时
noexcept01048575100000015–17 ms
不加 noexcept10485750204857533–36 ms

测量环境是 Apple M5 Pro,-O2,耗时取 7 次中的最小值,区间的两端分别来自 GCC 16 和 Apple clang 21,包含构造、扩容和析构全过程。

次数在两个编译器上完全相同:vector 容量逐次翻倍,搬迁总数是 2^20 - 1,平均每个元素被搬迁约一次。不加 noexcept 时,每次搬迁都多一次堆分配,所以分配次数翻倍,这是确定的结果。耗时差约 2 倍只代表这台机器和这个字符串长度,不能直接推广到其他元素大小。

什么时候写 noexcept?

移动构造、移动赋值和 swap 通常只交换指针,确实不会抛异常,应当标记。用 = default 时编译器会根据成员自动判断。可以用 static_assert 守住这件事:

static_assert(std::is_nothrow_move_constructible_v<String>);

7. 移动并不总是更快

移动的收益来自间接持有

短字符串没有指针可偷

移动之所以快,是因为资源放在对象外面,只要转移指针。如果数据就在对象内部,移动也得逐字节复制。

std::string 的短字符串优化(SSO)把短内容直接存在对象里:

std::string s1(5, 'a');
auto p1 = s1.data();
std::string s2 = std::move(s1);
p1 == s2.data(); // false,内容被复制到 s2 内部

std::string l1(100, 'a');
auto p2 = l1.data();
std::string l2 = std::move(l1);
p2 == l2.data(); // true,堆内存指针被转移

这两组比较在 libc++(sizeof(std::string) 为 24)和 libstdc++(为 32)上结果相同。其他类型也可以这样判断:

类型移动时实际做什么比拷贝省多少
内置类型、成员全是 int 和 double 的结构体按成员复制不省
std::array<String, N>元素就在对象内部,要逐个移动 N 个元素省掉元素的堆分配,但耗时仍随 N 增长
短字符串字符存在对象内部,只能复制过去基本不省
std::vector、长 std::string只转移指向堆内存的指针最省,耗时与元素数量无关
移动构造没有标记 noexcept 的类型vector 扩容时改用拷贝这个场景下不省

所以全是整数和 double 的结构体,加移动构造没有意义。写通用模板时,也不能假设移动一定便宜。

8. 完美转发:让右值穿过包装函数

多包一层,移动就没了

信息在哪一步丢的

移动依赖实参的值类别,但实参一旦进入函数,变成有名字的参数,就是左值了。看这三个重载:

void sink(const String&) { std::puts("sink(const String&)"); }
void sink(String&)       { std::puts("sink(String&)"); }
void sink(String&&)      { std::puts("sink(String&&)"); }

现在想包一层加日志,比如写一个 wrap,先打印再调用 sink。目标是:实参经过 wrap 后调到的 sink,要和直接调用时完全相同。先记下直接调用的结果,作为标准答案:

String a("a");
const String c("c");

sink(a);           // sink(String&)
sink(c);           // sink(const String&)
sink(String("t")); // sink(String&&)

下面依次试四种写法,都传这三个实参,注释里是实际调到的重载。

写法一:按值接收。

template<class T>
void wrap(T x) { sink(x); }

wrap(a);           // 先 copy 一次,再 sink(String&)
wrap(c);           // 先 copy 一次,再 sink(String&)
wrap(String("t")); // sink(String&)

x 是 wrap 自己的新对象,所以左值实参会多一次 copy,const 也丢了。右值实参同样落到 sink(String&),因为 x 有名字,是左值。三行全错。

写法二:const T&。

template<class T>
void wrap(const T& x) { sink(x); }

wrap(a);           // sink(const String&)
wrap(c);           // sink(const String&)
wrap(String("t")); // sink(const String&)

没有多余的 copy,但所有实参都变成了 const,只有第二行是对的。

写法三:T&&,内部直接传 x。

template<class T>
void wrap(T&& x) { sink(x); }

wrap(a);           // sink(String&)
wrap(c);           // sink(const String&)
wrap(String("t")); // sink(String&)

前两行对了,第三行仍然错:x 有名字,是左值,所以右值实参没能走到 sink(String&&)。

写法四:T&&,内部用 std::forward。

template<class T>
void wrap(T&& x) { sink(std::forward<T>(x)); }

wrap(a);           // sink(String&)
wrap(c);           // sink(const String&)
wrap(String("t")); // sink(String&&)

只有写法四的三行都和标准答案一致。为每个参数分别写左值和右值版本也行,但 n 个参数至少要 2^n 个重载。

T 记住了实参

转发引用的推导

函数模板的 T&&,且 T 由这次调用推导,这样的参数叫转发引用(forwarding reference),《Effective Modern C++》称为万能引用。它的推导规则是专门设计的([temp.deduct.call]/3):实参是左值时,T 推导成左值引用;实参是右值时,T 不带引用。

以 template<class T> void wrap(T&& x) 为例,三种实参的推导过程如下:

传给 wrap 的实参推导出的 T代入 T&&折叠后 x 的类型
左值 aString&String& &&String&
const 左值 cconst String&const String& &&const String&
右值StringString&&String&&

String& && 不能手写,但模板代入时会产生,这时按引用折叠处理:只要出现一个 &,结果就是 &;两层都是 &&,结果才是 &&。

注意最后一行:右值实参推导出的 T 是 String,不是 String&&,带 && 的是 x 的类型。

推导只看实参表达式的值类别,不看变量的声明类型:

String&& r = String("t");

wrap(r);            // r 是左值:T = String&
wrap(std::move(r)); // 实参是右值:T = String

在 wrap 内部,表达式 x 永远是左值,只有 T 还记得实参原本的值类别,后面的 std::forward 就靠它恢复信息。

哪些 T&& 才是转发引用

要成为转发引用,形式必须正好是 T&&(或 auto&&),而且 T 由这次初始化推导。下面三种都只是右值引用,详见类型推导文章:

  • std::vector<T>&&:形式不是单独的 T&&。
  • const T&&:多了 const。
  • 类模板成员 void put(T&&):T 在类实例化时已经确定,调用 put 时不再推导。

forward 恢复信息

std::forward 把信息取出来

// 简化版,只保留 wrap 里用到的重载
template<class T>
constexpr T&& forward(std::remove_reference_t<T>& t) noexcept {
    return static_cast<T&&>(t);
}

template<class T>
void wrap(T&& x) {
    sink(std::forward<T>(x)); // T 由 wrap 推导,再手动传给 forward
}

沿着调用链看,forward 收到的 x 始终是左值,结果的差别完全来自 T:

传给 wrap 的实参wrap 推导出的 T传给 forward 的 xforward 返回类型sink 收到
左值String&左值String&左值
右值String左值String&&将亡值

代入 T 后,就是两个普通函数,它们的参数相同,只有返回类型不同:

// 实参是左值,T = String&
String& forward(String& t) { return static_cast<String&>(t); }

// 实参是右值,T = String
String&& forward(String& t) { return static_cast<String&&>(t); }

原始实参是左值时什么都不改变,是右值时才转成右值,这就是有条件的 move。结果只由 T 决定,和 x 绑定到什么对象无关。

为什么不能省略 <T>

std::forward(x) 无法通过编译,这是有意的设计。x 在 wrap 内部永远是左值,实参原本是左值还是右值,只记录在 wrap 的 T 里。forward 无法从 x 得知这一点,所以 T 必须由你写在尖括号里传给它。

参数类型 remove_reference_t<T>& 同时保证了两件事:

  • 漏写 <T> 会编译报错:编译器不会从 remove_reference_t<T> 倒推 T。这个结果是 String 时,T 可能是 String、String& 或 String&&,无法确定。标准把这种情况称为不可推导语境。
  • 总能接收 x:T 是 String& 或 String 时,去掉引用再加 &,参数都是 String&,正好能绑定左值 x。

如果参数写成普通的 T&,漏写 <T> 也能编译:forward(x) 推导出 T = String,返回 String&&,左值实参也被转成右值,资源可能被悄悄拿走。现在的写法把这个隐蔽的 bug 变成了编译错误。

完整的 std::forward 还有一个接收右值的重载,只在括号里直接写右值表达式时用到,比如 std::forward<String>(make()),wrap 里用不到。它用 static_assert 拒绝把右值转成左值引用,规范见 [forward]。

std::move 和 std::forward 怎么选

std::move(x)std::forward<T>(x)
做什么总是转成右值实参原本是右值才转成右值,原本是左值就保持左值
什么时候用参数是 String&& 这样的右值引用,或对象之后不再使用参数是转发引用,要原样交给下一层
运行时成本没有,只是类型转换没有,只是类型转换

在转发引用上写 std::move 是危险的错误:调用方传的是普通左值,没有表达“可以拿走”,资源却被偷走了。

真正的包装

自己实现 make_unique

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

std::forward<Args>(args)... 展开后,每个参数各用自己的类型,因此不同参数可以各自是左值、右值或 const。std::vector::emplace_back 结构相同,所以 v.emplace_back(3, 'x') 能在容器内原地构造出 "xxx"。

泛型 lambda 的 auto&& 没有可写的 T,这时用 decltype 取回;C++20 也可以直接写模板参数:

auto l1 = [](auto&& x) { sink(std::forward<decltype(x)>(x)); };
auto l2 = []<class T>(T&& x) { sink(std::forward<T>(x)); };

包装函数还要原样交出返回值。返回类型写 auto 会丢掉引用,写 decltype(auto) 才能保留:

template<class F, class... A>
decltype(auto) call(F&& f, A&&... a) {
    return std::forward<F>(f)(std::forward<A>(a)...);
}

转发的三个陷阱

用错转发时会发生什么

同一参数只转发一次。第二次拿到的可能是被搬空的对象。需要多次使用时,只在最后一次写 forward。

template<class T>
void twice(T&& x) {
    String a(std::forward<T>(x));
    String b(std::forward<T>(x)); // 右值时,x 已被搬空
}

转发不延长生命周期。forward 返回的是引用,下面的临时字符串在这一行结束时销毁,r 随之悬空。GCC 16 在 -Wextra 下给出 -Wdangling-reference 警告,clang 没有报告,所以不能依赖编译器。

template<class T>
T&& id(T&& x) { return std::forward<T>(x); }

auto&& r = id(std::string("temp"));

转发引用会抢走重载。它几乎能精确匹配任何实参:

struct Person {
    std::string name;

    template<class T>
    explicit Person(T&& n) : name(std::forward<T>(n)) {}

    Person(const Person&) = default;
};

Person p("Alice");
Person q(p); // 编译错误

p 是非 const 左值,模板生成的 Person(Person&) 比 const Person& 更精确,于是尝试用 Person 初始化 std::string。把 p 改成 const Person 反而能编译,因为两者同样精确时非模板优先。

C++20 用约束说明模板能处理什么:

template<class T>
    requires std::constructible_from<std::string, T>
explicit Person(T&& n) : name(std::forward<T>(n)) {}

T = Person& 不满足约束,模板退出候选,Person q(p) 选中拷贝构造函数。

转发不过去的实参

直接调用可以,包一层就不行

直接调用时,编译器知道目标函数的参数类型,可以据此转换实参。经过转发函数时,编译器只能先看实参本身来推导类型,目标函数的参数类型帮不上忙,这一步推不出或推错,后面就失败了。下表用 template<class... A> void fwd(A&&... a) 把实参转发给目标函数:

传给 fwd 的实参结果为什么怎么改
{1, 2, 3}编译错误花括号本身没有类型,推不出 Astd::vector<int>{1, 2, 3}
用 0 或 NULL 表示空指针编译错误被推导成整数,转发时已是整数变量,不能再转成指针nullptr
有多个重载的函数名 cb编译错误同名函数有多个,不知道该选哪个static_cast<int(*)(int)>(cb)
函数模板名 tf编译错误模板不是具体函数,没有确定的类型tf<int>
位域 b.a编译错误位域可能不占完整字节,非 const 引用不能绑定到它先复制成普通变量
只声明、没有定义的 static const int 成员-O0 下链接失败绑定引用需要对象的地址,但这个成员没有定义C++17 起写 static constexpr 或 inline static

最后一行特别隐蔽:实测 -O2 下值被优化掉,又能链接通过。《Effective Modern C++》基于 C++14,所以书里需要手写类外定义。

9. 参数到底怎么写?

一个默认选择

按函数对参数做什么来选

函数要对参数做什么参数这样写代价
只读取,函数返回后不再保留const T&,字符串用 std::string_view只传引用,不拷贝
一定要留一份,比如存进成员按值接收,再 std::move 进成员传左值:一次拷贝加一次移动;传临时对象:一次移动;传 std::move(x):两次移动
接管对象的所有权Widget&&,或按值接收 std::unique_ptr<T>只有移动,调用方必须写 std::move,所有权转移一眼可见
只是转交给别的函数,不知道最终类型转发引用加 std::forward没有额外拷贝,但代码要放头文件,模板实例增多,报错更长

第二行是最常见的写法:

class Person {
public:
    explicit Person(std::string name) : name_(std::move(name)) {}

private:
    std::string name_;
};

只写一个构造函数,左值和右值都能接:调用方传左值时,拷贝发生在构造参数 name 时;传右值时全程只有移动。

判断转发是否值得,只问一句:这个函数是否只是中转参数,并且不知道最终目标的类型? 否则普通重载或按值传参通常更好。

读代码时问三个问题

看到一段对象传递的代码,想知道到底有没有移动,依次问:

  • 这个表达式是左值还是右值?
  • 它选中了哪个重载?
  • 选中的函数真的转移了资源吗?

全文的现象都能这样解释:String&& 参数是左值,所以走拷贝;const 右值接不住移动构造,所以走拷贝;短字符串走了移动构造,但没有指针可转移。

10. 检验:先判断,再展开答案

说出结果和理由

每题写下选中的函数

回答时不要只给结果,要说出表达式的值类别和选中的重载。

Quiz 1:String&& r = String("a"); String s = r; 发生拷贝还是移动?

拷贝。r 的声明类型是 String&&,但表达式 r 是左值。要移动,写 String s = std::move(r);。

Quiz 2:x++ 和 ++x 分别是什么值类别?怎样用编译器验证?

x++ 是纯右值,返回旧值的副本。++x 是左值,返回 x 本身。

decltype((x++)) 得到 int,decltype((++x)) 得到 int&。

Quiz 3:一个类只多写了 ~Widget() {},Widget b = std::move(a); 走哪个函数?

拷贝构造函数。声明析构函数后不再隐式生成移动操作,右值只能绑定到拷贝构造函数的 const 引用上,而且没有编译错误。需要移动时要把五个特殊成员函数都声明出来。只补 Widget(Widget&&) = default; 会让隐式拷贝操作被删除,移动赋值也不会生成。

Quiz 4(面试题):const std::string s = "a"; std::string t = std::move(s); 发生了什么?

拷贝。std::move(s) 的类型是 const std::string&&,移动构造函数绑定不了 const 对象,于是匹配到 const std::string&。std::move 不会去掉 const。

Quiz 5(面试题):函数里写 return std::move(local); 好不好?

不好。这样 return 后面不再是局部变量名,NRVO 失效,本来可以省略的构造变成一次移动。直接写 return local;,不能省略时编译器也会自动按右值返回。

Quiz 6(面试题):为什么移动构造不加 noexcept,vector 扩容会退化成拷贝?

vector 扩容要提供强异常保证。移动到一半抛异常时,部分旧元素已被搬空,无法回滚。所以它用 move_if_noexcept:移动是 noexcept 才移动,否则用拷贝。如果类型不可拷贝,就只能移动,放弃强保证。

Quiz 7(面试题):std::move 和 std::forward 有什么区别?运行时做什么?

std::move 无条件转成右值。std::forward<T> 按 T 有条件转换:T 是左值引用时保持左值,否则转成右值,用在转发引用上。

两者都只是 static_cast,运行时不做任何事。是否真的发生移动,取决于后面选中的函数。

Quiz 8(面试题):template<class T> void f(T&& v) { log(std::forward<T>(v)); store(std::forward<T>(v)); } 有什么问题?

转发了两次。实参是右值时,log 可能已经把 v 搬空,store 拿到的是被移动过的对象。只在最后一次使用处转发:log(v); store(std::forward<T>(v));。

延伸阅读

C++20 标准条款

书籍

  • 《Effective Modern C++》条款 23–30:条款 23 对应第 4 节,条款 24、28 对应转发引用,条款 25 对应第 4、5 节,条款 26–27 对应构造函数劫持,条款 29 对应第 7 节,条款 30 对应转发失败。书以 C++14 为背景,保证的复制消除、C++20 的自动移动和 static const 成员这三处已有变化。