For vs. while in C programming ?

Question

There are 3 loops in C: for, while, do-while. What's the difference between them? For example, it seems nearly all while statement can be replaced by for statement, right? Then, what's the advantage using while?

Answer 1

For the sake of readability

Answer 2

A while loop will always evaluate the condition first.

while (condition) {
  //gets executed after condition is checked
}

A do/while loop will always execute the code in the do{} block first and then evaluate the condition.

do {
  //gets executed at least once
} while (condition); 

A for loop allows you to initiate a counter variable, a check condition, and a way to increment your counter all in one line.

for (int x = 0; x < 100; x++) {
   //executed until x >= 100
}

At the end of the day, they are all still loops, but they offer some flexibility as to how they are executed.

Here is a great explanation of the reasoning behind the use of each different type of loop that may help clear things up. Thanks clyfe

The main difference between the for's and the while's is a matter of pragmatics: we usually use for when there is a known number of iterations, and use while constructs when the number of iterations in not known in advance. The while vs do ... while issue is also of pragmatics, the second executes the instructions once at start, and afterwards it behaves just like the simple while.

---

For loops are especially nice because they are concise. In order for this for loop

for (int x = 0; x < 100; x++) {
   //executed until x >= 100
}

to be written as a while loop, you'd have to do the following.

int count = 0;
while (count < 100) {
  //do stuff
  count++;
}

In this case, there's just more stuff to keep up with and the count++; could get lost in the logic. This could end up being troublesome depending on where count gets incremented, and whether or not it should get incremented before or after the loop's logic. With a for loop, your counter variable is always incremented before the next iteration of the loop, which adds some uniformity to your code.

---

For the sake of completeness, it's probably meaningful to talk about break and continue statements here which come in handy when doing loop processing.

break will instantly terminate the current loop and no more iterations will be executed.

//will only run "do stuff" twice
for (int x = 0; x < 100; x++) {
  if (x == 2) {
    break;
  }
  //do stuff
}

continue will terminate the current iteration and move on to the next one.

//will run "do stuff" until x >= 100 except for when x = 2
for (int x = 0; x < 100; x++) {
  if (x == 2) {
    continue;
  }
  //do stuff
}

Note that in a for loop, 'continue' evaluates the 'part3' expression of 'for (part1; part2; part3)'; in contrast, in a while loop, it just jumps to re-evaluate the loop condition.

Answer 3

If you want a loop to execute while a condition is true, and not for a certain number of iterations, it is much easier for someone else to understand:

while (cond_true)

than something like this:

for (; cond_true ; )

Answer 4

They're all interchangeable; you could pick one type and use nothing but that forever, but usually one is more convenient for a given task. It's like saying "why have switch, you can just use a bunch of if statements" -- true, but if it's a common pattern to check a variable for a set of values, it's convenient and much easier to read if there's a language feature to do that

Answer 5

A for suggest a fixed iteration using an index or variants on this scheme.

A while and do... while are constructions you use when there is a condition that must be checked each time (apart from some index-alike construction, see above). They differ in when the first execution of the condition check is performed.

You can use either construct, but they have their advantages and disadvantages depending on your use case.

Answer 6

They are all the same in the work they do. You can do the same things using any of them. But for readability, usability, convenience etc., they differ.

Answer 7

A difference between while and do-while is that while checks the loop condition and if this is true, the body is executed and the condition checked again. The do-while checks the condition after execution of the body, so with do-while the body is executed at least one time.

Of course you can write a while loop as a do-while and vv, but this usually requires some code duplication.

Answer 8

Remember, a for loop is essentially a fancy while loop. They're the same thing.

while <some condition is true> {
   // do some stuff
   // possibly do something to change the condition
}


for ( some var, <some condition is true>; increment var ) {

}

The advantage of a for loop is that it's harder to accidentally do an infinite loop. Or rather, it's more obvious when you do one because you generally put the loop var in the initial statement.

A while loop is more clear when you're not doing a standard incrementing pattern. For example:

int x = 1;
while( x != 10 ) {
  if ( some condition )
     x = 10;
  else 
     x += 5;
}

Answer 9

You should use such a loop, that most fully conforms to your needs. For example:

for(int i = 0; i < 10; i++)
{
    print(i);
}

//or

int i = 0;
while(i < 10)
{
    print(i);
    i++;
}

Obviously, in such situation, "for" looks better, than "while". And "do while" shoud be used when some operations must be done already before the moment when condition of your loop will be checked.

Sorry for my bad english).

Answer 10

One peculiarity of the do while is that you need a semi-colon after the while to complete. It is often used in macro definitions to execute several statements only once while constraining the impact of the macro. If macros where defined as blocks, some parsing errors may occur.

One explanation among others

Answer 11

For loops (at least considering C99) are superior to while loops because they limit the scope of the incremented variable(s).

Do while loops are useful when the condition is dependant on some inputs. They are the most seldom used of the three loop types.

Answer 12

Between for and while: while does not need initialization nor update statement, so it may look better, more elegant; for can have statements missing, one two or all, so it is the most flexible and obvious if you need initialization, looping condition and "update" before looping. If you need only loop condition (tested at the beginning of the loop) then while is more elegant.

Between for/while and do-while: in do-while the condition is evaluated at the end of the loop. More confortable if the loop must be executed at least once.

Answer 13

WHILE is more flexible. FOR is more concise in those instances in which it applies.

FOR is great for loops which have a counter of some kind, like

for (int n=0; n<max; ++n)

You can accomplish the same thing with a WHILE, of course, as others have pointed out, but now the initialization, test, and increment are broken across three lines. Possibly three widely-separated lines if the body of the loop is large. This makes it harder for the reader to see what you're doing. After all, while "++n" is a very common third piece of the FOR, it's certainly not the only possibility. I've written many loops where I write "n+=increment" or some more complex expression.

FOR can also work nicely with things other than a counter, of course. Like

for (int n=getFirstElementFromList(); listHasMoreElements(); n=getNextElementFromList())

Etc.

But FOR breaks down when the "next time through the loop" logic gets more complicated. Consider:

initializeList();
while (listHasMoreElements())
{
  n=getCurrentElement();
  int status=processElement(n);
  if (status>0)
  {
    skipElements(status);
    advanceElementPointer();
  }
  else
  {
    n=-status;
    findElement(n);
  }
}

That is, if the process of advancing may be different depending on conditions encountered while processing, a FOR statement is impractical. Yes, sometimes you could make it work with a complicated enough expressions, use of the ternary ?: operator, etc, but that usually makes the code less readable rather than more readable.

In practice, most of my loops are either stepping through an array or structure of some kind, in which case I use a FOR loop; or are reading a file or a result set from a database, in which case I use a WHILE loop ("while (!eof())" or something of that sort).

Answer 14

They are pretty much same except for do-while loop. The for loop is good when you have a counter kind of variable. It makes it obvious. while loop makes sense in cases where a flag is being checked as show below :

while (!done) {
   if (some condtion) 
      done = true;
}

Answer 15

One common misunderstanding withwhile/for loops I've seen is that their efficiency differs. While loops and for loops are equally efficient. I remember my computer teacher from highschool told me that for loops are more efficient for iteration when you have to increment a number. That is not the case.

For loops are simply syntactically sugared while loops, and make iteration code faster to write.

When the compiler takes your code and compiles it, it is translating it into a form that is easier for the computer to understand and execute on a lower level (assembly). During this translation, the subtle differences between the while and for syntaxes are lost, and they become exactly the same.

Answer 16

If there is a strong concern about speed & performances, the best approach is to verify at assembly level the code produced by the compiler.

For instance, the following code shows that the "do-while" is a bit faster. This because the "jmp" istruction is not used by the "do-while" loop.

BTW, in this specifc example, the worst case is given by the "for" loop. :))

int main(int argc, char* argv[])  
{     
int i;  
char x[100];  

//"FOR" LOOP:
for(i=0; i<100; i++ )  
{ x[i] = 0; 
}  

//"WHILE" LOOP:  
i=0;  
while(i<100 )  
{ x[i++] = 0;  
}  

//"DO-WHILE" LOOP:  
i=0;  
do  
{ x[i++] = 0;   
}  
while(i<100);  

return 0;  
}  

// "FOR" LOOP:

    010013C8  mov         dword ptr [ebp-0Ch],0     
    010013CF  jmp         wmain+3Ah (10013DAh)     

  for(i=0; i<100; i++ )   
  { x[i] = 0;  
    010013D1  mov         eax,dword ptr [ebp-0Ch]  <<< UPDATE i 
    010013D4  add         eax,1     
    010013D7  mov         dword ptr [ebp-0Ch],eax   
    010013DA  cmp         dword ptr [ebp-0Ch],64h  <<< TEST  
    010013DE  jge         wmain+4Ah (10013EAh)     <<< COND JUMP   
    010013E0  mov         eax,dword ptr [ebp-0Ch]  <<< DO THE JOB..
    010013E3  mov         byte ptr [ebp+eax-78h],0   
    010013E8  jmp         wmain+31h (10013D1h)     <<< UNCOND JUMP 
  }  

// "WHILE" LOOP:

  i=0;  
  010013EA  mov         dword ptr [ebp-0Ch],0   
  while(i<100 )   
  { x[i++] = 0;   
    010013F1  cmp         dword ptr [ebp-0Ch],64h   <<< TEST
    010013F5  jge         wmain+6Ah (100140Ah)      <<< COND JUMP 
    010013F7  mov         eax,dword ptr [ebp-0Ch]   <<< DO THE JOB..
    010013FA  mov         byte ptr [ebp+eax-78h],0   
    010013FF  mov         ecx,dword ptr [ebp-0Ch]   <<< UPDATE i 
    01001402  add         ecx,1   
    01001405  mov         dword ptr [ebp-0Ch],ecx   
    01001408  jmp         wmain+51h (10013F1h)      <<< UNCOND JUMP
  }  

// "DO-WHILE" LOOP:

i=0;  
.  0100140A  mov         dword ptr [ebp-0Ch],0   
  do  
  { x[i++] = 0;   
    01001411  mov         eax,dword ptr [ebp-0Ch]   <<< DO THE JOB..
    01001414  mov         byte ptr [ebp+eax-78h],0   
    01001419  mov         ecx,dword ptr [ebp-0Ch]   <<< UPDATE i
    0100141C  add         ecx,1   
    0100141F  mov         dword ptr [ebp-0Ch],ecx   
    01001422  cmp         dword ptr [ebp-0Ch],64h   <<< TEST
    01001426  jl          wmain+71h (1001411h)      <<< COND JUMP
  }
  while(i<100);