C++ Copy Elision 与 NRVO：编译器优化对对象构造的影响

好的，各位观众老爷，欢迎来到今天的“C++对象构造变形记”特别节目！我是你们的老朋友，BUG终结者，代码美容师，内存侦探——程序猿老王。

今天咱们不聊虚的，直接上硬货，聊聊C++里两个让对象“凭空消失”的黑魔法：Copy Elision（复制省略）和 NRVO（Named Return Value Optimization，具名返回值优化）。

开场白：对象，你的构造函数还好吗？

咱们写C++代码，天天跟对象打交道。对象生老病死，都要经过构造、复制、赋值、析构这些过程。但有时候，你明明写了构造函数，编译器却“视而不见”，直接把对象“变”出来了！这到底是咋回事？难道是编译器偷懒了？还是对象们集体罢工了？

别慌，今天咱们就来揭秘这背后的真相。

第一幕：Copy Elision——“无中生有”的障眼法

Copy Elision，顾名思义，就是“复制省略”。编译器觉得有些复制操作纯属多余，浪费时间，所以就直接省略掉了。这就像你去饭馆吃饭，服务员直接把菜端到你面前，省略了从厨房到餐桌的传送过程。

Copy Elision 主要发生在以下几种情况：

临时对象的构造： 当你用一个临时对象初始化另一个对象时，编译器很可能会直接在目标对象的内存位置构造这个临时对象，避免一次复制。
函数返回值（非 NRVO）： 当函数返回一个临时对象，并且该对象被用来初始化另一个对象时，编译器也可能直接在目标对象的内存位置构造这个返回值。

举个栗子：

#include <iostream>

class MyString {
public:
    MyString(const char* str) {
        std::cout << "Constructor called with: " << str << std::endl;
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    MyString(const MyString& other) {
        std::cout << "Copy Constructor called" << std::endl;
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    ~MyString() {
        std::cout << "Destructor called" << std::endl;
        delete[] data;
    }

    char* data;
};

MyString createString() {
    return MyString("Hello, world!"); // 返回临时对象
}

int main() {
    MyString str = createString(); // 初始化对象
    return 0;
}

正常情况下，这段代码应该输出：

Constructor called with: Hello, world!
Copy Constructor called
Destructor called
Destructor called

但是，如果你的编译器支持 Copy Elision，你很可能会看到：

Constructor called with: Hello, world!
Destructor called

解释：

createString() 函数返回一个临时的 MyString 对象。
在 main() 函数中，str 对象用这个临时对象初始化。
如果没有 Copy Elision，会调用拷贝构造函数，将临时对象复制到 str。
但是，编译器发现这个复制操作是多余的，它直接在 str 的内存位置构造了 createString() 返回的临时对象。
因此，拷贝构造函数被省略了，只调用了一次构造函数和两次析构函数（临时对象和str）。

总结： Copy Elision 就像一个勤劳的清洁工，默默地帮你清理掉不必要的复制操作，让你的代码运行得更快。但是，它也可能让你迷惑，为什么我的拷贝构造函数没被调用？

第二幕：NRVO——“鸠占鹊巢”的华丽转身

NRVO，Named Return Value Optimization，具名返回值优化。名字听起来很唬人，其实就是编译器对具名返回值的一种优化。

什么叫具名返回值？就是函数返回的时候，返回的是一个局部变量，而不是临时对象。

举个栗子：

#include <iostream>

class MyString {
public:
    MyString(const char* str) {
        std::cout << "Constructor called with: " << str << std::endl;
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    MyString(const MyString& other) {
        std::cout << "Copy Constructor called" << std::endl;
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    ~MyString() {
        std::cout << "Destructor called" << std::endl;
        delete[] data;
    }

    char* data;
};

MyString createString() {
    MyString result("Hello, world!"); // 局部变量
    return result; // 返回局部变量
}

int main() {
    MyString str = createString();
    return 0;
}

如果没有 NRVO，这段代码应该输出：

Constructor called with: Hello, world!
Copy Constructor called
Destructor called
Destructor called

但是，如果你的编译器支持 NRVO，你很可能会看到：

Constructor called with: Hello, world!
Destructor called

解释：

createString() 函数创建了一个局部变量 result。
函数返回 result 时，如果没有 NRVO，编译器会创建一个临时对象，将 result 复制到这个临时对象，然后返回这个临时对象。在 main() 中，再将这个临时对象复制到 str。
但是，有了 NRVO，编译器会直接在 main() 函数中 str 的内存位置构造 createString() 函数的局部变量 result。
这样，就避免了两次复制操作（从 result 到临时对象，再从临时对象到 str）。

NRVO 的条件：

函数返回的是一个局部变量。
这个局部变量是具名的（就是说，它有一个名字，而不是一个匿名对象）。
函数在所有 return 语句中都返回同一个具名变量。（这一点很重要，如果你的函数有多个 return 语句，并且返回不同的变量，NRVO 就可能失效。）

总结： NRVO 就像一个搬运工，直接把函数内部的局部变量“搬”到函数外部，省去了中间的复制环节。这对于大型对象来说，性能提升非常明显。

Copy Elision vs. NRVO：傻傻分不清楚？

Copy Elision 和 NRVO 都是编译器优化，目的都是减少不必要的复制操作。但是，它们的应用场景和触发条件有所不同。

特性	Copy Elision	NRVO
触发条件	临时对象的构造，函数返回值（非 NRVO）	函数返回具名的局部变量
优化方式	直接在目标对象的内存位置构造临时对象或返回值	直接在调用者的内存位置构造函数内部的局部变量
是否强制	C++17 之前是可选的，C++17 及以后，部分情况是强制的	可选的（虽然大部分编译器都会实现）
作用对象类型	任何类型	任何类型

C++17 的变化：强制 Copy Elision

在 C++17 之前，Copy Elision 只是编译器的一种优化手段，编译器可以选择是否进行优化。但是，在 C++17 中，某些情况下的 Copy Elision 变成了强制的。

具体来说，以下情况的 Copy Elision 是强制的：

当函数返回一个类类型的对象，并且 return 语句返回的是一个prvalue（pure rvalue，纯右值，比如临时对象）时。
当抛出一个类类型的异常，并且 throw 表达式的操作数是一个 prvalue 时。

这意味着，即使你的类没有拷贝构造函数，或者拷贝构造函数是 delete 的，只要满足以上条件，编译器仍然可以成功地编译你的代码，因为它根本不会调用拷贝构造函数！

这给我们带来了什么？

性能提升： 强制 Copy Elision 意味着，在某些情况下，我们不再需要担心不必要的复制操作带来的性能损失。
代码简化： 我们可以更自由地使用临时对象，而不用担心性能问题。
新的设计模式： 强制 Copy Elision 使得某些新的设计模式成为可能，比如移动语义。

移动语义：Copy Elision 的好基友

移动语义是 C++11 引入的一个重要特性，它允许我们将一个对象的资源“移动”到另一个对象，而不是进行深拷贝。

移动语义和 Copy Elision 经常一起使用，可以进一步提高程序的性能。

举个栗子：

#include <iostream>

class MyString {
public:
    MyString(const char* str) {
        std::cout << "Constructor called with: " << str << std::endl;
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    MyString(const MyString& other) {
        std::cout << "Copy Constructor called" << std::endl;
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept {
        std::cout << "Move Constructor called" << std::endl;
        data = other.data;
        other.data = nullptr;
    }

    ~MyString() {
        std::cout << "Destructor called" << std::endl;
        delete[] data;
    }

    char* data;
};

MyString createString() {
    MyString result("Hello, world!");
    return result;
}

int main() {
    MyString str = createString();
    return 0;
}

在这个例子中，我们添加了一个移动构造函数。当编译器进行 NRVO 时，它会尝试使用移动构造函数来初始化 str 对象，而不是拷贝构造函数。这样，就可以避免深拷贝，提高程序的效率。

注意事项：

noexcept： 移动构造函数应该声明为 noexcept，表示它不会抛出异常。这可以帮助编译器进行更多的优化。
资源所有权： 在移动构造函数中，我们需要将源对象的资源所有权转移到目标对象，并将源对象的指针设置为 nullptr，防止源对象析构时释放资源。

总结： 移动语义和 Copy Elision 是 C++ 中两个强大的性能优化工具，它们可以帮助我们编写更高效的代码。

结语：对象，你的构造函数自由了！

今天我们聊了 Copy Elision 和 NRVO，这两个编译器优化技术可以帮助我们减少不必要的复制操作，提高程序的性能。

记住，理解这些优化技术，可以帮助我们更好地理解 C++ 的对象构造过程，编写更高效、更优雅的代码。

但是，也不要过度依赖编译器优化。好的代码设计，才是性能优化的根本。

最后，祝各位观众老爷代码写得飞起，BUG 永远远离！咱们下期再见！

发表回复 取消回复

发表回复取消回复