What's the term for "while(true)" loop with "break" inside?

Question

Suppose I have a loop in C++ or C# that goes like this:

while( true ) {
    doSomething();
    if( condition() ) {
        break;
    }
    doSomethingElse();
}

This is commonly called "infinite loop". Yet it is not technically infinite - it will stop once control flows through break.

What's the term for such loop - that has "loop forever" loop control statement and "break" inside?

Answer 1

Studying CS, this professor taught us that there are pre-checking loops (while(cond) {}), post-checking loops (do {} while(cond);), and middle-checking loops. (I might have badly translated this into English, but you get the idea.)

C and C++ do not have the latter (ISTR Ada having it, BICBW), so your construct is used for that in C and C++.

Answer 2

The very first course in CS at Stanford (Programming Methodology by Mehran Sahami) refers to this as a loop and a half. And it is not necessarily bad programming practice. Consider this example on collecting user input (taken from The Art and Science of Java by Eric Roberts, where Roberts also calls it a-loop-and-a-half):

prompt user and read in the first value
while (value != sentinel) {
    process the data value
    prompt user and read in a new value
}

And then the same thing solved using the loop and a half idea to avoid duplicate code:

while (true) {
    prompt user and read in a value
    if (value == sentinel) break;
    process the data value
}

Answer 3

Lacking an official name, I'd call it the Broken Loop. The ambiguity of this term is intended, since a break in the middle of a loop is a bit unclean, almost like a goto.

Answer 4

There is no definitive name. Infinite loop is, I think, the appropriate term. No loops are truly infinite, but this has the potential to be effectively infinite since it's possible that the branch that contains the break will never occur.

If you tell someone "create an infinite loop, and use a break for condition X" and they'll know what you mean. If someone is reviewing your code and says nothing more than "I don't like the infinite loop you wrote" you'll know what they are talking about (unless you have more than one, of course).

Answer 5

It's a do-while loop with the conditional in the wrong place.

Answer 6

I'd vote for "unconditional loop", similar to "unconditional jump". It illustrates exactly what is going on (the code loops unconditionally), without lying (unlike "infinite loop").

Answer 7

What's the term for such loop - that has "loop forever" loop control statement and "break" inside?

Its an infinite loop with a break condition.

I would agree with ammilind in that if you wanted to give it a special name you could call it an Infinite Partial Loop

Answer 8

On Rosetta Code, this particular pattern is described as an “N plus one half” loop. While it's not my favorite term, it's not terrible and is clearly a pattern that is useful for some kinds of loops. (The alternatives are to duplicate the before-the-condition code — potentially tricky in real programs — or to increase the nesting depth of the after-the-condition code while adding a loop condition variable; neither improves the maintainability or understandability of the code. The only reason for rejecting such constructs is if one insists on writing loops to be break-free.)

Answer 9

There is no standard term, but I would say it as Partial loop.

This loop is used when you want to break only after executing some part of the loop one last time (i.e. partial execution). It's used when you don't find a suitable situation where you may want to break the whole loop.

In this case, you want to break the loop after at least executing doSomething() one last time.

Answer 10

I have to agree with sbi here - I like the middle-checking loop term. This kind of construct was more popular when Structured Programming started to roll and many languages had syntactic support for them.

That said, it is now widespread knowledge that while loops are usually more mantainable, since it is easier to reason about invariants and they often handle the tricky empty case better.

In your particular case your loop is just equivalent to

for(; doSomething(), !condition(); doSomethingElse()){}

so I would only use the break version if either doSomething or doSomethingElse involved multiple statements and I'd rather not put them away into separate functions like you did.

That said, if your loop is more complicated then a (start, check, increment) iteration then you should consider refactoring it into something simpler.

Answer 11

I guess if we are going to try to make up a term for this, maybe:

Escapable Loop

Answer 12

I call it what it is, a "while true loop."

Also see is while(true) bad programming practice?

Answer 13

It is not so bad in every case. I find myself writing this kind of loops with certain kind of APIs. Say, for instance, that you have a loop object, and need to check for some condition quite deep in it, like so:

while (loop
    .getAExecutionModelFactory()
    .getActiveXexecutor()
    .getYCancelModelHandler()
    .getCurrentHandler()
    .isCancelled()) {
        // ... do something with the current Handler ....
        loop = ..... // prepare for next loop
}

Now suppose every getXXX-method could potentially return null. Then it would be still possible to write a boolean expression, although a quite complicated and unreadable one. And then we have to do redo almost the same to get at the current handler object. In such cases, I find it easier to write a while (true) loop with break and continue.