Why use infinite loops?
A loop like:
while (true)
{
// do something
if (something else) break;
// do more
}
lets you break out of the loop in the middle, rather than at the start (while/for) or end (do-while).
If you've got a complex condition, you might also want to use this style to make the code clearer.
Best infinite loop
In any normal compiler, there should be absolutely no difference. For example, here's what LLVM-clang
generates (with the -O3
flag) for while (1) {}
:
.file "test.c"
.text
.globl main
.align 16, 0x90
.type main,@function
main:
pushl %ebp
movl %esp, %ebp
.align 16, 0x90
.LBB0_1:
jmp .LBB0_1
Note the jmp .LBB0_1
part, which is the actual infinite loop. For the for (;;)
kind, it generates absolutely the same code.
You can also try with other compilers for fun, but it's best just stop worrying about it.
OK, I just had to try with gcc
as well:
.file "test.c"
.text
.globl main
.type main, @function
main:
pushl %ebp
movl %esp, %ebp
.L2:
jmp .L2
Endless loop in C/C++
The problem with asking this question is that you'll get so many subjective answers that simply state "I prefer this...". Instead of making such pointless statements, I'll try to answer this question with facts and references, rather than personal opinions.
Through experience, we can probably start by excluding the do-while alternatives (and the goto), as they are not commonly used. I can't recall ever seeing them in live production code, written by professionals.
The while(1)
, while(true)
and for(;;)
are the 3 different versions commonly existing in real code. They are of course completely equivalent and results in the same machine code.
for(;;)
This is the original, canonical example of an eternal loop. In the ancient C bible The C Programming Language by Kernighan and Ritchie, we can read that:
K&R 2nd ed 3.5:
for (;;) {
...
}is an "infinite" loop, presumably to be broken by other means, such
as a break or return. Whether to use while or for is largely a matter
of personal preference.For a long while (but not forever), this book was regarded as canon and the very definition of the C language. Since K&R decided to show an example of
for(;;)
, this would have been regarded as the most correct form at least up until the C standardization in 1990.However, K&R themselves already stated that it was a matter of preference.
And today, K&R is a very questionable source to use as a canonical C reference. Not only is it outdated several times over (not addressing C99 nor C11), it also preaches programming practices that are often regarded as bad or blatantly dangerous in modern C programming.
But despite K&R being a questionable source, this historical aspect seems to be the strongest argument in favour of the
for(;;)
.The argument against the
for(;;)
loop is that it is somewhat obscure and unreadable. To understand what the code does, you must know the following rule from the standard:ISO 9899:2011 6.8.5.3:
for ( clause-1 ; expression-2 ; expression-3 ) statement
/--/
Both clause-1 and expression-3 can be omitted. An omitted expression-2
is replaced by a nonzero constant.Based on this text from the standard, I think most will agree that it is not only obscure, it is subtle as well, since the 1st and 3rd part of the for loop are treated differently than the 2nd, when omitted.
while(1)
This is supposedly a more readable form than
for(;;)
. However, it relies on another obscure, although well-known rule, namely that C treats all non-zero expressions as boolean logical true. Every C programmer is aware of that, so it is not likely a big issue.There is one big, practical problem with this form, namely that compilers tend to give a warning for it: "condition is always true" or similar. That is a good warning, of a kind which you really don't want to disable, because it is useful for finding various bugs. For example a bug such as
while(i = 1)
, when the programmer intended to writewhile(i == 1)
.Also, external static code analysers are likely to whine about "condition is always true".
while(true)
To make
while(1)
even more readable, some usewhile(true)
instead. The consensus among programmers seem to be that this is the most readable form.However, this form has the same problem as
while(1)
, as described above: "condition is always true" warnings.When it comes to C, this form has another disadvantage, namely that it uses the macro
true
from stdbool.h. So in order to make this compile, we need to include a header file, which may or may not be inconvenient. In C++ this isn't an issue, sincebool
exists as a primitive data type andtrue
is a language keyword.Yet another disadvantage of this form is that it uses the C99 bool type, which is only available on modern compilers and not backwards compatible. Again, this is only an issue in C and not in C++.
So which form to use? Neither seems perfect. It is, as K&R already said back in the dark ages, a matter of personal preference.
Personally, I always use for(;;)
just to avoid the compiler/analyser warnings frequently generated by the other forms. But perhaps more importantly because of this:
If even a C beginner knows that for(;;)
means an eternal loop, then who are you trying to make the code more readable for?
I guess that's what it all really boils down to. If you find yourself trying to make your source code readable for non-programmers, who don't even know the fundamental parts of the programming language, then you are only wasting time. They should not be reading your code.
And since everyone who should be reading your code already knows what for(;;)
means, there is no point in making it further readable - it is already as readable as it gets.
Idom for infinite loops in PHP?
Monitoring applications
If you have a background process that monitors the state of your servers and sends an email if trouble occurs. It would have an infinite loop to repeatably check the servers (with some pause between iterations.)
Server listening for Clients
If you have a server script that listens to a socket for connections, it will loop infinitely, blocking while waiting for new clients to connect.
Video Games
Games usually have a "game loop" that runs once a frame, indefinitely.
Or... anything else that needs to keep running in the background with periodic checks.
Continuous Looping Page (Not Infinite Scroll)
Try this:
$('document').ready(function() {
$(document).scroll(function(){
if(document.documentElement.clientHeight +
$(document).scrollTop() >= document.body.offsetHeight )$(document).scrollTop(0);
});
});
Infinite loop in useEffect
Passing an empty array as the second argument to useEffect makes it only run on mount and unmount, thus stopping any infinite loops.
useEffect(() => {
setIngredients({});
}, []);
This was clarified to me in the blog post on React hooks at https://www.robinwieruch.de/react-hooks/
Why do I get a Infinite Loop (Prolog)
As said in the comment, the loop is caused by r/1
. To show why, yust type ?- trace, q(b).
Look at the trace (ignore by now the singleton warning):
Call:q(b)
Call:r(_4244)
Call:r(f(_4162))
Call:r(f(f(_4162)))
Call:r(f(f(f(_4162))))
Call:r(f(f(f(f(_4162)))))
Call:r(f(f(f(f(f(_4162))))))
Call:r(f(f(f(f(f(f(_4162)))))))
Call:r(f(f(f(f(f(f(f(_4162))))))))
Now you can see that it try to derives r/1
entering a loop. You can see also this question to have a more in depth explaination.
Notice that in prolog, the order of the clauses matters. Just try to put the line r(X) :- r(f(X)).
to the bottom of your program. Now try ?- q(b).
On the first answer you get true
because prolog unifies X
with a
and Y
with b
before entering in a loop.
Related Topics
Acquire/Release Versus Sequentially Consistent Memory Order
Where Are the Man Pages for C++
New (Std::Nothrow) VS. New Within a Try/Catch Block
How to Declare an Array of Objects Whose Class Has No Default Constructor
Using C Function from Other Package in Rcpp
Thread Safety of Std::Map for Read-Only Operations
Is It Ok to Use C-Style Cast for Built-In Types
Why the Sizeof(Bool) Is Not Defined to Be One, by the Standard Itself
Why How to Call Base Template Class Method from Derived Class
How to Serialize Boost::Dynamic_Bitset
Setting Roi with Mouse from a Rectangle on a Video
Srand(Time(Null)) Generating Similar Results
How to Implement Coroutines in C++