blocks|key|1145494|text|如果你看这篇文章，NRVO在MSDN中显示|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1145495|你会发现没有副本联合指导员打电话。|1145496|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms364057%2528vs.80%2529.aspx^0|9|C|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

If you look at this article <a href="http://msdn.microsoft.com/en-us/library/ms364057%28vs.80%29.aspx" rel="nofollow">NRVO revealed in MSDN</a>

You will see that no copy coinstructor called.

blocks|key|1145513|text|如果优化生效，将省略复制，但仍需要编译器检查副本构造函数是否可访问。否则，如果编译器(或其他编译器)决定不进行优化，代码将无效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145514|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The copying is omitted if the optimization takes effect, but the compiler is still required to check that the copy constructor is accessible. Otherwise the code would be invalid in case the compiler (or some other compiler) decided not to optimize.

blocks|key|565543|text|复制本身是省略了还是复制构造函数调用省略了？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|565544|这样做的目的是省略复制构造函数，但如果编译器不改变程序的语义，则允许编译器共享内存。|unstyled|565545|当对象类具有私有副本构造函数时，是否应该允许从函数返回对象？|565546|不，不允许。“应该”很难说，但允许它会让你做各种各样的恶作剧，打破封装。在C%2B%2B11中，您可以通过在返回中使用{}构造并移动构造该值来做到这一点。|offset|length|style|CODE|565547|entityMap^0|0|0|0|1J|2|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|Q|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|R|8|@$I|S|J|T|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|D|7|U|8|@]|9|@]|A|$]]]|N|$]]

<blockquote>
 Is the copying itself omitted or is the copy constructor invokation omitted?
</blockquote>

The idea is that the copy constructor is omitted, although the compiler is allowed to share the memory if it doesn't change the program's semantics.

<blockquote>
 Should returning an object from a function be allowed when the object class has a private copy constructor?
</blockquote>

No, it's not allowed. "Should it" is hard to say, but allowing it would allow you to do all sorts of shenanigans and break encapsulation. In C++11 you can sort of do this by using <code>{}</code> construction in the return and move constructing that value.

blocks|key|666096|text|是省略了复制本身，还是忽略了复制构造函数调用？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|666097|复制操作本身被取消。如果你看一下全文，它就清楚地提到了这一点：|666098|C%2B%2B+03+12.8复制类对象|666099|第15段|666100|当满足某些条件时，即使对象的复制构造函数和/或析构函数有副作用，也允许实现省略类对象的复制构造。在这种情况下，默示将省略复制操作的源和目标视为引用同一对象的两种不同方式，而该对象的销毁发生在如果不进行优化就会销毁两个对象的晚些时候。111)在下列情况下允许这种复制操作的省略(可以合并使用以消除多个副本)：
-在具有类返回类型的函数中的返回语句中，当表达式是具有与函数返回类型相同的cv-非限定类型的非易失性自动对象的名称时，可以通过将自动对象直接构造到函数的返回值来省略操作。
-当没有绑定到引用(12.2)的临时类对象被复制到具有相同cv-非限定类型的类对象时，可以通过将临时对象直接构造到省略副本的目标中来省略操作……|blockquote|666101|当对象类具有私有副本构造函数？时，应该允许从函数返回对象。|666102|RVO和NRVO是编译器的优化，编译器允许使用，但不能保证，如果特定的哑编译器不能提供这些优化怎么办？|666103|如果没有可访问的复制构造函数，代码将中断在所有这类编译器上，这是不需要的。假定复制构造函数应该是可访问的。|666104|entityMap^0|0|N|0|0|0|G|0|0|4|0|6K|3|6O|20|0|0|F|0|N|6|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|L|3|M|5|N|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1H|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|V|$]]

Is the copying itself omitted or is the copy constructor invokation omitted? 

The copying operation itself is ommitted. If you have a look at the full quote it clearly mentions so: 

C++ 03 12.8 copying class objects 

Para 15

<blockquote>
 When certain criteria are met, an implementation is allowed to omit the copy construction of a class object, even if the copy constructor and/or destructor for the object have side effects. In such cases, the implemen-tation treats the source and target of the omitted copy operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects
 would have been destroyed without the optimization.111)This elision of copy operations is permitted in the following circumstances (which may be combined to eliminate multiple copies): 
 
 — in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object with the same cv-unqualified type as the function return type, the copy operation can be omitted by constructing the automatic object directly into the function’s return value. 
 
 — when a temporary class object that has not been bound to a reference (12.2) would be copied to a class object with the same cv-unqualified type, the copy operation can be omitted by constructing the temporary object directly into the target of the omitted copy.....
</blockquote>

Should returning an object from a function be allowed when the object class has a private copy constructor? 

RVO and NRVO are compiler optimizations, allowed by the compiler but not guaranteed What happens if a particular dumb compiler cannot provide these optimizations? 
Without a accessible copy constructor the code will break on all such compilers which is not desired. Given that the copy constructor should be accessible.

blocks|key|666129|text|根据官方说法，RVO/NRVO并不影响程序的格式是否良好。该标准显式地允许省略来自复制构造函数的任何副作用，但是仍然需要对复制构造函数进行访问检查。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|666130|但是，大多数编译器不会对省略的复制构造函数进行访问检查，除非您要求尽可能严格地强制执行规则。我不完全确定，但我似乎还记得曾经使用过一些跳过访问检查的方法，即使您确实要求严格遵守(但我不太清楚)。|666131|编辑(以纠正我认为在其他一些答案中表达的误解)：|666132|标准某一节中的段落按顺序阅读。第一段中适用于某一情况的要求总是适用的。在这种情况下，可以在第15段中略去副作用，但在第14段之前，我们看到：|666133|如果隐式使用对象的复制构造函数或复制赋值操作符，并且无法访问特殊的成员函数，则程序的格式是错误的(第11条)。|blockquote|666134|因此，如果第14段中指定的访问检查已经通过，我们只会到第15段(可以省略复制)。|666135|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|T|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|N|$]]

Officially, no, RVO/NRVO do not affect whether a program is well formed or not. The standard explicitly allows any side effects from the copy constructor to be omitted, but access checking on the copy constructor is still supposed to be done.

Most compilers, however, will no do access checking on omitted copy constructors unless you ask for the rules to be enforced as strictly as possible. I'm not absolutely sure, but I seem to recall having used a few that skipped the access check even when you did ask for strict compliance (but I don't remember for sure).

Edit (to correct what I see as a misconception expressed in some of the other answers):

The paragraphs in a section of the standard are intended to be read in order. The requirements in the first paragraph that apply to a situation always apply. In this case, the permission to omit side effects is in paragraph 15. Immediately before that in paragraph 14, however, we see that:

<blockquote>
 A program is ill-formed if the copy constructor or the copy assignment operator for an object is implicitly used and the special member function is not accessible (clause 11).
</blockquote>

So, we only get to paragraph 15 (where copying can be omitted) if the access check specified in paragraph 14 has already been passed.

blocks|key|666163|text|被省略的是副本本身。无论何时实际完成复制，都必须使用复制构造函数来完成，但是有几种情况允许编译器对副本进行优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|666164|堆栈返回较大和非结荚对象。调用方为对象准备一个空格，并将指向该空间的指针作为隐藏参数传递。被调用者将该对象复制到该空间中。在这里可以进行两种优化：|666165|被调用者可以直接在返回空间中创建对象。编译器必须确保该对象将被返回，也就是说，只有返回返回该对象的语句，并且不能抛出插入的代码。|ordered-list-item|666166|如果将结果分配给变量，调用方可以传递其地址，而不是创建临时地址。这只能在变量被初始化或者效果与调用operator=没有明显区别的情况下才能实现，这基本上是如果类型具有默认构造函数、析构函数和operator=。|offset|length|style|CODE|666167|entityMap^0|0|0|0|1D|9|2O|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|R|8|@$I|S|J|T|K|L]|$I|U|J|V|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|N|$]]

It's the copy itself that is omitted. Whenever copying is actually done, it must be done using the copy constructor, but there are several cases where the compiler is allowed to optimize away a copy.

Larger and non-pod objects are returned by the stack. The caller prepares a space for the object and passes pointer to that space as hidden parameter. The callee than copies the object into that space. Two optimizations can be done here:

<ol>
<li>The callee can create the object directly in the return space. The compiler has to be sure the object is going to be returned, that is only return statements returning that object may follow and intervening code must not throw.</li>
<li>If the result is assigned to variable, the caller may pass it's address instead of creating a temporary. This can only be done if the variable is either being initialized or if the effect would provably not differ from calling <code>operator=</code>, which is basically if the type has default constructor, destructor and <code>operator=</code>.</li>
</ol>

I can't get my head around RVO (and NRVO) definition because of multiple questions <a href="https://stackoverflow.com/q/3905869/57428">like this one</a> that to me look assuming that RVO omits a copy constructor. Now according to 12.8.15

<blockquote>
 In such cases, the implementation treats the source and target of the omitted copy operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.
</blockquote>

Which looks like it's not the copy constructor call is being omitted, but the copy itself - just the object is constructed at the "copy" location in the first place and so there's no "original" object and no copying at all. So even when a class has a <code>private</code> copy constructor it can be returned from a function when RVO kicks in because there's no copy.

Do I get it right? Is the copying itself omitted or is the copy constructor invokation omitted? Should returning an object from a function be allowed when the object class has a private copy constructor?

Is the object copied or not when RVO/NRVO kicks in?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我无法理解RVO (和NRVO)的定义，因为存在多个问题，在我看来，这些问题假设RVO忽略了一个复制构造函数。现在根据12.8.15在这种情况下，实现将省略复制操作的源和目标视为引用同一对象的两种不同方式，并且该对象的销毁发生在如果不进行优化就会销毁这两个对象的后期。它看起来不是复制构造函数调用被省略了，而是复制本身-...

问当RVO/NRVO启动时，对象是否被复制？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当RVO/NRVO启动时，对象是否被复制？EN