C++编译器优化：Copy Elision（省略不必要的拷贝）

最新推荐文章于 2024-09-20 17:41:28 发布
最新推荐文章于 2024-09-20 17:41:28 发布
阅读量8k 收藏 10
点赞数 2
分类专栏： C++ 文章标签： 优化 编译器 c++ initialization optimization struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwvista/article/details/6845020
版权
为避免对临时对象进行不必要的拷贝，C++编译器常使用一种名为Copy Ellision（拷贝去除）的优化技术，该技术至少包括以下两项内容： 
  1. 返回值优化（RVO），即通过将返回值所占空间的分配地点从被调用端转移至调用端的手段来避免拷贝操作。
    返回值优化包括具名返回值优化（NRVO）与无名返回值优化（URVO），两者的区别在于返回值是具名的局部变量还是无名的临时对象。
  2. 右值拷贝优化，当某一个类类型的临时对象被拷贝赋予同一类型的另一个对象时，通过直接利用该临时对象的方法来避免拷贝操作。
    这项优化只能用于右值（临时对象），不能用于左值。
如果需要测试编译器是否应用了Copy Ellision优化技术，可使用以下代码（摘自 cppnext）。 
#include <iostream>

struct X
{
    X() : id(instances++)
    {
        std::cout << "X" << id << ": construct\n";
    }
    
    X(X const& rhs) : id(instances++)
    {
        std::cout << "X" << id << ": <- " << "X" << rhs.id << ": **copy**\n";
        ++copies;
    }

    // This particular test doesn't exercise assignment, but for
    // completeness:
    X& operator=(X const& rhs)
    {
        std::cout << "X" << id << ": <- " << "X" << rhs.id << ": assign\n";
    }
    
    ~X() { std::cout << "X" << id << ": destroy\n"; }

    unsigned id;
    
    static unsigned copies;
    static unsigned instances;
};

unsigned X::copies = 0;
unsigned X::instances = 0;

#define CHECK_COPIES( stmt, min, max, comment )                         \
{                                                                       \
    unsigned const old_copies = X::copies;                              \
                                                                        \
    std::cout << "\n" comment "\n" #stmt "\n===========\n";             \
    {                                                                   \
        stmt;                                                           \
    }                                                                   \
    unsigned const n = X::copies - old_copies;                          \
    if (n > max)                                                        \
        std::cout << "*** max is too low or compiler is buggy ***\n";   \
    if (n < min)                                                        \
        std::cout << "*** min is too high or compiler is buggy ***\n";  \
                                                                        \
    std::cout << "-----------\n"                                        \
              << n << "/" << max                                        \
              << " possible copies made\n"                              \
              << max - n << "/" << max - min                            \
              << " possible elisions performed\n\n";                    \
                                                                        \
    if (n > min)                                                        \
        std::cout << "*** " << n - min                                  \
                  << " possible elisions missed! ***\n";                \
}

struct trace
{
    trace(char const* name)
        : name(name)
    {
        std::cout << "->: " << name << "\n";
    }
    
    ~trace()
    {
        std::cout << "<-: " << name << "\n";
    }
    
    char const* name;
};

void sink(X a)
{
  trace t("sink");
}

X nrvo_source()
{
    trace t("nrvo_source");
    X a;
    return a;
}

X urvo_source()
{
    trace t("urvo_source");
    return X();
}

X identity(X a)
{
    trace t("identity");
    return a;
}

X lvalue_;
X& lvalue()
{
    return lvalue_;
}
typedef X rvalue;

int main()
{
    // Double parens prevent "most vexing parse"
    CHECK_COPIES( X a(( lvalue() )), 1, 1, "Direct initialization from lvalue");
    CHECK_COPIES( X a(( rvalue() )), 0, 1, "Direct initialization from rvalue");
    
    CHECK_COPIES( X a = lvalue(), 1, 1, "Copy initialization from lvalue" );
    CHECK_COPIES( X a = rvalue(), 0, 1, "Copy initialization from rvalue" );

    CHECK_COPIES( sink( lvalue() ), 1, 1, "Pass lvalue by value" );
    CHECK_COPIES( sink( rvalue() ), 0, 1, "Pass rvalue by value" );

    CHECK_COPIES( nrvo_source(), 0, 1, "Named return value optimization (NRVO)" );
    CHECK_COPIES( urvo_source(), 0, 1, "Unnamed return value optimization (URVO)" );

    // Just to prove these things compose properly
    CHECK_COPIES( X a(urvo_source()), 0, 2, "Return value used as ctor arg" );
    
    // Expect to miss one possible elision here
    CHECK_COPIES( identity( rvalue() ), 0, 2, "Return rvalue passed by value" );
}
代码说明
  1. lvalue()函数返回struct X类型的全局变量lvalue_的引用，故lvalue()函数返回左值，可用于测试右值拷贝优化。
  2. rvalue()函数返回struct X类型的构造器所构建的临时对象，故rvalue()函数返回右值，可用于测试右值拷贝优化。
  3. nrvo_source()函数返回struct X类型的局部变量a，故nrvo_source()函数可用于测试具名返回值优化。
  4. urvo_source()函数返回struct X类型的构造器所构建的临时对象，故urvo_source()函数可用于测试无名返回值优化。
  5. 第109，110行分别用左右值来测试类对象直接初始化中的右值拷贝优化。
  6. 第112，113行分别用左右值来测试类对象拷贝初始化中的右值拷贝优化。
  7. 第115，116行分别用左右值来测试普通函数实参中的右值拷贝优化。
  8. 第118，119行分别用于测试具名返回值优化与无名返回值优化。
Windows平台下使用gcc4.6.1编译运行结果如下 
X0: construct

Direct initialization from lvalue
X a(( lvalue() ))
===========
X1: <- X0: **copy**
X1: destroy
-----------
1/1 possible copies made
0/0 possible elisions performed


Direct initialization from rvalue
X a(( rvalue() ))
===========
X2: construct
X2: destroy
-----------
0/1 possible copies made
1/1 possible elisions performed


Copy initialization from lvalue
X a = lvalue()
===========
X3: <- X0: **copy**
X3: destroy
-----------
1/1 possible copies made
0/0 possible elisions performed


Copy initialization from rvalue
X a = rvalue()
===========
X4: construct
X4: destroy
-----------
0/1 possible copies made
1/1 possible elisions performed


Pass lvalue by value
sink( lvalue() )
===========
X5: <- X0: **copy**
->: sink
<-: sink
X5: destroy
-----------
1/1 possible copies made
0/0 possible elisions performed


Pass rvalue by value
sink( rvalue() )
===========
X6: construct
->: sink
<-: sink
X6: destroy
-----------
0/1 possible copies made
1/1 possible elisions performed


Named return value optimization (NRVO)
nrvo_source()
===========
->: nrvo_source
X7: construct
<-: nrvo_source
X7: destroy
-----------
0/1 possible copies made
1/1 possible elisions performed


Unnamed return value optimization (URVO)
urvo_source()
===========
->: urvo_source
X8: construct
<-: urvo_source
X8: destroy
-----------
0/1 possible copies made
1/1 possible elisions performed


Return value used as ctor arg
X a(urvo_source())
===========
->: urvo_source
X9: construct
<-: urvo_source
X9: destroy
-----------
0/2 possible copies made
2/2 possible elisions performed


Return rvalue passed by value
identity( rvalue() )
===========
X10: construct
->: identity
X11: <- X10: **copy**
<-: identity
X11: destroy
X10: destroy
-----------
1/2 possible copies made
1/2 possible elisions performed

*** 1 possible elisions missed! ***
X0: destroy

C++ 的 Copy Elision
OreoMcFlurry的博客
12-08 310
No More C++ 系列带你玩转各种现代 C++ 的重要知识，告诉你凡人也可以接触和拥抱 C++。 Copy elision (拷贝省略，下文称之为 CE)，忽略拷贝构造函数和移动构造函数,，引发零拷贝值传递语义。CE 分为强制性和非强制性两大类。 先假设我们有这么一个 Widget 类。 class Widget { public: Widget() { std::cout << "construct \n"; } Widget(const Widget& other) {.
【C++】详谈explicit关键字背后的隐式类型转换和编译器优化
DanteKing的博客
02-07 971
开场白 本来想总结一下explicit关键字的用法，结果看了官方文档发现能给拷贝构造加explicit，我就去试了试 试了之后，又发现了两个大坑：隐式类型转换和编译器优化，本来我以为我很久以前就理解了这俩概念，但是一系列实验结果表明这并不是那么简单 这两个坑折磨得我欲仙欲死 首先贴一下我们一直说的编译器优化是什么，官网的定义 编译器优化学名叫：拷贝省略 Copy elision Omits copy and move (since C++11) constructors, resulting in zer
C++ - Copy Elision
Reeker
02-20 384
Copy Elision C++11/14/17编译器优化：省略不必要的拷贝 至少包括以下两项内容： 返回值优化（RVO），即通过将返回值所占空间的分配地点从被调用端转移至调用端的手段来避免拷贝操作。 返回值优化包括具名返回值优化（NRVO）与无名返回值优化（URVO），两者的区别在于返回值是具名的局部变量还是无名的临时对象。 右值拷贝优化，当某一个类类型的临时对象被拷贝赋予同一类型...
【C++篇】C++类与对象深度解析（六）：全面剖析拷贝省略、RVO、NRVO优化策略
最新发布
半截诗的博客~
09-20 1720
在这篇文章中，我们深入探讨了 C++ 中的 拷贝省略（Copy Elision）、返回值优化（RVO）、和 命名返回值优化（NRVO）等高级编译器优化技术。通过详细的代码示例与 VS2019 和 VS2022 编译器的实际表现对比，帮助你更好地理解这些优化在不同场景中的应用。无论你是 C++ 初学者，还是想提升编译性能的开发者，本文都将为你提供宝贵的见解。快来一起探索如何通过这些优化技术减少不必要的对象拷贝、提高代码性能吧！
C++中的CopyElision
iaibeyond的专栏
07-30 594
C++ copy elision的前世今生
Copy Elision
fatever的博客
08-17 1389
最近写程序的时候突然意识到了一个（也许大多数人早就意识到的）很常见的问题。我们知道复制一个对象（尤其是复杂的对象/实例）往往需要不小的计算开销（更别提复制一个数组的对象了）。但另一方面，复杂对象（群）的建立往往需要单独写一个函数来处理。那么如何从函数中输出这些对象？
c++的复制省略（copy elision）
https://gitcode.net/liuyuan185442111
08-28 1771
学习 A simple C++11 Thread Pool 时，发现函数返回了std::future，而std::future的拷贝构造和拷贝赋值都是delete的，感觉有点怪，查了一下，看到 编译器优化之Copy elision、URVO、NRVO 后恍然大悟。这里做一下总结整理。 复制省略或者译作省略不必要的复制（copy elision），是C++语言标准中定义的编译优化技术。 当一个class类型的临时对象用于初始化同类型的对象时，复制初始化通常优化为直接初始化。 GCC的编译选项-fno-elid
性能优化秘籍：如何避免C++拷贝构造函数中的不必要复制
在C++编程中，拷贝构造函数（Copy Constructor）是一种特殊的构造函数，用于创建一个与现有对象相同的新对象。这种构造函数通常用于将一个对象作为参数传递给函数、从函数返回对象、或是初始化类类型的新对象。拷贝...
【C++拷贝构造深入】：std::stack拷贝构造函数的工作原理
C++中的拷贝构造函数概念 在C++编程语言中，拷贝构造函数是类构造函数的一种特殊类型。它用于创建一个新对象作为现有对象的副本。拷贝构造函数的作用是确保对象可以被正确地复制，包括其内部的数据成员和指针指向...
C++ copy elision
茶佬牛逼
06-03 492
我们可以发现，首先在f_RVO()函数栈上(a4f地址)构造了一个对象，然后在main函数栈上开辟了一块临时地址(a9f)执行移动构造，再在main函数栈上真正要构造a的位置(a9e)执行移动构造。先在f_NRVO()函数栈上(a5f地址)构造了一个对象，然后在main函数栈上开辟了一块临时地址(aaf)执行移动构造，再在main函数栈上真正要构造a的位置(aae)执行移动构造。由于在c++17中RVO是必须的，所以-fno-elide-constructors不管用了，直接在main函数栈上原地构造了。
C++ Copy Elision
weixin_34235457的博客
06-17 137
故事得从 copy/move constructor 说起： The default constructor (12.1), copy constructor and copy assignment operator (12.8), move constructor and move assignment operator (12.8),...
C++构造与析构(12) - copy elision编译器优化
水草的专栏
05-25 956
Copy elision (或Copy omission)是一项编译器优化技术，用于避免不必要的对象拷贝。现如今基本上所有的编译器都使用它。
C++ Guaranteed Copy Elision
weixin_33936401的博客
03-15 213
考虑如下代码： struct S { S(){} // not copyable, not movable: S(S const &) = delete; S(S &&) = delete; }; S getS_GCE() { return S(); } int main() { S...
C++17之省略不必要的拷贝Copy Elision
janeqi1987的专栏
08-30 4997
从C++发展历史看来，c++ 17引入了一个规则，要求在满足一定的条件下避免对象的复制，这在以前是可选的。C++17中一个叫做强制复制省略的技术就是基于这个观点的。 至少包括以下两项内容： 1. 返回值优化（RVO），即通过将返回值所占空间的分配地点从被调用端转移至调用端的手段来避免拷贝操作。返回值优化包括具名返回值优化（NRVO）与无名返回值优化（URVO），两者的区别在于返回值是具名的...
浅谈C++11标准中的复制省略（copy elision，也叫RVO返回值优化）
davidhopper的博客
05-30 4813
严正声明：本文系作者davidhopper原创，未经许可，不得转载。 C++11以及之后的C++14、17标准均提出一项编译优化技术：复制省略（copy elision，也称复制消除），另外还有RVO（return value optimization，返回值优化）或NRVO（named return value optimization，具名返回值优化）的提法，其实都是一回事。维基百科的Copy...
copy elison & RVO & NRVO
weixin_30416871的博客
02-17 284
蓝色的博文 To summarize, RVO is a compiler optimization technique, while std::move is just an rvalue cast, which also instructs the compiler that it's eligible to move the object. The price of moving is l...
C++ 的复制省略(copy elision)特性
u012582383的博客
02-05 221
在上述代码中，①和②的意思是不一样的。②是直接声明，①则是先初始化一个临时的对象，在将其复制给test1（这里注意一下，如果把③的const去掉，程序会报错，因为。C++复制省略的介绍: https://zh.wikipedia.org/wiki/%E5%A4%8D%E5%88%B6%E7%9C%81%E7%95%A5。但由于copy elision特性的存在，拷贝初始化会被转换为直接初始化，即②会转换为①的形式。copy elision的特性可以在gcc中通过添加。生成的是一个临时的对象。
C++中减少内存拷贝的小技巧
jackuylove的博客
04-07 1807
1，在函数参数中使用&来代替，避免在调用函数时进行拷贝构造 class CTset { public: CTset() { cout << "construct a CTest" << endl; } CTset(const CTset& A) { cout << "Cop...
Intro to Copy Elision and (N)RVO
rsy56640的博客
01-09 343
不写了，这个东西越研究就越多，滚雪球一样，暂时撤退。。 感觉现在C++水平也算是勉强入门了，不再是C with STL了（逃）。 不过很多东西诸如compiling, parsing, linking and symbol table, etc 都慢慢有了一些细微的认知。。。参考来源： (主要3\4\5) [1].http://zh.cppreference.com/w/cpp/langu
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值