是不是比 for 快？

Question

As in the topic, I learnt in school, that loop for is faster than loop while , but someone told me that while is faster.

I must optimize the program and I want to write while instead for , but I have a concern that it will be slower?

for example I can change for loop:

for (int i=0; i<x; i++)
{
   cout<<"dcfvgbh"<<endl;
}

into while loop:

i=0;
while (i<x)
{
    cout<<"dcfvgbh"<<endl;
    i++;
}

Answer 1

The standard requires (§6.5.3/1) that:

The for statement
for ( for-init-statement condition _opt ; expression _opt ) statement
is equivalent to

{ for-init-statement while ( condition ) { statement expression; } }

As such, you're unlikely to see much difference between them (even if execution time isn't necessarily part of the equivalence specified in the standard). There are a few exceptions listed to the equivalence as well (scopes of names, execution of the expression before evaluating the condition if you execute a continue ). The latter could, at least theoretically, affect speed a little bit under some conditions, but probably not enough to notice or care about as a rule, and definitely not unless you actually used a continue inside the loop.

Answer 2

For all intents and purposes for is just a fancy way of writing while , so there is no performance advantage either way. The main reason to use one over the other is how the intent is translated so the reader understands better what the loop is actually doing.

Answer 3

No.

Nope, it's not.

It is not faster.

Answer 4

You cout will eat 99% of the clock cycles for this loop. Beware micro-optimization. At any rate, these two will give essentially identical code.

The only time when a for loop can be faster is when you have a known terminating condition - eg

for(ii = 0; ii < 24; ii++)

because some optimizing compilers will perform loop unrolling . This means they will not perform a test on every pass through the loop because they can "see" that just doing the thing inside the loop 24 times (or 6 times in blocks of 4, etc) will be a tiny bit more efficient. When the thing inside the loop is very small (eg jj += ii ;), such optimization makes the for loop a bit faster than the while (which typically doesn't do "unrolling").

Otherwise - no difference.

update at the request of @zeroth

Source: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.47.9346&rep=rep1&type=pdf

Quote from source (my emphasis):

Unrolling a loop at the source- code level involves identification of loop constructs (eg, for, while, do-while, etc.), determination of the loop count to ensure that it is a counting loop, replication of the loop body and the adjustment of loop count of the unrolled loop. A prologue or epilogue code may also be inserted. Using this approach, it is difficult to unroll loops formed using a while and goto statements since the loop count is not obvious. However, for all but the simplest of loops, this approach is tedious and error prone.

The other alternative is to unroll loops automatically. Automatic unrolling can be done early on source code, late on the unoptimized intermediate representation, or very late on an optimized representation of the program. If it is done at the source-code level, then typically only counting loops formed using for statements are unrolled. Unrolling loops formed using other control constructs is difficult since the loop count is not obvious.

Answer 5

To the best of my knowledge swapping out for loops for while loops is not an established optimization technique.

Both your examples will be identical in performance, but as an exercise you could time them to confirm this for yourself.