blocks|key|540562|text|如果您在向量中持有的对象的复制构造函数中没有疯狂的副作用，则不会。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|540563|引入emplace_back是为了优化不必要的复制和移动。|offset|length|style|CODE|540564|entityMap^0|0|2|C|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If you don't have crazy side-effects in copy constructor of the objects that you hold in your vector, then no.

<code>emplace_back</code> was introduced to optimise-out unnecessary copying and moving.

blocks|key|1540763|text|我构造了一个简短的示例，当push_back被emplace_back替换时，它实际上无法编译。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1540764|#include+<vector>
struct+S+{
++++S(double)+{}
++private:
++++explicit+S(int)+{}
};
int+main()+{
++++std::vector<S>().push_back(0);+//+OK
++++std::vector<S>().emplace_back(0);+//+error!
}|code-block|syntax|javascript|1540765|对push_back的调用需要将其参数0从int类型转换为S类型。因为这是一个隐式转换，所以不考虑显式构造函数S::S(int)，并且调用S::S(double)。另一方面，emplace_back执行直接初始化，因此考虑了S::S(double)和S::S(int)。后者是一个更好的匹配，但它是private，所以程序是错误的.|1540766|entityMap^0|D|9|N|C|0|0|1|9|J|1|L|3|T|1|1J|9|1X|C|2F|C|34|C|3H|9|45|7|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|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|N|$]]

I constructed a short example that actually fails to compile when <code>push_back</code> is replaced by <code>emplace_back</code>:

<pre><code>#include &lt;vector&gt;
struct S {
 S(double) {}
 private:
 explicit S(int) {}
};
int main() {
 std::vector&lt;S&gt;().push_back(0); // OK
 std::vector&lt;S&gt;().emplace_back(0); // error!
}
</code></pre>

The call to <code>push_back</code> needs to convert its argument <code>0</code> from type <code>int</code> to type <code>S</code>. Since this is an implicit conversion, the explicit constructor <code>S::S(int)</code> is not considered, and <code>S::S(double)</code> is called. On the other hand, <code>emplace_back</code> performs direct initialization, so both <code>S::S(double)</code> and <code>S::S(int)</code> are considered. The latter is a better match, but it's <code>private</code>, so the program is ill-formed.

blocks|key|1261482|text|在异常情况下，emplace版本根本不创建所需类型的对象。这可能会导致一个错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1261483|考虑下面的示例，它使用std::vector来简化操作(假设uptr的行为类似于std::unique_ptr，除非构造函数不是显式的)：|1261484|std::vector<uptr<T>>+vec;
vec.push_back(new+T());|code-block|syntax|javascript|1261485|它是例外安全的。创建一个临时uptr<T>以传递给push_back，后者被移动到向量中。如果向量重新分配失败，则分配的T仍然由一个正确删除它的智能指针所拥有。|1261486|与之相比：|1261487|std::vector<uptr<T>>+vec;
vec.emplace_back(new+T());|1261488|不允许emplace_back创建临时对象。ptr将在向量中创建一次.如果重新分配失败，就没有就地创建的位置，也不会创建任何智能指针。T将被泄露。|1261489|当然，最好的选择是：|1261490|std::vector<std::unique_ptr<T>>+vec;
vec.push_back(make_unique<T>());|1261491|这相当于第一个，但使智能指针创建显式。|1261492|entityMap^0|7|7|0|B|B|U|4|14|F|0|0|E|7|P|9|1O|1|0|0|0|3|C|M|3|1V|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1K|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1T|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1U|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1V|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|11|$]]

The <code>emplace</code> versions don't create an object of the desired type at all under exception circumstances. This can lead to a bug.

Consider the following example, which uses <code>std::vector</code> for simplicity (assume <code>uptr</code> behaves like <code>std::unique_ptr</code>, except the constructor is not explicit):

<pre><code>std::vector&lt;uptr&lt;T&gt;&gt; vec;
vec.push_back(new T());
</code></pre>

It is exception-safe. A temporary <code>uptr&lt;T&gt;</code> is created to pass to <code>push_back</code>, which is moved into the vector. If reallocation of the vector fails, the allocated <code>T</code> is still owned by a smart pointer which correctly deletes it.

Compare to:

<pre><code>std::vector&lt;uptr&lt;T&gt;&gt; vec;
vec.emplace_back(new T());
</code></pre>

<code>emplace_back</code> is not allowed to create a temporary object. The <code>ptr</code> will be created once, in-place in the vector. If reallocation fails, there is no location for in-place creation, and no smart pointer will ever be created. The <code>T</code> will be leaked.

Of course, the best alternative is:

<pre><code>std::vector&lt;std::unique_ptr&lt;T&gt;&gt; vec;
vec.push_back(make_unique&lt;T&gt;());
</code></pre>

which is equivalent to the first, but makes the smart pointer creation explicit.

blocks|key|540651|text|int+main()+{
std::vector<S>().push_back(0);
std::vector<S>().emplace_back(0);+
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|540652|在emplace_back中给出struct构造函数，即上面的代码如下所示|unstyled|540653|int+main()+{
std::vector<S>().push_back(0);+
std::vector<S>().emplace_back(S(0));+
}|540654|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>int main() {
std::vector&lt;S&gt;().push_back(0);
std::vector&lt;S&gt;().emplace_back(0); 
}
</code></pre>

Give struct constructor in emplace_back i.e The above code will be like this

<pre><code>int main() {
std::vector&lt;S&gt;().push_back(0); 
std::vector&lt;S&gt;().emplace_back(S(0)); 
}
</code></pre>

blocks|key|1261527|text|假设可以从大括号初始化器初始化用户定义的类。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261528|struct+S+{
++++int+value;
};|code-block|syntax|javascript|1261529|然后|1261530|std::vector<S>+v;

v.push_back({0});++++//+fine
v.emplace_back({0});+//+template+type+deduction+fails|1261531|std::vector::emplace_back是模板函数，std::vector::push_back是非模板函数.使用带大括号的初始化器，std::vector::emplace_back将失败，因为模板参数推导失败。|offset|length|style|CODE|1261532|非推导语境
6)参数P，其A是带括号的列表，但P不是std::initializer_list或引用：|blockquote|1261533|活着|1261534|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/container/vector/emplace_back|1|https://en.cppreference.com/w/cpp/container/vector/push_back|2|http://en.cppreference.com/w/cpp/language/template_argument_deduction#Non-deduced_contexts|3|https://wandbox.org/permlink/vSSIjKCgkHgTYfPG^0|0|0|0|0|0|P|V|M|20|P|0|P|0|V|M|1|2V|6|2|0|Q|L|0|0|2|3|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1B|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1D|8|@$M|1E|N|1F|O|P]|$M|1G|N|1H|O|P]|$M|1I|N|1J|O|P]]|9|@$M|1K|N|1L|1|1M]|$M|1N|N|1O|1|1P]|$M|1Q|N|1R|1|1S]]|A|$]]|$1|Q|3|R|5|S|7|1T|8|@$M|1U|N|1V|O|P]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1W|8|@]|9|@$M|1X|N|1Y|1|1Z]]|A|$]]|$1|V|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]|13|$5|Y|Z|10|A|$11|14]]|15|$5|Y|Z|10|A|$11|16]]|17|$5|Y|Z|10|A|$11|18]]]]

Suppose a user-defined class could be initialized from braced-initializer. e.g.

<pre><code>struct S {
 int value;
};
</code></pre>

then

<pre><code>std::vector&lt;S&gt; v;

v.push_back({0}); // fine
v.emplace_back({0}); // template type deduction fails
</code></pre>

<a href="https://en.cppreference.com/w/cpp/container/vector/emplace_back" rel="nofollow noreferrer"><code>std::vector::emplace_back</code></a> is template function but <a href="https://en.cppreference.com/w/cpp/container/vector/push_back" rel="nofollow noreferrer"><code>std::vector::push_back</code></a> is non-template function. With a braced-initializer <code>std::vector::emplace_back</code> would fail because <a href="http://en.cppreference.com/w/cpp/language/template_argument_deduction#Non-deduced_contexts" rel="nofollow noreferrer">template argument deduction</a> fails.

<blockquote>
 Non-deduced contexts
 
 6) The parameter P, whose A is a braced-init-list, but P is not <code>std::initializer_list</code> or a reference to one:
</blockquote>

<a href="https://wandbox.org/permlink/vSSIjKCgkHgTYfPG" rel="nofollow noreferrer">LIVE</a>

Can I break a valid C++03 program by replacing <code>std::vector::push_back</code> with <code>emplace_back</code> and compiling it with C++ 11 compiler? From reading <code>emplace_back</code> reference I gather it shouldn't happen, but I'll admit I don't fully get rvalue references.

Are there any cases where it is incorrect to replace push_back with emplace_back?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我可以通过用C++03替换std::vector::push_back并用C++ 11编译器编译来破坏一个有效的emplace_back程序吗？通过阅读emplace_back引用，我认为这是不应该发生的，但我承认我没有完全获得rvalue引用。

问是否存在用push_back替换emplace_back不正确的情况？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否存在用push_back替换emplace_back不正确的情况？EN