Is while (true) with break bad programming practice?

Question

I often use this code pattern:

while(true) {

    //do something

    if() {
        break;
    }

}   

Another progr

Answer 1

When you can write your code in the form

while (condition) { ... }

or

while (!condition) { ... }

with no exits (break, continue, or goto) in the body, that form is preferred, because someone can read the code and understand the termination condition just by looking at the header. That's good.

But lots of loops don't fit this model, and the infinite loop with explicit exit(s) in the middle is an honorable model. (Loops with continue are usually harder to understand than loops with break.) If you want some evidence or authority to cite, look no further than Don Knuth's famous paper on Structured Programming with Goto Statements; you will find all the examples, arguments, and explanations you could want.

A minor point of idiom: writing while (true) { ... } brands you as an old Pascal programmer or perhaps these days a Java programmer. If you are writing in C or C++, the preferred idiom is

for (;;) { ... }

There's no good reason for this, but you should write it this way because this is the way C programmers expect to see it.

Answer 2

I think the benefit of using "while(true)" is probably to let multiple exit condition easier to write especially if these exit condition has to appear in different location within the code block. However, for me, it could be chaotic when I have to dry-run the code to see how the code interacts.

Personally I will try to avoid while(true). The reason is that whenever I look back at the code written previously, I usually find that I need to figure out when it runs/terminates more than what it actually does. Therefore, having to locate the "breaks" first is a bit troublesome for me.

If there is a need for multiple exit condition, I tend to refactor the condition determining logic into a separate function so that the loop block looks clean and easier to understand.

Answer 3

The perfect consultant's answer: it depends. Most cases, the right thing to do is either use a while loop

while (condition is true ) {
    // do something
}

or a "repeat until" which is done in a C-like language with

do {
    // do something
} while ( condition is true);

If either of these cases works, use them.

Sometimes, like in the inner loop of a server, you really mean that a program should keep going until something external interrupts it. (Consider, eg, an httpd daemon -- it isn't going to stop unless it crashes or it's stopped by a shutdown.)

THEN AND ONLY THEN use a while(1):

while(1) {
   accept connection
   fork child process
}

Final case is the rare occasion where you want to do some part of the function before terminating. In that case, use:

while(1) { // or for(;;)
   // do some stuff
   if (condition met) break;
   // otherwise do more stuff.
}

Answer 4

I prefer

while(!<some condition>) {
    //do something
}

but I think it's more a matter of readability, rather than the potential to "forget the break." I think that forgetting the break is a rather weak argument, as that would be a bug and you'd find and fix it right away.

The argument I have against using a break to get out of an endless loop is that you're essentially using the break statement as a goto. I'm not religiously against using goto (if the language supports it, it's fair game), but I do try to replace it if there's a more readable alternative.

In the case of many break points I would replace them with

while( !<some condition> ||
       !<some other condition> ||
       !<something completely different> ) {
    //do something
}

Consolidating all of the stop conditions this way makes it a lot easier to see what's going to end this loop. break statements could be sprinkled around, and that's anything but readable.

Answer 5

There has been much talk about readability here and its very well constructed but as with all loops that are not fixed in size (ie. do while and while) you run at a risk.

His reasoning was that you could "forget the break" too easily and have an endless loop.

Within a while loop you are in fact asking for a process that runs indefinitely unless something happens, and if that something does not happen within a certain parameter, you will get exactly what you wanted... an endless loop.

Answer 6

using loops like

while(1) { do stuff }

is necessary in some situations. If you do any embedded systems programming (think microcontrollers like PICs, MSP430, and DSP programming) then almost all your code will be in a while(1) loop. When coding for DSPs sometimes you just need a while(1){} and the rest of the code is an interrupt service routine (ISR).