blocks|key|1036442|text|以下是一些硬件上可能发生的情况，这取决于编译器可以推断出您正在使用的数字的范围:对于递增循环，您必须在每次循环中测试i<N。对于递减版本，进位标志(设置为减法的副作用)可能会自动告诉您是否为i>=0。这样循环一次就可以节省一次测试。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1036443|实际上，在现代流水线处理器硬件上，这种东西几乎肯定是无关紧要的，因为从指令到时钟周期不存在简单的1-1映射。(虽然我可以想象，如果你正在做一些事情，比如从微控制器生成精确定时的视频信号，它就会出现。但是，无论如何你都要用汇编语言来写。)|1036444|entityMap^0|1M|3|2N|4|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|$]]

Here's what might happen on some hardware depending on what the compiler can deduce about the range of the numbers you're using: with the incrementing loop you have to test <code>i&lt;N</code> each time round the loop. For the decrementing version, the carry flag (set as a side effect of the subtraction) may automatically tell you if <code>i&gt;=0</code>. That saves a test per time round the loop.

In reality, on modern pipelined processor hardware, this stuff is almost certainly irrelevant as there isn't a simple 1-1 mapping from instructions to clock cycles. (Though I could imagine it coming up if you were doing things like generating precisely timed video signals from a microcontroller. But then you'd write in assembly language anyway.)

blocks|key|1251566|text|不，那不是真的。它可能更快的一种情况是，在循环的每次迭代期间，您将调用一个函数来检查边界。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1251567|for(int+i=myCollection.size();+i+>=+0;+i--)
{
+++...
}|code-block|syntax|javascript|1251568|但如果这样做不太清楚，那就不值得了。在现代语言中，无论如何都应该尽可能使用foreach循环。您特别提到了应该使用foreach循环的情况--当您不需要索引时。|1251569|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|$]]

No, that's not really true. One situation where it could be faster is when you would otherwise be calling a function to check the bounds during every iteration of a loop.

<pre><code>for(int i=myCollection.size(); i &gt;= 0; i--)
{
 ...
}
</code></pre>

But if it's less clear to do it that way, it's not worthwhile. In modern languages, you should use a foreach loop when possible, anyway. You specifically mention the case where you should use a foreach loop -- when you don't need the index.

blocks|key|1251615|text|在英特尔x86指令集中，构建向下计数到零的循环通常比计数到非零退出条件的循环需要更少的指令就可以完成。具体而言，ECX寄存器传统上用作x86+asm中的循环计数器，并且英特尔指令集有一个特殊的jcxz跳转指令，用于测试ECX寄存器是否为零，并根据测试结果进行跳转。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1251616|但是，除非您的循环对时钟周期计数非常敏感，否则性能差异将可以忽略不计。与向上计数相比，倒数到零可能会将循环的每次迭代减少4到5个时钟周期，因此它实际上更像是一种新奇的东西，而不是一种有用的技术。|1251617|此外，如今一个优秀的优化编译器应该能够将count+up循环源代码转换为count+down+to+0机器码(取决于您如何使用循环索引变量)，因此没有任何理由以奇怪的方式编写循环，只是为了在这里或那里压缩一两个循环。|1251618|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|$]]

In the Intel x86 instruction set, building a loop to count down to zero can usually be done with fewer instructions than a loop that counts up to a non-zero exit condition. Specifically, the ECX register is traditionally used as a loop counter in x86 asm, and the Intel instruction set has a special jcxz jump instruction that tests the ECX register for zero and jumps based on the result of the test.

However, the performance difference will be negligible unless your loop is already very sensitive to clock cycle counts. Counting down to zero might shave 4 or 5 clock cycles off each iteration of the loop compared to counting up, so it's really more of a novelty than a useful technique.

Also, a good optimizing compiler these days should be able to convert your count up loop source code into count down to zero machine code (depending on how you use the loop index variable) so there really isn't any reason to write your loops in strange ways just to squeeze a cycle or two here and there.

blocks|key|1251670|text|在一些较老的CPU上，有/+and指令，如DJNZ+==“如果不为零，则递减并跳转”。这允许高效的循环，您可以将初始计数值加载到寄存器中，然后您可以使用一条指令有效地管理递减循环。我们在这里谈论的是80年代的ISAs如果你的老师认为这条“经验法则”仍然适用于现代CPU，那么他就严重脱离了现实。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1251671|entityMap^0|L|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

On some older CPUs there are/were instructions like <code>DJNZ</code> == "decrement and jump if not zero". This allowed for efficient loops where you loaded an initial count value into a register and then you could effectively manage a decrementing loop with one instruction. We're talking 1980s ISAs here though - your teacher is seriously out of touch if he thinks this "rule of thumb" still applies with modern CPUs.

blocks|key|1036666|text|在C中转换为psudo-assembly：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1036667|for+(i+=+0;+i+<+10;+i%2B%2B)+{
++++foo(i);
}|code-block|syntax|javascript|1036668|变成了|1036669|++++clear+i
top_of_loop:
++++call+foo
++++increment+i
++++compare+10,+i
++++jump_less+top_of_loop|1036670|而：|1036671|for+(i+=+10;+i+>=+0;+i--)+{
++++foo(i);
}|1036672|1036673|++++load+i,+10
top_of_loop:
++++call+foo
++++decrement+i
++++jump_not_neg+top_of_loop|1036674|请注意，在第二个psudo-assembly中缺少比较。在许多架构上，有通过算术运算(加、减、乘、除、增、减)设置的标志，您可以使用这些标志进行跳转。这些函数通常给出的结果实质上是与0的比较。事实上，在许多架构上|1036675|x+=+x+-+0|1036676|在语义上与|1036677|compare+x,+0|1036678|此外，与我的示例中的10进行比较可能会导致更糟糕的代码。10可能必须住在寄存器中，所以如果它们供不应求，那么就会产生额外的代码来移动东西，或者每次通过循环重新加载10。|1036679|编译器有时可以重新排列代码以利用这一点，但这通常很困难，因为它们通常无法确保通过循环反转方向在语义上是等价的。|1036680|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|O|3|H|5|6|7|1B|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|1D|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|V|3|W|5|6|7|1F|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Z|3|10|5|6|7|1H|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1I|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|14|$]]

In C to psudo-assembly:

<pre><code>for (i = 0; i &lt; 10; i++) {
 foo(i);
}
</code></pre>

turns into

<pre><code> clear i
top_of_loop:
 call foo
 increment i
 compare 10, i
 jump_less top_of_loop
</code></pre>

while:

<pre><code>for (i = 10; i &gt;= 0; i--) {
 foo(i);
}
</code></pre>

turns into

<pre><code> load i, 10
top_of_loop:
 call foo
 decrement i
 jump_not_neg top_of_loop
</code></pre>

Note the lack of the compare in the second psudo-assembly. On many architectures there are flags that are set by arithmatic operations (add, subtract, multiply, divide, increment, decrement) which you can use for jumps. These often give you what is essentially a comparison of the result of the operation with 0 for free. In fact on many architectures

<pre><code>x = x - 0
</code></pre>

is semantically the same as

<pre><code>compare x, 0
</code></pre>

Also, the compare against a 10 in my example could result in worse code. 10 may have to live in a register, so if they are in short supply that costs and may result in extra code to move things around or reload the 10 every time through the loop.

Compilers can sometimes rearrange the code to take advantage of this, but it is often difficult because they are often unable to be sure that reversing the direction through the loop is semantically equivalent.

blocks|key|1251796|text|现在，我认为你的汇编讲座已经足够多了：)我想向你介绍自上而下方法的另一个原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1251797|从头开始的原因很简单。在循环体中，您可能会意外地更改边界，这可能会导致不正确的行为，甚至是非终止循环。|1251798|看看这一小部分Java代码(我猜是因为这个原因，语言并不重要)：|1251799|++++System.out.println("top->down");
++++int+n+=+999;
++++for+(int+i+=+n;+i+>=+0;+i--)+{
++++++++n%2B%2B;
++++++++System.out.println("i+=+"+%2B+i+%2B+"\t+n+=+"+%2B+n);
++++}
++++System.out.println("bottom->up");
++++n+=+1;
++++for+(int+i+=+0;+i+<+n;+i%2B%2B)+{
++++++++n%2B%2B;
++++++++System.out.println("i+=+"+%2B+i+%2B+"\t+n+=+"+%2B+n);
++++}|code-block|syntax|javascript|1251800|所以我的观点是，你应该考虑从上到下，或者以一个常量作为边界。|1251801|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Now, I think you had enough assembly lectures:) I would like to present you another reason for top->down approach.

The reason to go from the top is very simple. In the body of the loop, you might accidentally change the boundary, which might end in incorrect behaviour or even non-terminating loop.

Look at this small portion of Java code (the language does not matter I guess for this reason):

<pre><code> System.out.println("top-&gt;down");
 int n = 999;
 for (int i = n; i &gt;= 0; i--) {
 n++;
 System.out.println("i = " + i + "\t n = " + n);
 }
 System.out.println("bottom-&gt;up");
 n = 1;
 for (int i = 0; i &lt; n; i++) {
 n++;
 System.out.println("i = " + i + "\t n = " + n);
 }
</code></pre>

So my point is you should consider prefering going from the top down or having a constant as a boundary.

blocks|key|1251887|text|重点是，在倒计时时，你不需要分别检查i+>=+0和递减i。请注意：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1251888|for+(i+=+5;+i--;)+{
++alert(i);++//+alert+boxes+showing+4,+3,+2,+1,+0
}|code-block|syntax|javascript|1251889|比较和递减i都可以在一个表达式中完成。|1251890|请参阅其他答案，了解为什么这归结为更少的x86指令。|1251891|至于它是否会对你的应用程序产生有意义的影响，我猜这取决于你有多少个循环以及它们的嵌套深度。但对我来说，这样做同样具有可读性，所以我还是这样做了。|1251892|entityMap^0|I|6|R|1|0|0|5|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

The point is that when counting down you don't need to check <code>i &gt;= 0</code> separately to decrementing <code>i</code>. Observe:

<pre><code>for (i = 5; i--;) {
 alert(i); // alert boxes showing 4, 3, 2, 1, 0
}
</code></pre>

Both the comparison and decrementing <code>i</code> can be done in the one expression.

See other answers for why this boils down to fewer x86 instructions.

As to whether it makes a meaningful difference in your application, well I guess that depends on how many loops you have and how deeply nested they are. But to me, it's just as readable to do it this way, so I do it anyway.

blocks|key|1036935|text|这是一个有趣的问题，但作为一个实际问题，我认为它并不重要，并且不会使一个循环比另一个循环更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1036936|根据维基百科的这个页面：Leap+second，"...the太阳日每世纪增加1.7毫秒，主要是由于潮汐摩擦。“但是，如果你在计算离生日还有几天的时间，你真的关心这个微小的时间差吗？|offset|length|1036937|更重要的是，源代码要易于阅读和理解。这两个循环是为什么可读性很重要的一个很好的例子--它们不会循环相同的次数。|1036938|我敢打赌，大多数程序员阅读(i+=+0；i<+N；i%2B%2B)并立即理解这会循环N次。对我来说，(i+=+1；i+<=+N；i%2B%2B)的循环不太清楚，对于(i+=+N；i>+0；i--)我必须考虑一下。如果代码的意图不需要任何思考就直接进入大脑，这是最好的。|1036939|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Leap_second^0|0|C|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

It is an interesting question, but as a practical matter I don't think it's important and does not make one loop any better than the other.

According to this wikipedia page: <a href="http://en.wikipedia.org/wiki/Leap_second" rel="nofollow noreferrer">Leap second</a>, "...the solar day becomes 1.7 ms longer every century due mainly to tidal friction." But if you are counting days until your birthday, do you really care about this tiny difference in time?

It's more important that the source code is easy to read and understand. Those two loops are a good example of why readability is important -- they don't loop the same number of times.

I would bet that most programmers read (i = 0; i &lt; N; i++) and understand immediately that this loops N times. A loop of (i = 1; i &lt;= N; i++), for me anyway, is a little less clear, and with (i = N; i > 0; i--) I have to think about it for a moment. It's best if the intent of the code goes directly into the brain without any thinking required.

blocks|key|1036999|text|在汇编级，倒数到零的循环通常比倒数到给定值的循环稍微快一些。如果计算结果等于零，大多数处理器将设置一个零标志。如果减去1使得计算绕过零，这通常会改变进位标志(在一些处理器上，它会将它设置在其他处理器上，它会清除它)，所以与0的比较基本上是免费的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1037000|当迭代次数不是常量而是变量时，更是如此。|1037001|在微不足道的情况下，编译器可能能够自动优化循环的计数方向，但在更复杂的情况下，程序员可能知道循环的方向与整体行为无关，但编译器无法证明这一点。|1037002|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|$]]

At an assembler level a loop that counts down to zero is generally slightly faster than one that counts up to a given value. If the result of a calculation is equal to zero most processors will set a zero flag. If subtracting one makes a calculation wrap around past zero this will normally change the carry flag (on some processors it will set it on others it will clear it), so the comparison with zero comes essentially for free.

This is even more true when the number of iterations is not a constant but a variable. 

In trivial cases the compiler may be able to optimise the count direction of a loop automatically but in more complex cases it may be that the programmer knows that the direction of the loop is irrelevant to the overall behaviour but the compiler cannot prove that.

blocks|key|1252071|text|你的老师所说的是一些拐弯抹角的陈述，没有太多的澄清。这并不是说递减比递增更快，但您可以使用递减创建比使用递增快得多的循环。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1252072|不需要详细讨论它，也不需要使用循环计数器等-下面重要的是速度和循环计数(非零)。|1252073|下面是大多数人如何使用10次迭代来实现循环：|1252074|int+i;
for+(i+=+0;+i+<+10;+i%2B%2B)
{
++++//something+here
}|code-block|syntax|javascript|1252075|对于99%25的情况，它可能是所有人需要的，但与PHP，PYTHON，JavaScript一起，有整个世界的时间关键型软件(通常是嵌入式，操作系统，游戏等)，其中CPU的节拍是真正重要的，所以简单地看一下汇编代码：|1252076|int+i;
for+(i+=+0;+i+<+10;+i%2B%2B)
{
++++//something+here
}|1252077|编译后(未经优化)编译后的版本可能如下所示(VS2015)：|1252078|--------+C7+45+B0+00+00+00+00++mov+++++++++dword+ptr+[i],0++
--------+EB+09+++++++++++++++++jmp+++++++++labelB+
labelA+++8B+45+B0++++++++++++++mov+++++++++eax,dword+ptr+[i]++
--------+83+C0+01++++++++++++++add+++++++++eax,1++
--------+89+45+B0++++++++++++++mov+++++++++dword+ptr+[i],eax++
labelB+++83+7D+B0+0A+++++++++++cmp+++++++++dword+ptr+[i],0Ah++
--------+7D+02+++++++++++++++++jge+++++++++out1+
--------+EB+EF+++++++++++++++++jmp+++++++++labelA++
out1:|1252079|整个循环是8条指令(26字节)。它实际上有6条指令(17字节)和2个分支。是的，是的，我知道它可以做得更好(这只是一个例子)。|1252080|现在考虑一下这个常见的结构，你会经常发现它是由嵌入式开发人员编写的：|1252081|i+=+10;
do
{
++++//something+here
}+while+(--i);|1252082|它还迭代了10次(是的，我知道i值与所示的for循环不同，但我们关心这里的迭代次数)。这可能会被编译成：|1252083|00074EBC+C7+45+B0+01+00+00+00+mov+++++++++dword+ptr+[i],1++
00074EC3+8B+45+B0+++++++++++++mov+++++++++eax,dword+ptr+[i]++
00074EC6+83+E8+01+++++++++++++sub+++++++++eax,1++
00074EC9+89+45+B0+++++++++++++mov+++++++++dword+ptr+[i],eax++
00074ECC+75+F5++++++++++++++++jne+++++++++main%2B0C3h+(074EC3h)++|1252084|5条指令(18字节)和一个分支。实际上循环中有4条指令(11字节)。|1252085|最好的事情是，一些CPU(包括x86/x64兼容)具有可以递减寄存器的指令，稍后将结果与零进行比较，如果结果不同于零，则执行分支。几乎所有的PC+cpus都执行此指令。使用它，循环实际上只是一个(是的，一个)2字节的指令：|1252086|00144ECE+B9+0A+00+00+00+++++++mov+++++++++ecx,0Ah++
label:
++++++++++++++++++++++++++//+something+here
00144ED3+E2+FE++++++++++++++++loop++++++++label+(0144ED3h)++//+decrement+ecx+and+jump+to+label+if+not+zero|1252087|我需要解释哪个更快吗？|1252088|现在，即使特定的CPU没有实现上面的指令，模拟它所需要的就是一个递减，如果前一条指令的结果恰好是零，那么后面就是条件跳转。|1252089|因此，不管你可能指出的一些情况，为什么我错了，等等，我强调-是的，如果你知道如何，为什么和何时循环，向下循环是有益的。|1252090|PS。是的，我知道wise编译器(具有适当的优化级别)会将for循环(具有递增循环计数器)重写为等同于do..while的恒定循环迭代……(或展开它)+...|1252091|entityMap^0|0|0|0|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|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1K|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1L|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1M|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1N|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1P|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1R|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1S|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1T|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1U|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|1V|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1W|8|@]|9|@]|A|$]]|$1|16|3|17|5|H|7|1X|8|@]|9|@]|A|$I|J]]|$1|18|3|19|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|20|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|21|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|22|8|@]|9|@]|A|$]]]|1H|$]]

What your teacher have said was some oblique statement without much clarification.
It is NOT that decrementing is faster than incrementing but you can create much much faster loop with decrement than with increment.

Without going on at length about it, without need of using loop counter etc - what matters below is just speed and loop count (non zero).

Here is how most people implement loop with 10 iterations:

<pre><code>int i;
for (i = 0; i &lt; 10; i++)
{
 //something here
}
</code></pre>

For 99% of cases it is all one may need but along with PHP, PYTHON, JavaScript there is the whole world of time critical software (usually embedded, OS, games etc) where CPU ticks really matter so look briefly at assembly code of:

<pre><code>int i;
for (i = 0; i &lt; 10; i++)
{
 //something here
}
</code></pre>

after compilation (without optimisation) compiled version may look like this (VS2015):

<pre><code>-------- C7 45 B0 00 00 00 00 mov dword ptr [i],0 
-------- EB 09 jmp labelB 
labelA 8B 45 B0 mov eax,dword ptr [i] 
-------- 83 C0 01 add eax,1 
-------- 89 45 B0 mov dword ptr [i],eax 
labelB 83 7D B0 0A cmp dword ptr [i],0Ah 
-------- 7D 02 jge out1 
-------- EB EF jmp labelA 
out1:
</code></pre>

The whole loop is 8 instructions (26 bytes). In it - there are actually 6 instructions (17 bytes) with 2 branches. Yes yes I know it can be done better (its just an example).

Now consider this frequent construct which you will often find written by embedded developer:

<pre><code>i = 10;
do
{
 //something here
} while (--i);
</code></pre>

It also iterates 10 times (yes I know i value is different compared with shown for loop but we care about iteration count here).
This may be compiled into this:

<pre><code>00074EBC C7 45 B0 01 00 00 00 mov dword ptr [i],1 
00074EC3 8B 45 B0 mov eax,dword ptr [i] 
00074EC6 83 E8 01 sub eax,1 
00074EC9 89 45 B0 mov dword ptr [i],eax 
00074ECC 75 F5 jne main+0C3h (074EC3h) 
</code></pre>

5 instructions (18 bytes) and just one branch. Actually there are 4 instruction in the loop (11 bytes).

The best thing is that some CPUs (x86/x64 compatible included) have instruction that may decrement a register, later compare result with zero and perform branch if result is different than zero. Virtually ALL PC cpus implement this instruction. Using it the loop is actually just one (yes one) 2 byte instruction:

<pre><code>00144ECE B9 0A 00 00 00 mov ecx,0Ah 
label:
 // something here
00144ED3 E2 FE loop label (0144ED3h) // decrement ecx and jump to label if not zero
</code></pre>

Do I have to explain which is faster?

Now even if particular CPU does not implement above instruction all it requires to emulate it is a decrement followed by conditional jump if result of previous instruction happens to be zero.

So regardless of some cases that you may point out as an comment why I am wrong etc etc I EMPHASISE - YES IT IS BENEFICIAL TO LOOP DOWNWARDS if you know how, why and when.

PS. Yes I know that wise compiler (with appropriate optimisation level) will rewrite for loop (with ascending loop counter) into do..while equivalent for constant loop iterations ... (or unroll it) ...

Our computer science teacher once said that for some reason it is more efficient to count down than to count up.
For example if you need to use a FOR loop and the loop index is not used somewhere (like printing a line of N * to the screen)
I mean that code like this:

<pre><code>for (i = N; i &gt;= 0; i--) 
 putchar('*'); 
</code></pre>

is better than:

<pre><code>for (i = 0; i &lt; N; i++) 
 putchar('*'); 
</code></pre>

Is it really true? And if so, does anyone know why?

Is it faster to count down than it is to count up?

微控制器

编译器

Java

我们的计算机科学老师曾经说过，出于某种原因，倒计时比倒计时更有效。例如，如果您需要使用For循环，而循环索引并未在某些地方使用(例如在屏幕上打印一行N*)，我的意思是代码如下：for (i = N; i >= 0; i--) putchar('*'); 比：for (i = 0; i < N; i++) ...

问倒计时比倒计时快吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问倒计时比倒计时快吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问倒计时比倒计时快吗？
EN