blocks|key|977534|text|返回|type|unstyled|depth|inlineStyleRanges|entityRanges|data|977535|+std::pair**?**时，是否会发生RVO|blockquote|offset|length|style|BOLD|CODE|977536|977537|977538|是的，它可以。|977539|977540|+这肯定会发生吗？|977541|977542|977543|不，不是。|977544|977545|C%2B%2B11标准:第12.8/31节：|977546|977547|当满足某些条件时，允许实现省略类对象的复制/移动构造，即使对象的复制/移动构造函数和/或析构函数具有副作用。|977548|977549|977550|复制省略并不是一个有保证的功能。这是一种允许编译器在任何时候执行的优化。没有什么特别的w.r.t+std::pair。如果编译器足够好，可以检测到优化机会，它就会这么做。所以你的问题是特定于编译器的，但是的，同样的规则也适用于std::pair和任何其他类。|977551|entityMap^0|0|1|B|H|8|1|9|0|0|0|0|7|0|0|1|8|0|0|0|0|5|0|0|0|I|0|0|0|1I|0|0|0|0|3L|1D|9|35|9|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@$E|18|F|19|G|H]|$E|1A|F|1B|G|H]|$E|1C|F|1D|G|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1G|8|@$E|1H|F|1I|G|H]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1K|8|@$E|1L|F|1M|G|H]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1P|8|@$E|1Q|F|1R|G|H]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1T|8|@$E|1U|F|1V|G|H]]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1X|8|@$E|1Y|F|1Z|G|H]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|20|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|22|8|@$E|23|F|24|G|H]|$E|25|F|26|G|I]|$E|27|F|28|G|I]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|29|8|@]|9|@]|A|$]]]|15|$]]

<blockquote>
 Will RVO happen when returning <code>std::pair</code>? 
</blockquote>

Yes it can.

<blockquote>
 Is it guaranteed to happen? 
</blockquote>

No it is not.

<hr>

C++11 standard: Section 12.8/31: 

<blockquote>
 When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects.
</blockquote>

Copy elision is not a guaranteed feature. It is an optimization compilers are allowed to perform whenever they can. There is nothing special w.r.t <code>std::pair</code>. If a compiler is good enough to detect an optimization opportunity it will do so. So your question is compiler specific but yes same rule applies to <code>std::pair</code> as to any other class.

blocks|key|4548146|text|RVO或复制省略依赖于编译器，所以如果你想拥有RVO并避免调用复制构造函数，最好的选择是使用指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4548147|在我们的产品中，我们使用指针和boost容器指针来避免复制构造函数。这确实带来了大约10%25的性能提升。|4548148|对于你的问题，在选项1中，U和V的拷贝构造函数不会被调用，因为你不是返回U或V，而是返回std::pair对象，所以它的拷贝构造函数将被调用，大多数编译器在这里肯定会使用RVO来避免这种情况。|4548149|谢谢Niraj+Rathi|4548150|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

RVO or Copy elision is dependant on compiler so if you want to have RVO and avoid call to Copy constructor best option is to use pointers.

In our product we use use pointers and boost containers pointer to avoid Copy constructor. and this indeed gives performance boost of around 10%.

Coming to your question,
In option 1 U and V's copy constructor will not be called as you are not returning U or V but returning std::pair object so it's copy constructor will be called and most compilers will definately use RVO here to avoid that.

Thanks
Niraj Rathi

blocks|key|764611|text|虽然不能保证RVO，但在C%2B%2B11中，我认为您定义的函数至少必须移动-返回，所以我建议保留更清晰的定义，而不是扭曲它以接受输出变量(除非您有使用它们的特定策略)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|764612|此外，即使本例使用了RVO，显式地使用make_pair也意味着您将始终至少有一个额外的对构造，从而执行移动操作。将其更改为返回花括号初始化的表达式：|764613|return+{+getU(),+getV()+};|code-block|syntax|javascript|764614|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

While RVO is not guaranteed, in C++11 the function as you have defined it I believe MUST move-return at the very least, so I would suggest leaving the clearer definition rather than warping it to accept output-variables (Unless you have a specific policy for using them).

Also, even if this example did use RVO, your explicit use of make_pair means you will always have at least one extra pair construction and thus a move operation. Change it to return a brace-initialized expression:

<pre><code>return { getU(), getV() };
</code></pre>

blocks|key|4548205|text|如果您在创建u和v对之后需要对它们进行额外的工作，我发现以下模式在C%2B%2B17中非常灵活：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4548206|pair<U,V>+myfunc()
{
++auto+out+=+make_pair(getU(),getV());
++auto&+[u,+v]+=+out;
++//+Work+with+u+and+v
++return+out;
}|code-block|syntax|javascript|4548207|对于编译器来说，使用命名返回值优化应该是非常简单的情况|4548208|entityMap^0|6|1|8|1|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

If you need to do additional work on <code>u</code> and <code>v</code> after having created the pair, I find the following pattern pretty flexible in C++17:
<pre><code>pair&lt;U,V&gt; myfunc()
{
 auto out = make_pair(getU(),getV());
 auto&amp; [u, v] = out;
 // Work with u and v
 return out;
}
</code></pre>
This should be a pretty easy case for the compiler to use named return value optimization

A function needs to return two values to the caller. What is the best way to implement?

Option 1:

<pre><code>pair&lt;U,V&gt; myfunc()
{
...
return make_pair(getU(),getV());
}

pair&lt;U,V&gt; mypair = myfunc();
</code></pre>

Option 1.1:

<pre><code>// Same defn
U u; V v;
tie(u,v) = myfunc();
</code></pre>

Option 2:

<pre><code>void myfunc(U&amp; u , V&amp; v)
{
u = getU(); v= getV();
}

U u; V v;
myfunc(u,v);
</code></pre>

I know with Option2, there are no copies/moves but it looks ugly. Will there be any copies/moves occur in Option1, 1.1? Lets assume U and V are huge objects supporting both copy/move operations.

Q: Is it theoretically possible for any RVO/NRVO optimizations as per the standard? If yes, has gcc or any other compiler implemented yet?

Will RVO happen when returning std::pair?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

函数需要向调用者返回两个值。最好的实现方式是什么？选项1：pair<U,V> myfunc(){...return make_pair(getU(),getV());}pair<U,V> mypair = myfunc();选项1.1：// Same defnU u; V v;tie(u,v) = myfunc();选...

问返回std::pair时会发生RVO吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回std::pair时会发生RVO吗？EN