blocks|key|1577481|text|第一个应该比第二个好。为什么？std::vector是一个动态大小向量。这意味着，如果你想超越它的极限，它将调整大小。这个调整是怎么发生的？分配新内存，复制everything，并删除前一个内存。这意味着，如果容量不够，使用push_back()可能会触发此分配。第一种方法从一开始就使std::vector具有所需的容量，因此在插入元素时不需要移动。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|1577482|请注意，您可以使一个特定容量的std::vector，然后push_back()将不会做任何额外的分配，这将是相当有效的。|1577483|entityMap^0|F|B|34|B|3Z|B|26|A|0|F|B|T|B|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]|$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|E|@]|F|$]]|$1|I|3|-4|5|6|7|Y|8|@]|E|@]|F|$]]]|J|$]]

The first one should be better than the second. Why? <code>std::vector</code> is a dynamic size vector. It means that if u wanna push over its limit, it is gonna resize. How this resize is happening? Allocating new memory, copying everything, and deleting the previous one. This means that using <code>push_back()</code> may trigger this allocation if the capacity is not enough. The first one makes the <code>std::vector</code> with the required capacity from the beginning so no moving required when inserting elements

Note that u can make a <code>std::vector</code> of a specific capacity, and then <code>push_back()</code> is not gonna do any additional allocation, which shall be quite efficient

blocks|key|627166|text|效率的最佳选择是在使用reserve或emplace_back之前确定所需的元素数。这保证不会发生任何重新分配。它也更灵活一些。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|627167|按照所需的大小创建向量的替代方法要求您提前构造向量的所有元素，然后将其分配给已经构造的对象。|627168|entityMap^0|B|7|J|C|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The optiumum choice for efficiency is to <code>reserve</code> the required number of elements before using <code>push_back</code> or <code>emplace_back</code>. This guarantees that no reallocations will occur. It's also somewhat more flexible.

The alternative of creating the vector at the required size requires you to construct all the elements of the vector ahead of time and then assign to the already constructed objects.

blocks|key|541773|text|以下是摘自Cplusplus.com的参考资料：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|541774|在内部，向量使用动态分配的数组来存储它们的元素。当插入新元素时，可能需要重新分配这个数组，以增加大小，这意味着分配一个新数组并将所有元素移动到它。就处理时间而言，这是一个相对昂贵的任务，因此，向量不会在每次向容器中添加元素时重新分配。
相反，矢量容器可以为可能的增长分配一些额外的存储空间，因此容器的实际容量可能大于包含其元素所严格需要的存储量(即其大小)。|blockquote|541775|现在让我们看看这两种类型之间的区别：|541776|1.+vector<int>arr：|style|CODE|541777|当您声明vector<int>arr时，向量大小取决于通常为0的实现。因此，在这种情况下，向量将从0开始。|unordered-list-item|541778|每当您尝试push_back()时，向量都会查看当前的容量是否足以容纳该元素。|541779|如果容量已经足够容纳该元素，则只需在下一个空内存空间中分配新元素。|541780|如果当前容量已满，则向量将重新分配空间。例如：如果您的当前容量为4，并且所有的容量都用完了，并且尝试向后推一个元素，那么向量将重新分配空间(例如，8个元素)。新的容量几乎总是比当前容量增加一倍，然后将元素推入向量。|BOLD|541781|如果新空间不能扩展到当前内存位置本身(可能是因为相邻的空间已经被一些其他变量占用)，那么向量就会从原来的位置完全转移到一个我们有足够的所需空间的新位置。这个过程涉及到将向量的所有元素复制到新的位置，这将占用时间。|541782|如果发生了重新分配，则重新分配本身就会达到整个调整大小的线性。但是push_back()+的摊销时间复杂度仍然保持不变，即O(1)。|541783|2.+vector<int>arr(n)：|541784|这个声明将初始化向量，在开始时为n个元素预先分配空间。|541785|只要您想要添加另一个元素，就可以使用[]操作符分配下一个索引。|541786|因此，假设您的n=5和您已经分配了前两个索引。您可以直接使用arr[2]=4来添加第三个元素。没有必要使用push_back()，因为您已经为向量中的n个元素分配了所需的空间。|541787|如果要添加超过n个元素，仍然可以使用push_back()。但是对于前n个元素，赋值是直接使用[+]运算符完成的，因为向量已经被调整为容纳n个元素。|541788|如果不想使用reserve()，另一种选择是使用vector<int>arr(n)。它指示所创建的向量可以至少存储指定元素的数目，而不必重新分配内存。在本例中，初始向量大小为零，必须使用.push_back()添加任何新元素。但是，首先保留一个空间，然后使用push_back可以节省重新分配和复制整个数组到新内存位置的耗时过程。|541789|结论：|541790|因此，由于我们不必总是使用第二种类型来分配新的空间和复制向量的所有元素，因此第二类型的声明比第一种类型的声明效率要高得多--您在开始时知道向量的大小，本身。|541791|效率如下：|541792|vector<int>arr(n);并使用[+]运算符直接在每个索引上赋值元素。|ordered-list-item|541793|arr.reserve(n);在向量声明后使用.push_back()方法添加新元素。|541794|vector<int>arr;和使用.push_back()方法添加新元素。|541795|希望这能回答你的问题！|541796|entityMap|0|LINK|mutability|MUTABLE|url|http://cplusplus.com/^0|5|D|0|0|0|0|3|E|0|4|E|0|5|B|0|0|D|6|29|B|0|2B|K|0|X|B|19|L|X|B|0|0|L|3|H|0|0|R|0|0|V|I|2|0|0|2G|7|3|U|8|1H|B|0|0|22|I|B|1B|3|0|0|4L|6|9|O|H|2L|C|0|0|3|0|0|26|0|0|5|0|0|14|0|I|L|3|0|0|17|0|F|N|C|0|0|12|0|F|I|C|0|0|B|0^^$0|@$1|2|3|4|5|6|7|1Z|8|@]|9|@$A|20|B|21|1|22]]|C|$]]|$1|D|3|E|5|F|7|23|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|24|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|25|8|@$A|26|B|27|K|L]]|9|@]|C|$]]|$1|M|3|N|5|O|7|28|8|@$A|29|B|2A|K|L]]|9|@]|C|$]]|$1|P|3|Q|5|O|7|2B|8|@$A|2C|B|2D|K|L]]|9|@]|C|$]]|$1|R|3|S|5|O|7|2E|8|@]|9|@]|C|$]]|$1|T|3|U|5|O|7|2F|8|@$A|2G|B|2H|K|V]|$A|2I|B|2J|K|V]]|9|@]|C|$]]|$1|W|3|X|5|O|7|2K|8|@$A|2L|B|2M|K|V]]|9|@]|C|$]]|$1|Y|3|Z|5|O|7|2N|8|@$A|2O|B|2P|K|V]|$A|2Q|B|2R|K|V]|$A|2S|B|2T|K|L]]|9|@]|C|$]]|$1|10|3|11|5|6|7|2U|8|@$A|2V|B|2W|K|V]|$A|2X|B|2Y|K|L]]|9|@]|C|$]]|$1|12|3|13|5|O|7|2Z|8|@$A|30|B|31|K|V]]|9|@]|C|$]]|$1|14|3|15|5|O|7|32|8|@$A|33|B|34|K|V]|$A|35|B|36|K|L]]|9|@]|C|$]]|$1|16|3|17|5|O|7|37|8|@$A|38|B|39|K|V]|$A|3A|B|3B|K|L]|$A|3C|B|3D|K|L]|$A|3E|B|3F|K|L]]|9|@]|C|$]]|$1|18|3|19|5|O|7|3G|8|@$A|3H|B|3I|K|V]|$A|3J|B|3K|K|L]|$A|3L|B|3M|K|L]]|9|@]|C|$]]|$1|1A|3|1B|5|6|7|3N|8|@$A|3O|B|3P|K|V]|$A|3Q|B|3R|K|L]|$A|3S|B|3T|K|L]|$A|3U|B|3V|K|L]]|9|@]|C|$]]|$1|1C|3|1D|5|6|7|3W|8|@$A|3X|B|3Y|K|V]]|9|@]|C|$]]|$1|1E|3|1F|5|6|7|3Z|8|@$A|40|B|41|K|V]]|9|@]|C|$]]|$1|1G|3|1H|5|6|7|42|8|@$A|43|B|44|K|V]]|9|@]|C|$]]|$1|1I|3|1J|5|1K|7|45|8|@$A|46|B|47|K|V]|$A|48|B|49|K|L]|$A|4A|B|4B|K|L]]|9|@]|C|$]]|$1|1L|3|1M|5|1K|7|4C|8|@$A|4D|B|4E|K|V]|$A|4F|B|4G|K|L]|$A|4H|B|4I|K|L]]|9|@]|C|$]]|$1|1N|3|1O|5|1K|7|4J|8|@$A|4K|B|4L|K|V]|$A|4M|B|4N|K|L]|$A|4O|B|4P|K|L]]|9|@]|C|$]]|$1|1P|3|1Q|5|6|7|4Q|8|@$A|4R|B|4S|K|V]]|9|@]|C|$]]|$1|1R|3|-4|5|6|7|4T|8|@]|9|@]|C|$]]]|1S|$1T|$5|1U|1V|1W|C|$1X|1Y]]]]

Below is a reference taken from <a href="http://cplusplus.com/" rel="nofollow noreferrer">Cplusplus.com</a> :

<blockquote>
 Internally, vectors use a dynamically allocated array to store their
 elements. This array may need to be reallocated in order to grow in
 size when new elements are inserted, which implies allocating a new
 array and moving all elements to it. This is a relatively expensive
 task in terms of processing time, and thus, vectors do not reallocate
 each time an element is added to the container.
 
 Instead, vector containers may allocate some extra storage to
 accommodate for possible growth, and thus the container may have an
 actual capacity greater than the storage strictly needed to contain
 its elements (i.e., its size).
</blockquote>

<hr>

Now let's look at the difference between the two types :

<h1>1. <code>vector&lt;int&gt;arr</code> :</h1>

<ul>
<li>When you declare <code>vector&lt;int&gt;arr</code>, the vector size depends on
implementation which is usually 0. So, the vector in this case will
start at size 0.</li>
<li>Whenever you try to <code>push_back()</code> , the vector will see if the
present capacity is enough to accommodate that element.</li>
<li>If the capacity is already enough to accommodate the element, it just assigns the new element in the next empty memory space.</li>
<li>If the current capacity is full, the vector will reallocate the space. Eg. If you have a current capacity of 4 and it's all used up and you try to pushback an element, then the vector will reallocate the space (for say, 8 elements. The new capacity is almost always doubled than the current capacity) and then push the element into the vector.</li>
<li>If the new space can't be extended at the present memory location itself (maybe because the space adjacent to it is already occupied by some other variables), then the vector is completely shifted from its original location to a new location where we have sufficient amount of needed space. This process involves copying all the elements of vector to the new location which takes up time.</li>
<li>If a reallocation happens, the reallocation is itself up to linear in the entire size. But the amortized time-complexity of <code>push_back()</code> still remains constant, i.e O(1)</li>
</ul>

<h1>2. <code>vector&lt;int&gt;arr(n)</code> :</h1>

<ul>
<li>This declaration will initialise the vector with space for n elements pre-allocated, at the start itself.</li>
<li>whenever you want to add another element you can just assign the next index using <code>[]</code> operator.</li>
<li>So, say that your <code>n=5</code> and you have assigned first two index. You can directly use like <code>arr[2]=4</code> to add a third element. There's no need to use <code>push_back()</code> as you have already allocated the space needed for n elements in your vector.</li>
<li>You can still use <code>push_back()</code> if you want to add more than n elements. But for the first n elements, the assignment is done directly using <code>[ ]</code> operator as vector has already been sized to hold n elements.</li>
</ul>

<hr>

Another choice would to use <code>reserve()</code> if you don't want to intialise using <code>vector&lt;int&gt;arr(n)</code>.
It indicates that the vector is created such that it can store at least the number of the specified elements without having to reallocate memory.
In this case, your initial vector size will be zero and you have to use <code>.push_back()</code> to add any new element. But, first reserving a space and then using push_back will save you from the time-consuming process of reallocation and copying of whole array to new memory location.

<h3>Conclusion :</h3>

So, since we don't always have to keep allocating new space and copying all the elements of vector using the 2nd type, therefore the 2nd type of declaration is much more efficient than the first type of declaration of you know the size of vector at the start itself. 

The efficiency will be as follows:

<ol>
<li><code>vector&lt;int&gt;arr(n);</code> and directly assigning elements at each index using <code>[ ]</code> operator.</li>
<li><code>arr.reserve(n);</code> after vector declaration and adding new elements using <code>.push_back()</code> method.</li>
<li><code>vector&lt;int&gt;arr;</code> and adding new elements using <code>.push_back()</code> method.</li>
</ol>

Hope this answers your question !

Let us say we know the size of a vector we will be needing, (say 'n').

Does using <code>vector&lt;int&gt; Array(n);</code> offer any improvements over using <code>Array.push_back(element)</code> one by one?

Which is recommended and why?

Does declaring a vector with size offer any improvements over using push_back in C++

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

假设我们知道我们所需要的向量的大小(例如'n')。使用vector<int> Array(n);比一个接一个地使用Array.push_back(element)提供什么改进吗？推荐哪一种?为什么？

问声明一个大小的向量比在C++中使用C++提供任何改进吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问声明一个大小的向量比在C++中使用C++提供任何改进吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问声明一个大小的向量比在C++中使用C++提供任何改进吗？
EN