blocks|key|2120067|text|我明显倾向于小的作用域(例如，如果变量只在最里面的循环中使用，就在最里面的循环中声明它)，但是对于大的作用域，这可能会导致大量的分配。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2120068|因此，如果此循环是一个性能问题，请尝试在循环外声明变量，并仅在循环内清除它-然而，只有在向量的(保留)大小保持不变的情况下，这才是有利的。如果你正在调整向量的大小，那么无论如何你都会得到重新分配。|2120069|不要使用原始数组，因为它不会给你带来任何好处，只会带来麻烦。|2120070|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I have a clear preference for small scopes (i.e. declaring the variable in the innermost loop if it’s only used there) but for large sizes this could cause a lot of allocations.

So if this loop is a performance problem, try declaring the variable outside the loop and merely clearing it inside the loop – however, this is only advantageous if the (reserved) size of the vector stays identical. If you are resizing the vector, then you get reallocations anyway.

Don’t use a raw array – it doesn’t give you any advantage, and only trouble.

blocks|key|1104671|text|使用向量与数组的开销很小，特别是当您从向量中获得许多有用的功能时。在内部，向量分配一个数组。因此，向量是可行的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1104672|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 overhead of using a vector vs an array is minor, especially when you are getting a lot of useful functionality from the vector. Internally a vector allocates an array. So vector is the way to go.

blocks|key|2125005|text|为什么不这样做呢：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2125006|{
++++vector<+vector<long+long>+>+vec(n1,+vector<long+long>(n2));

++++for+(int+i=0;+i<bound;+i%2B%2B){

+++++++++//about+three+more+for-loops+here

+++++++++vec.clear();
++++}
}|code-block|syntax|javascript|2125007|编辑：增加作用域大括号;-)|offset|length|style|BOLD|2125008|entityMap^0|0|0|0|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|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Why not something like that :

<pre><code>{
 vector&lt; vector&lt;long long&gt; &gt; vec(n1, vector&lt;long long&gt;(n2));

 for (int i=0; i&lt;bound; i++){

 //about three more for-loops here

 vec.clear();
 }
}
</code></pre>

Edit: added scope braces ;-)

blocks|key|1744736|text|除了前面的评论之外：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1744737|如果使用Robinson的交换方法，通过异步处理交换可以更快。|1744738|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In addition to the previous comments :

if you use Robinson's swap method, you could go ever faster by handling that swap asynchronously.

blocks|key|1104312|text|在选择容器时，我通常使用下面的图表来帮助我：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1104313|​|1104314|📷|atomic|offset|length|1104315|1104316|source|1104317|1104318|除此之外，|1104319|与前面发布的一样，如果这会导致性能问题，请在for循环外部声明容器，并在每次迭代开始时将其清除|1104320|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/b78648dc03edbc4898aaa3be8f9195ef.png|imageAlt|1|LINK|MUTABLE|url|https://stackoverflow.com/questions/471432/in-which-scenario-do-i-use-a-particular-stl-container^0|0|0|0|1|0|0|0|0|6|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@$G|17|H|18|1|19]]|A|$]]|$1|I|3|C|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@$G|1C|H|1D|1|1E]]|A|$]]|$1|L|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X|Y|-4]]|Z|$5|10|U|11|A|$12|13]]]]

When choosing a container i usually use this diagram to help me:

<img src="https://i.stack.imgur.com/QeF8e.png" alt="enter image description here">

<a href="https://stackoverflow.com/questions/471432/in-which-scenario-do-i-use-a-particular-stl-container">source</a>

<hr>

Other than that,

Like previously posted if this is causing performance problems declare the container outside of the for loop and just clear it at the start of each iteration

blocks|key|2125097|text|如果您真的很关心性能(并且事先知道n1和n2的大小)，但又不想使用C风格的数组，那么std::array可能是您的朋友。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2125098|编辑:考虑到您的编辑，std::array似乎不是一个合适的替代品，因为虽然向量大小不会在每次迭代中改变，但在编译之前仍然是未知的。|2125099|entityMap^0|H|2|K|2|16|A|0|B|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

Well if you are really concerned about performance (and you know the size of <code>n1</code> and <code>n2</code> beforehand) but don't want to use a C-style array, <code>std::array</code> may be your friend.

EDIT: Given your edit, it seems an <code>std::array</code> isn't an appropriate substitute since while the vector size does not change each iteration, it still isn't known before compilation.

blocks|key|2125113|text|下面是一些测试一些不同方法的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2125114|#include+<chrono>
#include+<iostream>
#include+<vector>

int+main()
{
++typedef+std::chrono::high_resolution_clock+clock;

++unsigned+n1+=+1000;
++unsigned+n2+=+1000;

++//+Original+method
++{
++++auto+start+=+clock::now();
++++for+(unsigned+i+=+0;+i+<+10000;+%2B%2Bi)
++++{
++++++std::vector<std::vector<long+long>>+vec(n1,+std::vector<long+long>(n2));
++++++//+vec+is+initialized+to+zero+already

++++++//+do+stuff
++++}
++++auto+elapsed_time+=+clock::now()+-+start;

++++std::cout+<<+elapsed_time.count()+<<+std::endl;
++}


++//+reinitialize+values+to+zero+at+every+pass+in+the+loop
++{
++++auto+start+=+clock::now();
++++std::vector<std::vector<long+long>>+vec(n1,+std::vector<long+long>(n2));
++++for+(unsigned+i+=+0;+i+<+10000;+%2B%2Bi)
++++{
++++++//+initialize+vec+to+zero+at+the+start+of+every+loop
++++++for+(unsigned+j+=+0;+j+<+n1;+%2B%2Bj)
++++++++for+(unsigned+k+=+0;+k+<+n2;+%2B%2Bk)
++++++++++++vec[j][k]+=+0;

++++++//+do+stuff
++++}
++++auto+elapsed_time+=+clock::now()+-+start;

++++std::cout+<<+elapsed_time.count()+<<+std::endl;
++}

++//+clearing+the+vector+this+way+is+not+optimal+since+it+will+destruct+the
++//+inner+vectors
++{
++++auto+start+=+clock::now();
++++std::vector<std::vector<long+long>>+vec(n1,+std::vector<long+long>(n2));
++++for+(unsigned+i+=+0;+i+<+10000;+%2B%2Bi)
++++{
++++++vec.clear();
++++++vec.resize(n1,+std::vector<long+long>(n2));

++++++//+do+stuff
++++}
++++auto+elapsed_time+=+clock::now()+-+start;

++++std::cout+<<+elapsed_time.count()+<<+std::endl;
++}

++//+equivalent+to+the+second+method+from+above
++//+no+performace+penalty
++{
++++auto+start+=+clock::now();
++++std::vector<std::vector<long+long>>+vec(n1,+std::vector<long+long>(n2));
++++for+(unsigned+i+=+0;+i+<+10000;+%2B%2Bi)
++++{
++++++for+(unsigned+j+=+0;+j+<+n1;+%2B%2Bj)
++++++{
++++++++vec[j].clear();
++++++++vec[j].resize(n2);
++++++}

++++++//+do+stuff
++++}
++++auto+elapsed_time+=+clock::now()+-+start;

++++std::cout+<<+elapsed_time.count()+<<+std::endl;
++}
}|code-block|syntax|javascript|2125115|编辑：我已经更新了代码，以便在方法之间进行更公平的比较。编辑2：稍微清理了一下代码，方法2或4是可行的。|offset|length|style|BOLD|2125116|以下是上述四种方法在我的电脑上的时间安排：|2125117|16327389
15216024
16371469
15279471|2125118|关键是你应该尝试不同的方法并分析你的代码。|2125119|entityMap^0|0|0|0|2|S|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

Here is some code that tests a few different methods.

<pre><code>#include &lt;chrono&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main()
{
 typedef std::chrono::high_resolution_clock clock;

 unsigned n1 = 1000;
 unsigned n2 = 1000;

 // Original method
 {
 auto start = clock::now();
 for (unsigned i = 0; i &lt; 10000; ++i)
 {
 std::vector&lt;std::vector&lt;long long&gt;&gt; vec(n1, std::vector&lt;long long&gt;(n2));
 // vec is initialized to zero already

 // do stuff
 }
 auto elapsed_time = clock::now() - start;

 std::cout &lt;&lt; elapsed_time.count() &lt;&lt; std::endl;
 }


 // reinitialize values to zero at every pass in the loop
 {
 auto start = clock::now();
 std::vector&lt;std::vector&lt;long long&gt;&gt; vec(n1, std::vector&lt;long long&gt;(n2));
 for (unsigned i = 0; i &lt; 10000; ++i)
 {
 // initialize vec to zero at the start of every loop
 for (unsigned j = 0; j &lt; n1; ++j)
 for (unsigned k = 0; k &lt; n2; ++k)
 vec[j][k] = 0;

 // do stuff
 }
 auto elapsed_time = clock::now() - start;

 std::cout &lt;&lt; elapsed_time.count() &lt;&lt; std::endl;
 }

 // clearing the vector this way is not optimal since it will destruct the
 // inner vectors
 {
 auto start = clock::now();
 std::vector&lt;std::vector&lt;long long&gt;&gt; vec(n1, std::vector&lt;long long&gt;(n2));
 for (unsigned i = 0; i &lt; 10000; ++i)
 {
 vec.clear();
 vec.resize(n1, std::vector&lt;long long&gt;(n2));

 // do stuff
 }
 auto elapsed_time = clock::now() - start;

 std::cout &lt;&lt; elapsed_time.count() &lt;&lt; std::endl;
 }

 // equivalent to the second method from above
 // no performace penalty
 {
 auto start = clock::now();
 std::vector&lt;std::vector&lt;long long&gt;&gt; vec(n1, std::vector&lt;long long&gt;(n2));
 for (unsigned i = 0; i &lt; 10000; ++i)
 {
 for (unsigned j = 0; j &lt; n1; ++j)
 {
 vec[j].clear();
 vec[j].resize(n2);
 }

 // do stuff
 }
 auto elapsed_time = clock::now() - start;

 std::cout &lt;&lt; elapsed_time.count() &lt;&lt; std::endl;
 }
}
</code></pre>

Edit: I've updated the code to make a fairer comparison between the methods.
Edit 2: Cleaned up the code a bit, methods 2 or 4 are the way to go.

Here are the timings of the above four methods on my computer:

<pre><code>16327389
15216024
16371469
15279471
</code></pre>

The point is that you should try out different methods and profile your code.

blocks|key|2125129|text|由于每次迭代都必须将向量值重置为0，因此实际上，这个问题可以归结为“与循环内的计算相比，为向量分配和释放内存的成本是便宜还是昂贵”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2125130|假设计算是算法中最昂贵的部分，那么您编写它的方式既清晰、简洁，又显示了预期的范围，并且可能与其他方法一样快。|2125131|但是，如果您的计算和更新非常快，并且向量的分配/释放相对昂贵，则可以使用std::fill在循环中的每个迭代结束/开始时将零填充回数组中。|offset|length|style|CODE|2125132|当然，唯一确定的方法是使用剖析器进行测量。我怀疑您会发现您采用的方法不会显示为任何类型的热点，您应该将显而易见的代码保留在适当的位置。|2125133|entityMap^0|0|0|10|9|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Since you have to reset the vector values to 0 each iteration, in practical terms, this question boils down to "is the cost of allocating and deallocating the memory for the vector cheap or expensive compared to the computations inside the loops".

Assuming the computations are the expensive part of the algorithm, the way you've coded it is both clear, concise, shows the intended scope, and is probably just as fast as alternate approaches.

If however your computations and updates are extremely fast and the allocation/deallocation of the vector is relatively expensive, you could use <code>std::fill</code> to fill zeroes back into the array at the end/beginning of each iteration through the loop.

Of course the only way to know for sure is to measure with a profiler. I suspect you'll find that the approach you took won't show up as a hotspot of any sort and you should leave the obvious code in place.

I have a nested for-loop structure and right now I am re-declaring the vector at the start of each iteration:

<pre><code>void function (n1,n2,bound,etc){

 for (int i=0; i&lt;bound; i++){
 vector&lt; vector&lt;long long&gt; &gt; vec(n1, vector&lt;long long&gt;(n2));
 //about three more for-loops here
 }
}
</code></pre>

This allows me to "start fresh" each iteration, which works great because my internal operations are largely in the form of vec[a][b] += some value. But I worry that it's slow for large n1 or large n2. I don't know the underlying architecture of vectors/arrays/etc so I am not sure what the fastest way is to handle this situation. Should I use an array instead? Should I clear it differently? Should I handle the logic differently altogether?

EDIT: The vector's size technically does not change each iteration (but it may change based on function parameters). I'm simply trying to clear it/etc so the program is as fast as humanly possible given all other circumstances.

EDIT:

My results of different methods:

<pre><code>Timings (for a sample set of data):
reclaring vector method: 111623 ms
clearing/resizing method: 126451 ms
looping/setting to 0 method: 88686 ms
</code></pre>

C++: Optimizing speed with vector/array?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一个嵌套的for循环结构，现在我在每次迭代开始时重新声明向量：void function (n1,n2,bound,etc){ for (int i=0; i<bound; i++){ vector< vector<long long> > vec(n1, vector<long lo...

问C++：使用向量/数组优化速度？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：使用向量/数组优化速度？EN