RVO、NRVO和-fno-elide-constructors

最新推荐文章于 2025-03-28 11:18:48 发布
最新推荐文章于 2025-03-28 11:18:48 发布
阅读量359 收藏 1
点赞数 1
分类专栏： C/C++后端开发 文章标签： c++ c11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/heihei36/article/details/120771567
版权
本文简要介绍了C++的RVO（Return Value Optimization）和NRVO（Named Return Value Optimization）优化技术，说明它们如何减少构造函数的调用次数。在编译时使用-fno-elide-constructors参数可以禁用这种优化，导致额外的移动和拷贝构造函数调用。此外，当对象作为参数传递时，如果实参是局部变量，将优先使用移动构造函数；如果是全局变量或const局部变量，则会使用拷贝构造函数。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

若有时间再详细地解释一下，RVO和NRVO都做了什么， 此文只说结论。

一、RVO和NRVO优化后（NVO和NRVO是什么，自行google，此处不做解释），形如：

Test func() {
    Test t;
    return t;
}

Test tt = func();

只会调用一次构造函数。若想解除RVO和NRVO，编译时加上 -fno-elide-constructors 参数。

若加上-fno-elide-constructors，函数调用顺序为：

1、构造函数， func内局部变量构造

2、移动构造函数，局部变量t构造返回值的临时变量tmp，注意此处不是拷贝构造函数。

3、析构函数，局部变量t析构

4、移动构造函数，返回值的临时变量tmp构造tt

5、析构函数， 返回值的临时变量tmp析构

6、析构函数， tt析构

二、对象参数传递，若实参为局部变量则优先调用移动构造函数，若实参为全局变量或者const类型的局部变量等不会引起RVO或者NRVO的则会调用拷贝构造函数。即加上-fno-elide-constructors参数后，形如：

Test t;
Test fu
了解本专栏 订阅专栏 解锁全文
GCC：-fno-elide-constructors关闭返回值优化
风静如云的博客
07-14 1491
将tmpA1作为参数，调用拷贝构造函数生成一个临时的返回值对象，记作tmpA2；按照C++的标准，A a = getA();3.对A a进行构造时，通过tmpA2，调用拷贝构造函数，生成对象a。时调佣默认构造函数，生成一个对象，记作tmpA1；
C++ 构造函数const & -fno-elide-constructors
weixin_45424965的博客
11-05 557
why const https://www.geeksforgeeks.org/copy-constructor-argument-const/ 最开始是想查一下为什么要用const #include<iostream> using namespace std; class Test { /* Class data members */ public: Test(Test &t) { /* Copy data members from t*/} Test() { /* Initial
通过参数-fno-elide-constructors关闭g++的编译优化
神技圈子的博客
04-06 5503
前两天在做讲课资料的时候遇到一个比较坑的问题。一般来说调用拷贝构造函数分三种情况 1.当用类一个对象去初始化另一个对象时。 2.如果函数形参是类对象。 3.如果函数返回值是类对象，函数执行完成返回调用时。 道理很简单，我写了个很简单的例子 在fun函数中会返回一个class A的对象，那么编译器会在栈上构造一个临时对象，构造临时对象的方法则是调用拷贝构造函数 结果运行后，如下...
性能翻倍！揭秘编译器如何偷偷加速你的C++代码 - RVO/NRVO详解
Henry313的博客
03-28 908
性能翻倍！揭秘编译器如何偷偷加速你的C++代码 - RVO/NRVO详解
c++：fno-elide-constructors
李白
05-09 1306
-fno-elide-constructors C++ 标准允许实现省略创建仅用于初始化相同类型的另一个对象的临时对象。指定此选项会禁用该优化，并强制 g++ 在所有情况下调用复制构造函数。
C++移动构造函数，移动赋值和编译选项-fno-elide-constructors
sharpblade's Blog
02-04 1021
对比了拷贝构造函数和移动构造函数，赋值和移动赋值运算，以及有无-fno-elide-constructors选项的情况。
-fno-elide-constructors
with_dream的博客
12-20 1098
c++11 测试右值 临时对象的构造 编译器会自动优化导致有些流程未打印 需要添加-fno-elide-constructors标记 g++直接添加 cmake 使用SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-elide-constructors") 参考： https://blog.youkuaiyun.com/XiyouLinux_Kangyijie/arti...
【C++踩坑】说说g++的-fno-elide-constructors参数
康康的博客
12-30 9262
前言有时结果和你想的不一样，并不一定是你想错了。。。可能是编译器优化了。正文在给学弟讲题时遇到了这样一个问题，代码如下class A{ public: A() = default; A(const A &a): str(a.str){ cout << "copy" << endl; } A(const string &d):str(d){ co
C++编译优化RVO&NRVO&复制省略
WindSun's Blog
04-24 434
编译器优化技术 现代编译器缺省会使用 RVO(return value optimization，返回值优化)、NRVO(named return value optimization、命名返回值优化)和复制省略(Copy elision)技术，来减少拷贝次数来提升代码的运行效率。 注1：vc6、vs 没有提供编译选项来关闭该优化，无论是 debug 还是 release 都会进行 RVO 和复...
全面理解-返回值优化 RVO/NRVO
HL_LOVE_C的博客
02-09 1002
理解 RVO/NRVO 可显著提升 C++ 函数返回对象的性能，尤其在涉及大型数据结构时。它们的核心目标是直接在调用者的内存位置构造对象，而非通过临时对象中转。：编译器尝试直接在调用者的内存中构造该具名对象，但优化难度高于 RVO。是两种编译器优化技术，旨在消除函数返回对象时的。对象类型支持拷贝/移动（即使优化后实际未调用）。：直接在调用者的内存中构造返回对象，（即直接返回构造函数或运算结果）。将临时对象拷贝/移动到调用者。函数内所有返回路径必须返回。（即函数内部定义的变量）。在函数内构造临时对象。
c++中返回值优化（RVO）和命名返回值优化（NRVO）介绍
shadow-lr的博客
03-07 5006
RVO和NRVO介绍 前言 半年前就想写一篇关于RVO和NRVO的介绍，但碍于没什么时间去写博客。在跟身边人进行学术探讨的时候，会发现部分人可能尝到了编译器给它做返回值优化的好处，知道这段代码被优化了，但为什么 如何去做，却不知道。 因此，为了尝试说明RVO和NRVO的好处、使用场景、局限性等，在看了数个StackOverflow的讨论之后，有了这篇博客。 RVO(返回值优化(Return Value Optimization)) 如果函数返回一个无名的临时对象，该对象将被编译器移动或拷贝到目标中，在此时
g++编译优化选项-fno-elide-constructors
choumin的专栏
06-27 2475
1、考虑下面的代码，请问输出结果是什么？ #include <stdio.h> class A { public: A(int val) { puts("A(int)"); d = val; } A(A&& a) { puts("A(A&&)"); d = a.d; } A(A& a) { puts("A(A&)"); d = a.d; } ~A() {} private: int d; }; A cr
-fno-elide-constructors 返回值优化
lanshi00的博客
12-11 243
在devc++将 编译时加入 -fno-elide-constructors 改为-std=c++11 参考文章 https://www.cnblogs.com/xkfz007/archive/2012/07/21/2602110.html
使用-fno-elide-constructors关闭g++编译器对C++中拷贝与移到拷贝相关优化问题
勿忘初心,方得始终
01-13 393
#include<iostream> using namespace std; class A { private: /* data */ public: A(/* args */); A(const A&other); A& operator=(const A&other); A getA(); void fun(A); void fun2(A&); ~A(); }; A::A(/* args *
C++11 右值引用与g++ fno-elide-constructors编译选项
繁华落尽梦一场
04-07 878
右值和将亡值 C++11增加了一种新类型，称为右值引用（R-value-reference)，标记为T &&。那么怎么区分左右值？左值指的是表达式结束后依然存在的持久对象，右值指的是表达式结束时就不再存在的临时对象。一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。所有的具名变量或者对象都是左值，而右值不具名。 ...
C++函数返回局部变量对象的优化-不调用复制构造函数（g++ -fno-elide-constructors选项）
随意的风的专栏
08-16 2968
　　先说点背景知识，调用复制构造函数的三种情况： 　　1.当用类一个对象去初始化另一个对象时。 　　2.如果函数形参是类对象。 　　3.如果函数返回值是类对象，函数执行完成返回调用时。 　　在辅导学生上机时，有同学第3点提出异议。有教材上的例题为证： 请看下面的例子： #include &lt;stdio.h&gt; #include &lt;unistd.h&gt; #inclu.........
gcc参数 -fno-elide-constructors怎么回事儿？
Lionel的专栏
01-13 825
这里写自定义目录标题好奇怪！复制构造函数居然不被调用了？代码代码分析合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 好奇怪！复制构造函数居然不被调用了？ 我在Linux下写demo的时候遇到了一个非常奇怪的问题！代码如下，理论上是复制构造函
C++ 命名返回值优化（NRVO）
weixin_34185364的博客
11-12 478
命名的返回值优化（NRVO），这优化了冗余拷贝构造函数和析构函数调用，从而提高了总体性能。值得注意的是，这可能导致优化和非优化程序之间的不同行为。 下面是代码段1中的一个简单示例，以说明优化及其实现方式： A MyMethod (B &var) { A retVal; retVal.member = var.value + bar...
RVO(Return Value Optimization)和NRVO(Named Return Value Optimization)
diaolingle的专栏
04-17 1353
中文解释： RVO：返回值优化                    NRVO：具命返回值优化 具体示例如下： #include class A { public: A(int i): m_a(i) { printf("constructor\n"); } A(const A &a) { printf("copy constructor\n"); m_a = a
拷贝构造函数详解和使用场景
最新发布
04-03
<think>好的，我现在需要详细解释拷贝构造函数，并列举其使用场景。首先，我要确保自己对拷贝构造函数有全面的理解，然后整理出用户可能需要的关键点。 拷贝构造函数是C++中的一个特殊成员函数，用于创建一个新对象作为现有对象的副本。它的基本形式是`ClassName(const ClassName& other)`。当对象被以值传递、返回或以值方式初始化时，拷贝构造函数会被调用。理解这一点很重要，因为它关系到对象的复制方式和资源管理。 接下来，我需要考虑用户可能遇到的问题。比如，为什么需要自定义拷贝构造函数？默认的拷贝构造函数有什么问题？这时候深拷贝和浅拷贝的区别就变得关键。特别是当类中有动态分配的资源时，默认的浅拷贝会导致多个对象指向同一内存，引发双重释放等问题。因此，必须通过自定义拷贝构造函数实现深拷贝，分配新内存并复制内容。 然后，使用场景部分需要覆盖常见的几种情况：显式拷贝构造、函数参数传递、函数返回值以及容器中的对象复制。每个场景都需要具体例子来说明拷贝构造函数何时被调用，比如在传递对象参数时，值传递会触发拷贝构造，而引用传递则不会。同时，编译器优化如返回值优化（RVO）可能会影响拷贝构造函数的调用次数，这也是需要注意的地方。 用户可能还会想知道如何正确实现拷贝构造函数，避免常见错误。比如，确保深拷贝的正确性，处理可能的异常，以及遵循三大法则（拷贝构造函数、拷贝赋值运算符、析构函数的一致性）。此外，现代C++中的移动语义和`=delete`的使用也是值得提及的改进点，帮助用户了解如何禁用拷贝或转移资源所有权。 另外，我需要验证默认拷贝构造函数的风险，通过对比有无自定义拷贝构造函数时的程序行为，展示内存地址的变化和潜在的双重释放错误。这部分可以通过示例代码的输出结果直观说明问题，增强用户的理解。 最后，总结最佳实践，比如何时需要自定义拷贝构造函数，如何结合其他特殊成员函数管理资源，以及现代C++提供的工具和技巧。确保用户不仅了解拷贝构造函数的机制，还能在实际编程中正确应用，避免常见陷阱。 整理这些思路时，要注意结构清晰，逐步引导用户理解概念，并通过代码示例和输出来验证关键点。同时，语言要简洁明了，避免过于技术化的术语，确保不同水平的读者都能跟上。</think>### 拷贝构造函数详解与使用场景 --- #### **一、基本定义** **拷贝构造函数**（Copy Constructor）是C++中用于**创建新对象作为现有对象副本**的特殊构造函数，其核心特征如下： - **语法形式**：`ClassName(const ClassName& other)` - **调用时机**：当对象通过**值传递**、**值返回**或**显式复制**时触发 - **默认行为**：若未显式定义，编译器会生成**浅拷贝**版本（逐成员复制） --- #### **二、核心作用：深拷贝与资源管理** 当类包含**动态分配的资源**（如指针、文件句柄）时，必须自定义拷贝构造函数实现**深拷贝**，避免以下问题： ```cpp // 示例：未定义拷贝构造的灾难性后果 class BadString { char* data; public: BadString(const char* str) { data = new char[strlen(str)+1]; strcpy(data, str); } ~BadString() { delete[] data; } // 析构函数 }; int main() { BadString a("Hello"); BadString b = a; // 默认浅拷贝：b.data 与 a.data 指向同一内存 return 0; // 程序崩溃：双重释放！ } ``` --- #### **三、典型使用场景** | 场景类型 | 触发条件示例 | 代码示例 | |-------------------------|----------------------------------|-----------------------------------| | **显式对象复制** | 通过现有对象初始化新对象 | `MyClass obj2(obj1);` | | **函数参数值传递** | 对象作为非引用参数传递 | `void func(MyClass obj) { ... }` | | **函数返回值** | 返回局部对象（可能触发RVO优化） | `return MyClass(...);` | | **容器操作** | STL容器插入/复制元素 | `vector.push_back(existing_obj);` | | **异常抛出** | 抛出异常对象时复制 | `throw MyException(obj);` | --- #### **四、完整实现示例** ```cpp #include <iostream> #include <cstring> class SecureArray { private: int* m_data; size_t m_size; public: // 普通构造函数 SecureArray(size_t size) : m_size(size) { m_data = new int[size]{0}; // 初始化为0 } // 拷贝构造函数（深拷贝） SecureArray(const SecureArray& other) : m_size(other.m_size) { std::cout << "执行深拷贝，分配 " << m_size*4 << " 字节内存" << std::endl; m_data = new int[m_size]; memcpy(m_data, other.m_data, m_size * sizeof(int)); } // 析构函数 ~SecureArray() { delete[] m_data; std::cout << "释放 " << m_size*4 << " 字节内存" << std::endl; } void setValue(size_t index, int value) { if(index < m_size) m_data[index] = value; } void print() const { std::cout << "地址:" << m_data << " 数据:"; for(size_t i=0; i<m_size; ++i) std::cout << " " << m_data[i]; std::cout << std::endl; } }; int main() { SecureArray arr1(3); arr1.setValue(0, 10); arr1.setValue(1, 20); // 场景1：显式拷贝 SecureArray arr2 = arr1; // 调用拷贝构造 // 场景2：修改副本不影响原对象 arr2.setValue(2, 30); // 验证独立性 arr1.print(); // 输出: 地址:0x... 数据:10 20 0 arr2.print(); // 输出: 地址:0x... 数据:10 20 30 return 0; } ``` **输出验证**： ``` 执行深拷贝，分配 12 字节内存 地址:0x55a1a3a12e80 数据:10 20 0 地址:0x55a1a3a12eb0 数据:10 20 30 释放 12 字节内存 释放 12 字节内存 ``` - 两个对象的`m_data`地址不同，证明深拷贝成功 - 修改副本数据不影响原始对象 --- #### **五、必须自定义拷贝构造的典型场景** | 特征类型 | 示例 | 风险说明 | |-------------------------|-------------------------------|--------------------------------| | **动态内存管理** | 类包含`new`分配的指针成员 | 默认浅拷贝导致双重释放 | | **唯一资源句柄** | 文件描述符、数据库连接 | 多个对象操作同一资源引发冲突 | | **引用计数控制** | 智能指针的引用计数管理 | 需要精确控制拷贝时的计数增减 | | **复杂状态对象** | 包含互斥锁(mutex)的线程安全类 | 避免多个对象共享同一锁 | --- #### **六、高级技巧与规范** 1. **拷贝赋值运算符**： ```cpp SecureArray& operator=(const SecureArray& other) { if(this != &other) { // 防止自赋值 delete[] m_data; // 释放旧资源 m_size = other.m_size; m_data = new int[m_size]; // 分配新资源 memcpy(m_data, other.m_data, m_size*sizeof(int)); } return *this; } ``` 2. **C++11改进：删除拷贝**： ```cpp SecureArray(const SecureArray&) = delete; // 禁用拷贝构造 SecureArray& operator=(const SecureArray&) = delete; // 禁用拷贝赋值 ``` 3. **移动语义（C++11+）**： ```cpp SecureArray(SecureArray&& other) noexcept // 移动构造 : m_data(other.m_data), m_size(other.m_size) { other.m_data = nullptr; // 转移资源所有权 other.m_size = 0; } ``` --- #### **七、经典问题解答** **Q1：为什么拷贝构造函数的参数必须是const引用？** - 避免无限递归：若参数为值传递，为复制实参需要调用拷贝构造函数，导致无限递归 - 保证原对象不被修改：`const`确保复制过程中原对象状态不变 **Q2：何时编译器会隐式生成拷贝构造函数？** 当满足以下条件时，编译器自动生成默认拷贝构造函数： - 类中没有用户声明的拷贝构造函数 - 所有非静态成员均可被拷贝（如具备可访问的拷贝构造函数） **Q3：如何验证拷贝构造函数被调用？** - 在拷贝构造函数中添加调试输出 - 使用`g++ -fno-elide-constructors`关闭编译器优化（观察完整调用链） --- #### **八、性能优化建议** 1. **尽量使用`const引用传递`对象**： ```cpp void processObject(const SecureArray& arr); // 避免不必要的拷贝 ``` 2. **利用返回值优化（RVO/NRVO）**： ```cpp SecureArray createArray() { return SecureArray(1000); // 编译器可能直接构造到目标内存 } ``` 3. **移动语义优先**： ```cpp SecureArray arr = std::move(existingArray); // 触发移动构造，零拷贝 ``` --- ### 总结 拷贝构造函数是C++资源管理的核心机制之一，其正确实现直接影响程序的稳定性和安全性。通过深拷贝避免资源冲突，结合现代C++的移动语义和`=delete`语法，可以构建更高效、更安全的对象复制策略。理解其工作原理后，开发者能更好地控制对象生命周期，避免内存泄漏和竞态条件等常见问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值