保证拷贝消除(Guaranteed Copy Elision) ​

什么是保证拷贝消除 ​

C++17 通过重新定义纯右值(prvalue)的语义,从语言层面保证了在特定场景下不会发生拷贝或移动操作。这个特性的正式名称是"通过简化值类别实现的保证拷贝消除"(Guaranteed copy elision through simplified value categories)。

在 C++17 之前,编译器在某些场景下可以选择性地省略拷贝/移动操作(称为"拷贝消除"或"返回值优化 RVO"),但这只是一种允许的优化,不是保证。即使编译器实际上消除了拷贝,代码中对应的拷贝/移动构造函数仍然必须存在且可访问——否则编译报错。

C++17 从根本上改变了纯右值的定义:纯右值不再是"临时对象",而是"可以初始化对象的东西"。纯右值只有在真正需要时才会"实体化"(materialize)为一个临时对象。如果纯右值直接用来初始化同类型的对象,根本不会创建临时对象,也就根本不需要拷贝/移动构造函数。

编译期行为解释 ​

C++17 之前的模型:T x = T(); 的语义是"创建一个 T 类型的临时对象,然后用这个临时对象拷贝/移动初始化 x"。编译器可以优化掉这个拷贝/移动,但 T 必须有可用的拷贝或移动构造函数。

C++17 的模型:T x = T(); 的语义是"用 T() 这个纯右值直接初始化 x"。纯右值 T() 不是一个临时对象,它是一个"初始化器"。只有当纯右值绑定到引用或者在其他需要实体化的场景下才会创建临时对象。所以 T 不需要有拷贝或移动构造函数。

这意味着:

  • return T(); 中,T() 直接初始化函数的返回值,没有临时对象
  • T x = factory(); 中,factory() 的返回值(纯右值)直接初始化 x,没有中间的拷贝/移动
  • 即使 T 的拷贝和移动构造函数都被 delete 了,上述代码也能编译通过

需要注意:这个保证只适用于纯右值(prvalue),不适用于具名的局部变量。return local_var; 中的 local_var 是左值,不是纯右值,所以命名返回值优化(NRVO)仍然不是强制的。

基本示例 ​

cpp
#include <iostream>
#include <string>

// ============================
// 示例1:不可拷贝不可移动的类型也能按值返回
// ============================

struct NonMovable {
    int value;

    NonMovable(int v) : value(v) {
        std::cout << "构造 NonMovable(" << v << ")" << std::endl;
    }

    // 拷贝和移动都被删除了
    NonMovable(const NonMovable&) = delete;
    NonMovable(NonMovable&&) = delete;

    ~NonMovable() {
        std::cout << "析构 NonMovable(" << value << ")" << std::endl;
    }
};

// C++17 之前:编译错误,因为按值返回需要可用的拷贝/移动构造函数
// C++17:完全合法,因为返回的纯右值直接初始化调用方的对象
NonMovable create_nonmovable() {
    return NonMovable(42);  // 纯右值,直接初始化返回值
}

// ============================
// 示例2:工厂函数链式调用
// ============================

struct Widget {
    std::string name;

    Widget(std::string n) : name(std::move(n)) {
        std::cout << "构造 Widget: " << name << std::endl;
    }

    Widget(const Widget&) {
        std::cout << "拷贝 Widget" << std::endl;
    }

    Widget(Widget&&) {
        std::cout << "移动 Widget" << std::endl;
    }
};

Widget make_widget() {
    return Widget("from factory");
    // C++17: 不会调用移动构造函数,直接在目标位置构造
}

Widget wrap_widget() {
    return make_widget();
    // C++17: make_widget() 返回纯右值,直接传递给 wrap_widget 的返回值
    // 整个链条中只有一次构造
}

// ============================
// 示例3:纯右值 vs 具名变量
// ============================

struct Tracker {
    Tracker() { std::cout << "默认构造" << std::endl; }
    Tracker(const Tracker&) { std::cout << "拷贝构造" << std::endl; }
    Tracker(Tracker&&) { std::cout << "移动构造" << std::endl; }
};

// 返回纯右值:C++17 保证不拷贝不移动
Tracker return_prvalue() {
    return Tracker();  // 纯右值
}

// 返回具名变量:NRVO 可能发生但不保证
Tracker return_named() {
    Tracker t;
    return t;  // 具名变量(左值),NRVO 不是强制的
    // 但大多数编译器在优化模式下仍然会消除拷贝
}

// ============================
// 示例4:初始化场景
// ============================

void initialization_demo() {
    // 以下所有情况在 C++17 中都保证不产生额外的拷贝/移动

    // 直接初始化
    Tracker t1(Tracker());        // 纯右值直接初始化 t1

    // 拷贝初始化(虽然语法上有 =,但不产生拷贝)
    Tracker t2 = Tracker();       // 纯右值直接初始化 t2

    // 从函数返回值初始化
    Tracker t3 = return_prvalue(); // 纯右值直接初始化 t3

    // new 表达式
    Tracker* t4 = new Tracker(return_prvalue()); // 纯右值直接初始化堆上的对象
    delete t4;
}

int main() {
    std::cout << "=== 不可移动类型 ===" << std::endl;
    NonMovable nm = create_nonmovable();
    std::cout << "值: " << nm.value << std::endl;

    std::cout << "\n=== 工厂链式调用 ===" << std::endl;
    Widget w = wrap_widget();
    // 只输出一次 "构造 Widget",没有移动或拷贝

    std::cout << "\n=== 纯右值 vs 具名变量 ===" << std::endl;
    std::cout << "纯右值返回:" << std::endl;
    Tracker t1 = return_prvalue();  // 只有默认构造

    std::cout << "具名变量返回:" << std::endl;
    Tracker t2 = return_named();    // 可能有移动,取决于编译器优化

    std::cout << "\n=== 初始化场景 ===" << std::endl;
    initialization_demo();

    return 0;
}

保证消除 vs 非保证消除的对比 ​

场景C++17 之前C++17
T x = T();允许消除,但 T 必须可拷贝/可移动保证消除,T 不需要可拷贝/可移动
return T();允许消除(RVO),T 必须可拷贝/可移动保证消除,T 不需要可拷贝/可移动
T x = factory();(factory 返回纯右值)允许消除,T 必须可拷贝/可移动保证消除,T 不需要可拷贝/可移动
return local_var;(具名变量)允许消除(NRVO),T 必须可拷贝/可移动允许消除(NRVO),T 必须可拷贝/可移动
用 -fno-elide-constructors 禁用优化拷贝/移动会实际发生纯右值场景仍然不产生拷贝/移动

关键区别:保证拷贝消除只对纯右值生效,对具名变量(NRVO)不生效。

与传统方案的对比 ​

对比项C++11/14 拷贝消除C++17 保证拷贝消除
性质编译器优化,允许但不强制语言规则,强制执行
拷贝/移动构造函数要求必须存在且可访问纯右值场景不需要
调试模式下可能被禁用纯右值场景仍然生效
不可移动类型按值返回不允许允许(纯右值返回)
NRVO(具名变量)允许消除仍然只是允许,不保证

适用场景 ​

  • 工厂函数返回不可拷贝不可移动的类型(比如 std::mutex、std::lock_guard 的包装器等)
  • 需要保证零拷贝开销的场景:即使在调试模式、低优化级别下也不会产生多余的拷贝
  • 简化类设计:某些只需要直接构造的类型,不必为了满足按值返回的需求而提供拷贝/移动构造函数
  • 链式工厂调用:T x = f(g(h())) 这种多层嵌套的纯右值传递,C++17 保证全程零拷贝

常见问题 ​

NRVO(命名返回值优化)在 C++17 中是保证的吗?

不是。C++17 只保证了纯右值(prvalue)的消除。return local_var; 中的 local_var 是具名变量(左值),不是纯右值,所以 NRVO 仍然只是"允许但不保证"。实践中,大多数编译器在非调试模式下都会执行 NRVO,但严格来说标准不保证。

如果函数有多个 return 路径返回不同的局部变量,会怎样?

cpp
T func(bool flag) {
    T a, b;
    if (flag) return a;
    else return b;
}

这种情况下 NRVO 通常不会发生(因为编译器不知道该把 a 还是 b 构造在返回值的位置上)。但 C++11 保证在 NRVO 不发生时,返回局部变量会自动尝试移动而不是拷贝。

保证拷贝消除影响析构函数的调用吗?

不影响构造的次数——纯右值直接在目标位置构造,所以只有一次构造和一次析构。但要注意,即使在保证拷贝消除的场景下,返回类型的析构函数仍然必须可访问且非删除(编译器需要检查这一点)。

这个特性和 std::move 有关系吗?

没有直接关系。保证拷贝消除解决的是纯右值的传递问题,而 std::move 处理的是把左值转换为右值引用的问题。如果你的返回语句已经是纯右值(return T(...)),不需要也不应该写 return std::move(T(...))。对于返回局部变量的场景(return local_var),写 std::move 反而可能阻止 NRVO。

注意事项 ​

  • 保证拷贝消除只对纯右值生效。return T(); 是纯右值,return local_var; 不是
  • 即使拷贝/移动构造函数被 delete,纯右值返回在 C++17 中也是合法的
  • 不要对返回的纯右值使用 std::move——这会把纯右值变成 xvalue,可能反而阻止保证拷贝消除
  • 返回类型的析构函数必须可访问,即使不会发生拷贝/移动
  • NRVO 虽然不保证,但实际上几乎所有编译器都支持——只是在极端场景(多返回路径、调试模式)下可能不做
  • 这个特性不是"优化"——C++17 标准从语义层面就没有拷贝/移动的发生,而不是发生了然后被优化掉

编译器支持情况 ​

编译器最低支持版本
GCC7.0
Clang4.0
MSVC19.13 (VS 2017 15.6)

总结 ​

保证拷贝消除是 C++17 对值语义的一次根本性改进。它通过重新定义纯右值的语义——纯右值不再是临时对象,而是"延迟实体化的初始化器"——从语言层面消除了纯右值场景下的拷贝/移动操作。最直观的影响是:不可拷贝不可移动的类型也能按值返回了(只要返回的是纯右值)。对于日常开发来说,这意味着 T x = factory() 这种代码在 C++17 中保证零开销,即使在调试模式下也不会产生额外的拷贝。但要记住,NRVO(返回具名变量)仍然不是保证的——如果你需要依赖消除,尽量让返回语句直接返回纯右值。