What the Advantages of while loop over the loop?

Answer 1

Here you can initialize, check for condition and incriment the variable at the same time inside in the for loop

like

for(int i=0;i<10;i++)

and for other looping structures you need to have these three things at different places.

Answer 2

Loops allow you to save space in source code and execute code an arbitrary number of times. The only other way to do this would be recursion, but with Java's fixed stack size, recursion has a very limited depth.

Answer 3

Procedural (unstructured) loops make use of gotostatements and labels. Consider the following loop:

begin_loop: /* ... */

if (x) goto begin_loop;

The loop body is denoted by the comment and may contain any number of statements.

The loop itself is relatively easy to understand because the label gives a reasonable hint to the reader that what follows is a loop. However, the control expression (x) is placed at the end of the loop so the body of the loop always executes at least once. Often this is undesirable; we'd like to avoid the initial execution of the loop. To do so we need to rewrite the loop as follows:

begin_loop:

if (!x) goto end_loop;

/* ... */

goto begin_loop;

end_loop:

The problem with this is that we've got to reverse the logic of the control expression so it's not immediately obvious to us that the loop only iterates when x is true. The more complex the expression the harder it becomes to digest the logic of the control expression. Code that is difficult to read is also difficult to maintain.

Compare the equivalent structured loop:

while (x) {

/* ... */

}

Note that there is (generally) no advantage in terms of performance; both loops will generate the exact same machine code. The advantage is with respect to the readability of the code. The code is much less verbose and logic is clear and concise.

On the rare occasions where we actually need the loop body to execute at least once (as per the first example above), we don't have to reverse the logic of the control expression, we simply move it to the end of the loop body:

do {

/* ... */

} while (x);

Counted loops are a fairly common type of loop. If we wish a loop to execute ten times, for instance, we might use the following procedural version:

x = 0;

begin_loop:

if (x==10) goto end_loop;

/* ... */

++x;

goto begin_loop;

end_loop:

The problem with this is that the control expressions that actually define the loop are separated, both inside and outside of the loop.

The structured version keeps everything in the same place, up front where it belongs:

for (x=0; x!=10; ++x) {

/* ... */

}

Again, the structure reduces verbosity, aids readability and thus reduces the cost of maintenance.

Although structured loops don't generally offer any performance advantage, the compiler cannot easily determine if a procedural loop really is a loop or not. A goto is simply a branching statement and will generally be treated as such. However, a structured loop makes it clear to the compiler that the code really is a loop. The compiler can thus establish a more complete overview of the loop's structure and thus determine how best to optimise the code to produce the most efficient machine code. This is particularly true of a counted loop where the control variable can be placed in an accumulator register; there is no need to continually move the value in and out of memory. With a procedural loop, the actual "structure" of the loop won't be obvious to the compiler so it generally won't make any attempt to optimise the code.

Answer 4

loop is powerful feature of c progamming language and it can help develop and programme to reduce many lines of code to few lines...