Loops
Often in computer programming, it is necessary to perform a certain action a certain number of
times or until a certain condition is met. It is impractical and tedious to simply type a certain
statement or group of statements a large number of times, not to mention that this approach is too
inflexible and unintuitive to be counted on to stop when a certain event has happened. As a real
times or until a certain condition is met. It is impractical and tedious to simply type a certain
statement or group of statements a large number of times, not to mention that this approach is too
inflexible and unintuitive to be counted on to stop when a certain event has happened. As a real
world analogy, someone asks a dishwasher at a restaurant what he did all night. He will respond, "I
washed dishes all night long." He is not likely to respond, "I washed a dish, then washed a dish, then
washed a dish, then...". The constructs that enable computers to perform certain repetitive tasks are
called loops.
washed dishes all night long." He is not likely to respond, "I washed a dish, then washed a dish, then
washed a dish, then...". The constructs that enable computers to perform certain repetitive tasks are
called loops.
While loops
A while loop is the most basic type of loop. It will run as long as the condition is nonzero (true). For example, if you try the following, the program will appear to lock up and you will have to manually close the program down. A situation where the conditions for exiting the loop will never become true is called an infinite loop.
int a=1;
while(42) {
a = a*2;
a = a*2;
}
Here is another example of a while loop. It prints out all the exponents of two less than 100.
int a=1;
while(a<100) {
printf("a is %d \n",a); a = a*2;
}
The flow of all loops can also be controlled by break and continue statements. A break statement will immediately exit the enclosing loop. A continue statement will skip the remainder of the block and start at the controlling conditional statement again. For example:
int a=1;
while (42) { // loops until the break statement in the loop is executed
printf("a is %d ",a);
printf("a is %d ",a);
a = a*2;
if(a>100)
break;
break;
else if(a==64)
continue; // Immediately restarts at while, skips next step
printf("a is not 64\n");
}
In this example, the computer prints the value of a as usual, and prints a notice that a is not 64 (unless it was skipped by the continue statement).
Similar to If above, braces for the block of code associated with a While loop can be omitted if the code consists of only one statement, for example:
int a=1;
while(a < 100)
a = a*2;
a = a*2;
This will merely increase a until a is not less than 100.
It is very important to note, once the controlling condition of a While loop becomes 0 (false), the
loop will not terminate until the block of code is finished and it is time to reevaluate the conditional.
If you need to terminate a While loop immediately upon reaching a certain condition, consider
using break.
If you need to terminate a While loop immediately upon reaching a certain condition, consider
using break.
A common idiom is to write:
int i = 5;
while(i)
printf("java and c# can't do this\n");
This executes the code in the while loop 5 times, with i having values that range from 4 down to 0.
Conveniently, these are the values needed to access every item of an array containing 5 elements.
Conveniently, these are the values needed to access every item of an array containing 5 elements.
For loops
For loops generally look something like this:
for(initialization; test; increment)
{
{
/* code */
}
The initialization statement is executed exactly once before the first evaluation of the test
condition. Typically, it is used to assign an initial value to some variable, although this is not strictly
necessary. The initialization statement can also be used to declare and initialize variables used in the
loop.
necessary. The initialization statement can also be used to declare and initialize variables used in the
loop.
The test expression is evaluated each time before the code in the for loop executes. If this expression evaluates as 0 (false) when it is checked (i.e. if the expression is not true), the loop is not (re)entered
and execution continues normally at the code immediately following the FORloop. If the
expression is nonzero (true), the code within the braces of the loop is executed.
expression is nonzero (true), the code within the braces of the loop is executed.
After each iteration of the loop, the increment statement is executed. This often is used to increment the loop index for the loop, the variable initialized in the initialization expression and tested in the test expression. Following this statement execution, control returns to the top of the loop, where the test action occurs. If a continue statement is executed within the for loop, the increment statement would be the next one executed.
Each of these parts of the for statement is optional and may be omitted. Because of the freeform nature of the for statement, some fairly fancy things can be done with it. Often a for loop is used to loop through items in an array, processing each item at a time.
int myArray[12];
int ix;
for (ix = 0; ix<12; ix++)
myArray[ix] = 5 * ix + 3;
The above for loop initializes each of the 12 elements of myArray. The loop index can start from any value. In the following case it starts from 1.
for(ix = 1; ix <= 10; ix++)
{
{
printf("%d ", ix);
}
which will print
1 2 3 4 5 6 7 8 9 10
You will most often use loop indexes that start from 0, since arrays are indexed at zero, but you will sometimes use other values to initalize a loop index as well.
The increment action can do other things, such as decrement. So this kind of loop is common:
for (i = 5; i > 0; i)
{
printf("%d ",i);
}
which yields
5 4 3 2 1
Here's an example where the test condition is simply a variable. If the variable has a value of 0 or NULL, the loop exits, otherwise the statements in the body of the loop are executed.
for (t = list_head; t; t = NextItem(t) ) {
/*body of loop */
}
A WHILE loop can be used to do the same thing as a FOR loop, however a FOR loop is a more
condensed way to perform a set number of repetitions since all of the necessary information is in a one line statement.
A FOR loop can also be given no conditions, for example:
for(;;) {
/* block of statements */
}
This is called a forever loop since it will loop forever unless there is a break statement within the
statements of the for loop. The empty test condition effectively evaluates as true.
It is also common to use the comma operator in for loops to execute multiple statements.
int i, j, n = 10;
for(i = 0, j = 0; i <= n; i++,j+=2)
printf("i = %d , j = %d \n",i,j);
DoWhile loops
A DOWHILE loop is a postcheck while loop, which means that it checks the condition after each
run. As a result, even if the condition is zero (false), it will run at least once. It follows the form of:
run. As a result, even if the condition is zero (false), it will run at least once. It follows the form of:
do
{
/* do stuff */
} while (condition);
Note the terminating semicolon. This is required for correct syntax. Since this is also a type of while loop, break and continue statements within the loop function accordingly. A continue statement causes a jump to the test of the condition and a break statement exits the loop.
It is worth noting that DoWhile and While are functionally almost identical, with one important
difference: DoWhile loops are always guaranteed to execute at least once, but While loops will not execute at all if their condition is 0 (false) on the first evaluation.
One last thing: goto
goto is a very simple and traditional control mechanism. It is a statement used to immediately and
unconditionally jump to another line of code. To use goto, you must place a label at a point in your program. A label consists of a name followed by a colon (:) on a line by itself. Then, you can type
"goto label;" at the desired point in your program. The code will then continue executing beginning with label. This looks like:
"goto label;" at the desired point in your program. The code will then continue executing beginning with label. This looks like:
MyLabel:
/* some code */ goto MyLabel;
The ability to transfer the flow of control enabled by gotos is so powerful that, in addition to the simple if, all other control constructs can be written using gotos instead. Here, we can let "S" and "T" be any arbitrary statements:
if (cond) {
S;
}
else {
T;
T;
}
/* ... */
The same statement could be accomplished using two gotos and two labels:
if (cond) goto Label1:
T;
goto Label2; Label1:
S;
Label2:
/* ... */
Here, the first goto is conditional on the value of "cond". The second goto is unconditional. We can perform the same translation on a loop:
while (cond1) {
S;
if (cond2) break;
T;
T;
}
/* ... */
Which can be written as:
Start:
if (!cond1) goto End;
S;
S;
if (cond2) goto End;
T;
T;
goto Start;
End:
End:
/* ... */
As these cases demonstrate, often the structure of what your program is doing can usually be
expressed without using gotos. Undisciplined use of gotos can create unreadable, unmaintainable
code when more idiomatic alternatives (such as ifelses, or for loops) can better express your
structure. Theoretically, the goto construct does not ever have to be used, but there are cases when it
can increase readability, avoid code duplication, or make control variables unnecessary. You should
code when more idiomatic alternatives (such as ifelses, or for loops) can better express your
structure. Theoretically, the goto construct does not ever have to be used, but there are cases when it
can increase readability, avoid code duplication, or make control variables unnecessary. You should
consider first mastering the idiomatic solutions first, and use goto only when necessary. Keep in
mind that many, if not most, C style guidlines strictly forbid use of goto, with the the only common exceptions being the following examples.
One use of goto is to break out of a deeply nested loop. Since break will not work (it can only
escape one loop), goto can be used to jump completely outside the loop. Breaking outside of deeply
nested loops without the use of the goto is always possible, but often involves the creation and
testing of extra variables that may make the resulting code far less readable than it would be with goto. The use of goto makes it easy to undo actions in an orderly fashion, typically to avoid failing to free memory that had been allocated.
testing of extra variables that may make the resulting code far less readable than it would be with goto. The use of goto makes it easy to undo actions in an orderly fashion, typically to avoid failing to free memory that had been allocated.
Another accepted use is the creation of a state machine. This is a fairly advanced topic though, and not commonly needed.
0 comments:
Post a Comment