What's the point of using "while (true) {...}"?

Why do some people use while(true){} b开发者_开发技巧locks in their code? How does it work?

---

It's an infinite loop. At each iteration, the condition will be evaluated. Since the condition is true, which is always... true... the loop will run forever. Exiting the loop is done by checking something inside the loop, and then breaking if necessary.

By placing the break check inside the loop, instead of using it as the condition, this can make it more clear that you're expecting this to run until some event occurs.

A common scenario where this is used is in games; you want to keep processing the action and rendering frames until the game is quit.

---

It's just a loop that never ends on its own, known as an infinite-loop. (Often times, that's a bad thing.)

When it's empty, it serves to halt the program indefinitely*; otherwise there's typically some condition in the loop that, when true, breaks the loop:

while (true)
{
    // ...

    if (stopLoop)
        break;

    // ...
}

This is often cleaner than an auxiliary flag:

bool run = true;
while (run)
{
    // ...

    if (stopLoop)
    {
        run = false;
        continue; // jump to top
    }

    // ...
}

Also note some will recommend for (;;) instead, for various reasons. (Namely, it might get rid of a warning akin to "conditional expression is always true".)

*In most languages.

---

Rather than stuff all possible conditions in the while statement,

// Always tests all conditions in loop header:
while( (condition1 && condition2) || condition3 || conditionN_etc ) {

    // logic...

    if (notable_condition)
        continue;  // skip remainder, go direct to evaluation portion of loop

    // more logic
    // maybe more notable conditions use keyword: continue
}

Some programmers might argue it's better to put the conditions throughough the logic, (i.e. not just inside the loop header) and to employ break statements to get out at appropriate places. This approach will usually negate the otherwise original conditions to determine when to leave the loop (i.e. instead of when to keep looping).

// Always tests all conditions in body of loop logic: 
while(true) {

    //logic...

    if (!condition1 || !condition2)
        break;  // Break out for good. 

    // more logic...

    if (!condition3)
        break;

     // even more logic ...
}

In real life it's often a more gray mixture, a combination of all these things, instead of a polarized decision to go one way or another.

Usage will depend on the complexity of the logic and the preferences of the programmer .. and maybe on the accepted answer of this thread :)

Also don't forget about do..while. The ultimate solution may use that version of the while construct to twist conditional logic to their liking.

do {
    //logic with possible conditional tests and break or continue 
} while (true); /* or many conditional tests */

In summary it's just nice to have options as a programmer. So don't forget to thank your compiler authors.

---

When Edsger W. Dijkstra was young, this was equivalent to:

         Do loop initialization
 label a:
         Do some code
         If (Loop is stoppable and End condition is met) goto label b
                     /* nowadays replaced by some kind of break() */
         Do some more code, probably incrementing counters
         go to label a
 label b:
         Be happy and continue

After Dijkstra decided to become Antigotoist, and convinced hordes of programmers to do so, a religious faith came upon earth and the truthiness of code was evident.

So the

 Do loop initialization
 While (true){
    some code
    If (Loop is stoppable and End condition is met) break();
    Do some more code, probably incrementing counters
 }
 Be happy and continue

Replaced the abomination.

Not happy with that, fanatics went above and beyond. Once proved that recursion was better, clearer and more general that looping, and that variables are just a diabolic incarnation, Functional Programming, as a dream, came true:

 Nest[f[.],x, forever[May God help you break]]   

And so, loops recursion became really unstoppable, or at least undemonstratively stoppable.

---

while (the condition){do the function} when the condition is true.. it will do the function.

so while(true) the condition is always true it will continue looping.

the coding will never proceed.

---

It's a loop that runs forever, unless there's a break statement somewhere inside the body.

---

The real point to have while (true) {..} is when semantics of exit conditions have no strong single preference, so its nice way to say to reader, that "well, there are actually break conditions A, B, C .., but calculations of conditions are too lengthy, so they were put into inner blocks independently in order of expected probability of appearance".