Infinite loop in C

In C programming, especially in embedded systems, infinite loops are commonly used for tasks that need to keep running continuously (e.g., monitoring sensors or controlling hardware). Here's an explanation of the different approaches you mentioned:

1. while(1) { … }

This is a clear and straightforward way to implement an infinite loop. The condition 1 is always true, so the loop continues indefinitely. The code inside the loop is executed repeatedly. This construct is widely used because it is simple, easy to read, and communicates exactly what is intended: an infinite loop.

Advantages:

• Readable and intuitive.

• Explicitly shows that the loop is meant to run forever.

Points to consider

• Beginner Misuse: Less experienced programmers might accidentally write while(condition) instead of while(1), leading to unexpected results.

• Tool Preferences: Some static analysis tools, like Lint, prefer for(;;) and may flag while(1).

• Optimization: In rare cases, for(;;) might produce slightly more efficient assembly code, though modern compilers handle both similarly.

• Condition Evaluation: while(1) evaluates the condition every iteration, while for(;;) skips this, though the difference is typically negligible.

Note for the compiler ones the performance difference is usually insignificant.

2. for(;;) { … }

This is a more compact form for writing an infinite loop. A for loop typically has three parts: initialization, condition, and increment. In for(;;), all parts are left empty, which effectively means:

• No initialization.

• No condition check (so it's always true).

• No increment (so nothing changes).

The result is an infinite loop that does exactly what while(1) does but in a more cryptic way.

Advantages:

• It’s the preferred method in K&R (the original C programming book by Kernighan and Ritchie). Its a good book 👍🏻

• Some argue it's more "elegant" or idiomatic C.

• Historically, some tools like Lint may prefer this form.

Disadvantages:

• Less readable, especially for beginners, since it doesn't explicitly show the infinite nature as clearly as while(1).

Personally, I dislike this construct because the syntax doesn’t exactly spell out what is going on.

3. goto Loop

This method uses a label (Loop:) and the goto statement to jump back to that label, creating an infinite loop. Probably FORTRAN programmers.

I discovered this style in some older codebases.

Loop:
    ...
    goto Loop;

Advantages:

• Sometimes preferred by assembly programmers, as it mimics how loops are often implemented at the machine level. Can be used to directly jump to a specific point, offering flexibility.

Disadvantages:

• goto is generally frowned upon because it can make code hard to follow and maintain. Can lead to "spaghetti code" if used extensively or improperly, which complicates debugging.

So What?

Understanding loop constructs and the reasons behind choosing one over another is valuable. It helps you learn about coding style, readability, conventions, and the historical context behind different approaches.

At the end of the day, follow what seems right for your situation.