【C++】RVO、NRVO优化以及返回值优化失效的场景

拾牙慧者

于 2023-12-14 23:58:16 发布

阅读量592

点赞数 11

分类专栏： # C++ 挖坑与填坑文章标签： c++ java 前端

本文链接：https://blog.csdn.net/qq_42604176/article/details/135006934

版权

C++ 挖坑与填坑专栏收录该内容

102 篇文章 27 订阅

订阅专栏

目录

**简单对象的返回**
**多个返回语句**
**具有可观察副作用的对象**

（RVO, Return Value Optimization，返回值优化，或者NRVO，Named Return Value optimization)。

使用-fno-elide-constructors选项可以在g++/clang++中关闭这个优化
但若在编译的时候不使用该选项的话，很多构造和移动都被省略了。对于下面这样的代码，一旦打开g++/clang++的RVO/NRVO，从ReturnValue函数中a变量拷贝/移动构造临时变量，以及从临时变量拷贝/移动构造b的二重奏就通通没有了

        A ReturnRvalue() { A a(); return a; }
        A b = ReturnRvalue();

b变量实际就使用了ReturnRvalue函数中a的地址，任何的拷贝和移动都没有了。通俗地说，就是b变量直接“霸占”了a变量。这是编译器中一个效果非常好的一个优化。不过RVO/NRVO并不是对任何情况都有效。比如有些情况下，一些构造是无法省略的。还有一些情况，即使RVO/NRVO完成了，也不能达到最好的效果。但结论是明显的，移动语义可以解决编译器无法解决的优化问题，因而总是有用的。

返回值优化（Return Value Optimization，RVO）是一种编译器优化技术，旨在减少函数返回对象的副本构造和析构成本。通过RVO，编译器可以直接将局部对象放置在函数调用方所期望的位置，而不是创建一个临时副本。

尽管RVO在现代编译器中通常会生效，但并不能保证它始终有效。以下是一些情况下RVO可能无法生效的情况：

多个返回语句：如果函数中存在多个返回语句，且每个返回语句返回的对象类型不同，编译器可能无法进行RVO。这是因为编译器需要确保能够正确地创建要返回的对象，并且无法预先确定哪个对象将最终被返回。
异常处理：当函数中存在异常处理代码时，编译器可能会禁用RVO。这是为了确保在异常抛出时能够捕获、处理或传递异常对象的拷贝。
对象具有可观察的副作用：如果对象的拷贝构造函数、析构函数或移动构造函数具有可观察的副作用，编译器可能会禁用RVO。这是为了确保对象的副本构造和析构过程按照预期进行，避免对程序的行为产生副作用。
C++标准规定：虽然大多数现代编译器支持RVO，但C++标准并不要求编译器实现该优化。因此，特定编译器或编译器版本可能在某些情况下选择不执行RVO。

需要注意的是，无论RVO是否生效，代码的行为应始终符合C++语言中对拷贝构造函数、析构函数和移动构造函数的要求。如果有特定的性能需求或对RVO的可靠性有疑问，可以通过使用移动语义、返回指针或引用等其他技术来显式控制对象的生命周期和复制行为。

简单对象的返回

#include <iostream>

struct MyObject {
    int value;

    MyObject(int val) : value(val) {
        std::cout << "Constructor called\n";
    }

    MyObject(const MyObject& other) : value(other.value) {
        std::cout << "Copy constructor called\n";
    }

    ~MyObject() {
        std::cout << "Destructor called\n";
    }
};

MyObject createObject() {
    MyObject obj = MyObject(42);
    return obj;
}

int main() {
    MyObject obj = createObject();
    std::cout << "Value: " << obj.value << "\n";
    return 0;
}

Constructor called
Value: 42         
Destructor called

多个返回语句

#include <iostream>

struct MyObject {
    int value;

    MyObject(int val) : value(val) {
        std::cout << "Constructor called\n";
    }

    MyObject(const MyObject& other) : value(other.value) {
        std::cout << "Copy constructor called\n";
    }

    ~MyObject() {
        std::cout << "Destructor called\n";
    }
};

MyObject createObject(bool flag) {
    MyObject obj1 = MyObject(42);
    MyObject obj2 = MyObject(43);
    if (flag) {
        return obj1;
    } else {
        return obj2;
    }
}

int main() {
    MyObject obj = createObject(true);
    std::cout << "Value: " << obj.value << "\n";
    return 0;
}

Constructor called     
Constructor called     
Copy constructor called
Destructor called      
Destructor called      
Value: 42              
Destructor called

在这个例子中，createObject() 函数根据 flag 参数返回不同的对象。由于无法预测哪个对象将被返回，编译器无法进行RVO。因此，在每个返回语句处都会调用相应的拷贝构造函数

具有可观察副作用的对象

#include <iostream>

struct MyObject {
    int value;
    
    MyObject(int val) : value(val) {
        std::cout << "Constructor called\n";
    }
    
    MyObject(const MyObject& other) : value(other.value) {
        std::cout << "Copy constructor called\n";
    }
    
    ~MyObject() {
        std::cout << "Destructor called\n";
    }
};

MyObject createObject(bool flag) {
    MyObject obj1(42);
    if (flag) {
        return obj1;
    } else {
        return MyObject(64);
    }
}

int main() {
    MyObject obj = createObject(true);
    std::cout << "Value: " << obj.value << "\n";
    return 0;
}