When implementing an infinite loop, is there a difference in using while (1) vs for (;;) vs goto (in C)?

Question

When implementing an infinite loop, is there a difference in using while(1) vs for(;;) vs goto ?

Thanks Chenz

Answer 1

They are equivalent even if you turned off the optimizer.

Example:

 #include <stdio.h> extern void f(void) { while(1) { putchar(' '); } } extern void g(void) { for(;;){ putchar(' '); } } extern void h(void) { z: putchar(' '); goto z; } 

Compiling with gcc -O0 gives an equivalent build for all three functions:

  f: ; [ EXTERNAL ] ; +00000 00000fb4 80402DE9 stmdb sp!,{r7,lr} +00004 00000fb8 00708DE2 add r7,sp,#0x0 +00008 00000fbc 2000A0E3 loc_000008: mov r0,#0x20 +0000c 00000fc0 0A0000EB bl putchar (stub) +00010 00000fc4 FCFFFFEA b loc_000008 ; ; g: ; [ EXTERNAL ] ; +00000 00000fc8 80402DE9 stmdb sp!,{r7,lr} +00004 00000fcc 00708DE2 add r7,sp,#0x0 +00008 00000fd0 2000A0E3 loc_000008: mov r0,#0x20 +0000c 00000fd4 050000EB bl putchar (stub) +00010 00000fd8 FCFFFFEA b loc_000008 ; ; h: ; [ EXTERNAL ] ; +00000 00000fdc 80402DE9 stmdb sp!,{r7,lr} +00004 00000fe0 00708DE2 add r7,sp,#0x0 +00008 00000fe4 2000A0E3 loc_000008: mov r0,#0x20 +0000c 00000fe8 000000EB bl putchar (stub) +00010 00000fec FCFFFFEA b loc_000008 

Answer 2

I just compared the unoptimized gcc assembler output:

 # cat while.c int main() { while(1) {}; return 0; } # cat forloop.c int main() { for (;;) { }; return 0; } 

Draw the assembler output:

 # gcc -S while.c # gcc -S forloop.c 

Compare assembler files:

 # diff forloop.s while.s 1c1 < .file "forloop.c" --- > .file "while.c" 

As you can see, there are no significant differences. Here is the conclusion

 # cat while.s .file "while.c" .text .globl main .type main, @function main: pushl %ebp movl %esp, %ebp .L2: jmp .L2 # this is the loop in both cases .size main, .-main .ident "GCC: (GNU) 4.4.3" .section .note.GNU-stack,"",@progbits 

Although this is not technical evidence that they are the same, I would say that it is in 99.9% of cases.

Answer 3

There is hardly any difference in the generated assembly. This is rather a stylistic problem:

Jump in - just oooh: jumps back without a clear endless block

while (1) - better, the condition is "dummy", although you will often be warned by the compiler (warning level 4) or a static analysis tool

for (;;) may not be the most beautiful, but imho is best suited because this construct cannot have any other meaning (compared to that time). But some other people still prefer (1) for the "same" reason ...

Answer 4

Absent. Use what is most readable to you

Answer 5

while(1) and for(;;) are exactly equivalent, and both are well-understood idioms for coding infinite loops.

I would avoid using goto : to break out of an infinite loop or move on to the next iteration, use break and continue .

Answer 6

In C, true is implemented as follows (depending on the compiler)

 #define TRUE 1 

or

 #define TRUE (-1) 

And false is executed as

 #define FALSE 0 

therefore, while (1) equivalent to while (true) , since 0 is considered false.

the while (1) == for (; ;) , since there are no stop conditions.

which translates to assembler as

 :loop ... ... ... goto loop 

therefore, if the assembler code does not have a ret or exit statement, it is considered an infinite loop.

Answer 7

Despite the lack of significant differences, as mentioned in other posts, the common reason for using for (;;) instead of while (1) is that static analysis tools (and some compilers with certain warning levels) often complain about the while loop.

Goto is a little nasty, but should contain the same code as the others. Personally, I stick with for (;;) (to keep Lint happy), but I have no problem with while (1) .

Answer 8

From what I recall about “sorting out the years,” it will not matter much (compilers are smart enough). This is more about IMO aesthetics.