blocks|key|1361868|text|使用迭代器会导致指针递增(用于递增)和取消引用为取消引用指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361869|对于索引，增量应该同样快，但查找元素涉及加法(data+pointer%2Bindex)和取消引用该指针，但差异应该是微不足道的。|1361870|at()还会检查索引是否在界限内，因此它可能会更慢。|offset|length|style|CODE|1361871|500M迭代的基准测试结果，向量大小为10，使用gcc+4.3.3+(-O3)，Linux2.6.29.1+x86_64：|1361872|at()：9158ms|1361873|operator[]：4269ms|1361874|iterator：3914ms|1361875|YMMV，但是如果使用索引使代码更易读或更容易理解，您应该这样做。|1361876|2021年更新|1361877|在现代编译器中，所有选项实际上都是免费的，但迭代器在迭代方面稍好一些，并且更容易与范围循环(for(auto&+x:+vs))一起使用。|1361878|代码：|1361879|#include+<vector>

void+iter(std::vector<int>+&vs)+{
++++for(std::vector<int>::iterator+it+=+vs.begin();+it+!=+vs.end();+%2B%2Bit)
++++++++*it+=+5;
}

void+index(std::vector<int>+&vs)+{
++++for(std::size_t+i+=+0;+i+<+vs.size();+%2B%2Bi)
++++++++vs[i]+=+5;
}

void+at(std::vector<int>+&vs)+{
++++for(std::size_t+i+=+0;+i+<+vs.size();+%2B%2Bi)
++++++++vs.at(i)+=+5;
}|code-block|syntax|javascript|1361880|为index()和at()生成的程序集是相同的godbolt，但iter()的循环设置少了两条指令：|1361881|iter(std::vector<int,+std::allocator<int>+>&):
++++++++mov+++++rax,+QWORD+PTR+[rdi]
++++++++mov+++++rdx,+QWORD+PTR+[rdi%2B8]
++++++++cmp+++++rax,+rdx
++++++++je++++++.L1
.L3:++++++++++++++++++++++++++++++;+loop+body
++++++++mov+++++DWORD+PTR+[rax],+5
++++++++add+++++rax,+4
++++++++cmp+++++rax,+rdx
++++++++jne+++++.L3
.L1:
++++++++ret
index(std::vector<int,+std::allocator<int>+>&):
++++++++mov+++++rax,+QWORD+PTR+[rdi]
++++++++mov+++++rdx,+QWORD+PTR+[rdi%2B8]
++++++++sub+++++rdx,+rax
++++++++mov+++++rcx,+rdx
++++++++shr+++++rcx,+2
++++++++je++++++.L6
++++++++add+++++rdx,+rax
.L8:++++++++++++++++++++++++++++++;+loop+body
++++++++mov+++++DWORD+PTR+[rax],+5
++++++++add+++++rax,+4
++++++++cmp+++++rdx,+rax
++++++++jne+++++.L8
.L6:
++++++++ret|1361882|entityMap|0|LINK|mutability|MUTABLE|url|https://godbolt.org/z/cv6Kv4b6f^0|0|0|0|4|0|0|0|4|0|0|A|0|0|8|0|0|0|1A|G|0|0|0|1|7|9|4|W|6|N|7|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1I|8|@$F|1J|G|1K|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1L|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1M|8|@$F|1N|G|1O|H|I]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1P|8|@$F|1Q|G|1R|H|I]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1S|8|@$F|1T|G|1U|H|I]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1V|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1W|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1X|8|@$F|1Y|G|1Z|H|I]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|20|8|@]|9|@]|A|$]]|$1|Z|3|10|5|11|7|21|8|@]|9|@]|A|$12|13]]|$1|14|3|15|5|6|7|22|8|@$F|23|G|24|H|I]|$F|25|G|26|H|I]|$F|27|G|28|H|I]]|9|@$F|29|G|2A|1|2B]]|A|$]]|$1|16|3|17|5|11|7|2C|8|@]|9|@]|A|$12|13]]|$1|18|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F]]]]

Using an iterator results in incrementing a pointer (for incrementing) and for dereferencing into dereferencing a pointer. 
With an index, incrementing should be equally fast, but looking up an element involves an addition (data pointer+index) and dereferencing that pointer, but the difference should be marginal. 
<code>at()</code> also checks if the index is within the bounds, so it could be slower.
Benchmark results for 500M iterations, vector size 10, with gcc 4.3.3 (-O3), linux 2.6.29.1 x86_64: 
<code>at()</code>: 9158ms 
<code>operator[]</code>: 4269ms 
<code>iterator</code>: 3914ms
YMMV, but if using an index makes the code more readable/understandable, you should do it.
<h1>2021 update</h1>
With modern compilers, all options are practically free, but iterators are very slightly better for iterating and easier to use with range-for loops (<code>for(auto&amp; x: vs)</code>).
Code:
<pre class="lang-cpp prettyprint-override"><code>#include &lt;vector&gt;

void iter(std::vector&lt;int&gt; &amp;vs) {
 for(std::vector&lt;int&gt;::iterator it = vs.begin(); it != vs.end(); ++it)
 *it = 5;
}

void index(std::vector&lt;int&gt; &amp;vs) {
 for(std::size_t i = 0; i &lt; vs.size(); ++i)
 vs[i] = 5;
}

void at(std::vector&lt;int&gt; &amp;vs) {
 for(std::size_t i = 0; i &lt; vs.size(); ++i)
 vs.at(i) = 5;
}
</code></pre>
The generated assembly for <code>index()</code> and <code>at()</code> is identical <a href="https://godbolt.org/z/cv6Kv4b6f" rel="nofollow noreferrer">godbolt</a>, but the loop setup for <code>iter()</code> is two instructions shorter:
<pre><code>iter(std::vector&lt;int, std::allocator&lt;int&gt; &gt;&amp;):
 mov rax, QWORD PTR [rdi]
 mov rdx, QWORD PTR [rdi+8]
 cmp rax, rdx
 je .L1
.L3: ; loop body
 mov DWORD PTR [rax], 5
 add rax, 4
 cmp rax, rdx
 jne .L3
.L1:
 ret
index(std::vector&lt;int, std::allocator&lt;int&gt; &gt;&amp;):
 mov rax, QWORD PTR [rdi]
 mov rdx, QWORD PTR [rdi+8]
 sub rdx, rax
 mov rcx, rdx
 shr rcx, 2
 je .L6
 add rdx, rax
.L8: ; loop body
 mov DWORD PTR [rax], 5
 add rax, 4
 cmp rdx, rax
 jne .L8
.L6:
 ret
</code></pre>

blocks|key|1577133|text|第一种方法在调试模式下会更快，因为索引访问会在后台创建迭代器，但在发布模式下，所有内容都应该是内联的，差异应该可以忽略不计或为空|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577134|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 first one will be faster in debug mode because index access creates iterators behind the scene, but in release mode where everything should be inlined, the difference should be negligible or null

blocks|key|1361990|text|我认为唯一的答案可能是在你的平台上进行一次测试。通常，在STL中唯一标准化的是集合提供的迭代器的类型和算法的复杂性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361991|我要说的是，这两个版本没有(差别不大)--我能想到的唯一区别是，当代码必须计算数组的长度时，它必须遍历整个集合(我不确定长度是否存储在向量内的变量中，那么开销就无关紧要了)|1361992|使用"at“访问元素的时间应该比使用[]直接访问它的时间长一点，因为它会检查您是否在向量的边界内，如果您超出了边界，则会抛出异常(似乎[]通常只是使用指针算法-所以它应该更快)。|1361993|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 think the only answer could be a test on your platform. Generally the only thing which is standardized in the STL is the type of iterators a collection offers and the complexity of algorithms.

I would say that there is no (not much of a difference) between those two versions- the only difference I could think of would be tjat the code has to iterate through the whole collection when it has to compute the length of an array (I'm not sure if the length is stored in a variable inside the vector, then the overhead wouldn't matter)

Accessing the elements with "at" should take a little bit longer than directly accessing it with [] because it checks if you are in the bounds of the vector and throws an exception if you are out of bounds (it seems [] is normally just using pointer arithmetic - so it should be faster)

blocks|key|1577266|text|既然你关注的是效率，你应该意识到以下变化可能更有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577267|//1.+Using+vector<string>::iterator:

vector<string>+vs+=+GetVector();
for(vector<string>::iterator+it+=+vs.begin(),+end+=+vs.end();+it+!=+end;+%2B%2Bit)
{
+++//...
}

//2.+Using+size_t+index:

vector<string>+vs+=+GetVector();
for(size_t+i+=+0,+size+=+vs.size();+i+!=+size;+%2B%2Bi)
{
+++//...
}|code-block|syntax|javascript|1577268|因为end/size函数只调用一次，而不是通过循环每次都调用。编译器很可能无论如何都会内联这些函数，但这种方式可以确保。|1577269|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since you're looking at efficiency, you should realise that the following variations are potentially more efficient:

<pre><code>//1. Using vector&lt;string&gt;::iterator:

vector&lt;string&gt; vs = GetVector();
for(vector&lt;string&gt;::iterator it = vs.begin(), end = vs.end(); it != end; ++it)
{
 //...
}

//2. Using size_t index:

vector&lt;string&gt; vs = GetVector();
for(size_t i = 0, size = vs.size(); i != size; ++i)
{
 //...
}
</code></pre>

since the end/size function is only called once rather than every time through the loop. It's likely that the compiler will inline these functions anyway, but this way makes sure.

blocks|key|1577303|text|如果你不需要索引，就不要使用它。迭代器的概念是最好的。迭代器很容易优化，而直接访问则需要一些额外的知识。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577304|索引是用于直接访问的。括号和at方法可以做到这一点。与[]不同的是，at会检查越界索引，因此速度会更慢。|offset|length|style|CODE|1577305|信条是:不要索要你不需要的东西。这样编译器就不会为你不用的东西收费了。|1577306|entityMap^0|0|E|2|R|2|Y|2|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

If you don't need indexing, don't use it. The iterator concept is there for your best. Iterators are very easy to optimize, while direct access needs some extra knowledge.

Indexing is meant for direct access. The brackets and the <code>at</code> method do this. <code>at</code> will, unlike <code>[]</code>, check for out of bounds indexing, so it will be slower.

The credo is: don't ask for what you don't need. Then the compiler won't charge you for what you don't use.

blocks|key|1362131|text|如果您使用的是VisualStudio+2005或2008，为了从向量中获得最佳性能，您需要定义_SECURE_SCL=0|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362132|默认情况下，_SECURE_SCL是开的，这会使遍历容器的速度明显变慢。也就是说，在调试版本中将其保留为打开状态，将使跟踪任何错误变得更加容易。需要注意的是，由于宏会更改迭代器和容器的大小，因此您必须在共享stl容器的所有编译单元中保持一致。|1362133|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|$]]

If you are using VisualStudio 2005 or 2008, to get the best performance out of the vector you'll need to define
_SECURE_SCL=0

By default _SECURE_SCL is on which makes iterating over a contain significantly slower. That said leave it on in debug builds, it will make tracking down any errors much easier. One word of caution, since the macro changes the size of iterators and containers, you'll have to be consistent across all compilation units that share a stl container.

blocks|key|1577442|text|正如在座的每个人所说的，做基准测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577443|话虽如此，我认为迭代器更快，因为at()也做范围检查，也就是说，如果索引越界，它会抛出out_of_range异常。该检查本身可能会产生一些开销。|1577444|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|$]]

As everyone else here is saying, do benchmarks.

Having said that, I would argue that the iterator is faster since at() does range checking as well, i.e. it throws an out_of_range exception if the index is out of bounds. That check itself propbably incurrs some overhead.

blocks|key|1362276|text|这种差异应该可以忽略不计。vector保证它的元素在内存中连续布局。因此，大多数stl实现将迭代器作为普通指针实现到std::vector中。考虑到这一点，两个版本之间的唯一区别应该是第一个版本递增一个指针，而在第二个版本中递增一个索引，然后将其添加到指针中。所以我猜第二个可能是一个速度极快的机器指令(就周期而言)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362277|尝试检查编译器生成的机器代码。|1362278|然而，一般来说，建议是如果它真的很重要的话就去分析。过早地思考这类问题通常不会给你太多的回报。通常，您的代码热点会在其他地方，您可能不会第一眼看到它。|1362279|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|$]]

The difference should be negligible. std::vector guarantees that its elements are laid out consecutively in memory. Therefore, most stl implementations implement iterators into std::vector as a plain pointer. With this is mind, the only difference between the two versions should be that the first one increments a pointer, and in the second increments an index which is then added to a pointer. So my guess would be the second one is maybe one extremly fast (in terms of cycles) machine instruction more.

Try and check the machine code your compiler produces.

In general, however, the advice would be to profile if it really matters. Thinking about this kind of question prematurely usually does not give you too much back. Usually, your code's hotspots will be elsewhere where you might not suspect it at first sight.

blocks|key|1362311|text|您可以使用此测试代码并比较结果！去吧！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362312|#include+<vector>+
#include+<iostream>+
#include+<ctime>+
using+namespace+std;;+


struct+AAA{
++++int+n;
++++string+str;
};
int+main()+{+
++++const+int+BIG+=+5000000;+
++++vector+<AAA>+v;+
++++for+(+int+i+=+0;+i+<+BIG;+i%2B%2B+)+{+
++++++++AAA+a+=+{i,+"aaa"};
++++++++v.push_back(+a+);+
++++}+

++++clock_t+now;
++++cout+<<+"start"+<<+endl;+
++++int+n+=+0;+
++++now+=+clock();+
++++for(vector<AAA>::iterator+it+=+v.begin();+it+!=+v.end();+%2B%2Bit)+{+
++++++++n+%2B=+it->n;+
++++}+
+++cout+<<+clock()+-+now+<<+endl;+

++++n+=+0;
++++now+=+clock();+
++++for(size_t+i+=+0;+i+<+v.size();+%2B%2Bi)+{+
++++++++n+%2B=+v[i].n;+
++++}+
++++cout+<<+clock()+-+now+<<+endl;+

++++getchar();
++++return+n+!=+0;+
}+|code-block|syntax|javascript|1362313|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use this test code and compare results!
Dio it!

<pre><code>#include &lt;vector&gt; 
#include &lt;iostream&gt; 
#include &lt;ctime&gt; 
using namespace std;; 


struct AAA{
 int n;
 string str;
};
int main() { 
 const int BIG = 5000000; 
 vector &lt;AAA&gt; v; 
 for ( int i = 0; i &lt; BIG; i++ ) { 
 AAA a = {i, "aaa"};
 v.push_back( a ); 
 } 

 clock_t now;
 cout &lt;&lt; "start" &lt;&lt; endl; 
 int n = 0; 
 now = clock(); 
 for(vector&lt;AAA&gt;::iterator it = v.begin(); it != v.end(); ++it) { 
 n += it-&gt;n; 
 } 
 cout &lt;&lt; clock() - now &lt;&lt; endl; 

 n = 0;
 now = clock(); 
 for(size_t i = 0; i &lt; v.size(); ++i) { 
 n += v[i].n; 
 } 
 cout &lt;&lt; clock() - now &lt;&lt; endl; 

 getchar();
 return n != 0; 
} 
</code></pre>

blocks|key|1577557|text|这真的取决于你在做什么，但是如果你必须不断地重新声明迭代器，迭代器会变得稍微慢一点。在我的测试中，最快的迭代可能是对向量数组声明一个简单的*，然后遍历它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577558|例如：|1577559|向量迭代和每次传递拉取两个函数。|1577560|vector<MyTpe>+avector(128);
vector<MyTpe>::iterator+B=avector.begin();
vector<MyTpe>::iterator+E=avector.end()-1;
for(int+i=0;+i<1024;+%2B%2Bi){
+B=avector.begin();
+++while(B!=E)
+++{
+++++++float+t=B->GetVal(Val1,12,Val2);+float+h=B->GetVal(Val1,12,Val2);
++++%2B%2BB;
++}}|code-block|syntax|javascript|1577561|Vector花了90次点击(0.090000秒)|1577562|但如果你是用指针做的.|1577563|for(int+i=0;+i<1024;+%2B%2Bi){
MyTpe+*P=&(avector[0]);
+++for(int+i=0;+i<avector.size();+%2B%2Bi)
+++{
+++float+t=P->GetVal(Val1,12,Val2);+float+h=P->GetVal(Val1,12,Val2);
+++}}|1577564|向量花了18次点击(0.018000秒)|1577565|大致相当于...|1577566|MyTpe+Array[128];
for(int+i=0;+i<1024;+%2B%2Bi)
{
+++for(int+p=0;+p<128;+%2B%2Bp){
++++float+t=Array[p].GetVal(Val1,+12,+Val2);+float+h=Array[p].GetVal(Val2,12,Val2);
++++}}|1577567|阵列花了15次点击(0.015000秒)。|1577568|如果取消对avector.size()的调用，时间就会变得相同。|1577569|最后，使用|1577570|for(int+i=0;+i<1024;+%2B%2Bi){
+++for(int+i=0;+i<avector.size();+%2B%2Bi){
+++float+t=avector[i].GetVal(Val1,12,Val2);+float+h=avector[i].GetVal(Val1,12,Val2);
+++}}|1577571|向量花了33次点击(0.033000秒)|1577572|使用clock()计时|1577573|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1F|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|1G|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1H|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|1J|8|@]|9|@]|A|$I|J]]|$1|W|3|X|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|13|5|H|7|1N|8|@]|9|@]|A|$I|J]]|$1|14|3|15|5|6|7|1O|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1P|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|19|$]]

It really depends on what you are doing, but if you have to keep re-declaring the iterator, Iterators become MARGINALLY SLOWER. In my tests, the fastest possible iteration would be to declare a simple * to your vectors array and Iterate through that.

for example:

Vector Iteration and pulling two functions per pass.

<pre><code>vector&lt;MyTpe&gt; avector(128);
vector&lt;MyTpe&gt;::iterator B=avector.begin();
vector&lt;MyTpe&gt;::iterator E=avector.end()-1;
for(int i=0; i&lt;1024; ++i){
 B=avector.begin();
 while(B!=E)
 {
 float t=B-&gt;GetVal(Val1,12,Val2); float h=B-&gt;GetVal(Val1,12,Val2);
 ++B;
 }}
</code></pre>

Vector Took 90 clicks (0.090000 seconds)

But if you did it with pointers...

<pre><code>for(int i=0; i&lt;1024; ++i){
MyTpe *P=&amp;(avector[0]);
 for(int i=0; i&lt;avector.size(); ++i)
 {
 float t=P-&gt;GetVal(Val1,12,Val2); float h=P-&gt;GetVal(Val1,12,Val2);
 }}
</code></pre>

Vector Took 18 clicks (0.018000 Seconds)

Which is roughly equivalent to...

<pre><code>MyTpe Array[128];
for(int i=0; i&lt;1024; ++i)
{
 for(int p=0; p&lt;128; ++p){
 float t=Array[p].GetVal(Val1, 12, Val2); float h=Array[p].GetVal(Val2,12,Val2);
 }}
</code></pre>

Array Took 15 clicks (0.015000 seconds).

If you eliminate the call to avector.size(), the time becomes the same. 

Finally, calling with [ ]

<pre><code>for(int i=0; i&lt;1024; ++i){
 for(int i=0; i&lt;avector.size(); ++i){
 float t=avector[i].GetVal(Val1,12,Val2); float h=avector[i].GetVal(Val1,12,Val2);
 }}
</code></pre>

Vector Took 33 clicks (0.033000 seconds)

Timed with clock()

blocks|key|1577682|text|仅与原始问题稍微相切，但最快的循环将是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577683|for(+size_t+i=size()+;+i--+;+)+{+...+}|offset|length|style|CODE|1577684|当然会倒计时。如果你的循环中有大量的迭代，但它只包含少量非常快的操作，这确实可以节省大量的时间。|1577685|因此，使用[]运算符访问，这可能比已发布的许多示例更快。|1577686|entityMap^0|0|0|12|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|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|$]]

Only slightly tangential to the original question, but the fastest loop would be 

<code>for( size_t i=size() ; i-- ; ) { ... }
</code>

which would of course count down. This does give a substantial saving if you have a large number of iterations in your loop, but it contains only a small number of very fast operations. 

So with the [] operator access, this might be faster than many of the examples already posted.

In terms of performance, what would work faster? Is there a difference? Is it platform dependent? 

<pre><code>//1. Using vector&lt;string&gt;::iterator:
vector&lt;string&gt; vs = GetVector();

for(vector&lt;string&gt;::iterator it = vs.begin(); it != vs.end(); ++it)
{
 *it = "Am I faster?";
}

//2. Using size_t index:
for(size_t i = 0; i &lt; vs.size(); ++i)
{
 //One option:
 vs.at(i) = "Am I faster?";
 //Another option:
 vs[i] = "Am I faster?";
}
</code></pre>

What's faster, iterating an STL vector with vector::iterator or with at()?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在性能方面，什么会更快？有什么不同吗？它依赖于平台吗？//1. Using vector<string>::iterator:vector<string> vs = GetVector();for(vector<string>::iterator it = vs.begin(); it != vs.end(); ++i...

问使用vector::iterator或at()迭代STL向量，哪个更快？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用vector::iterator或at()迭代STL向量，哪个更快？EN