The while Statement

The while statement supports iteration (i.e. it is
a repetition control statement). Iteration is the process
of repeating an operation.

The idea of looping in a computer program can be attributed
to Ada Lovelace (01815-01852). Many believe Lovelace wrote
the first "computer program." On 10 December 1980 (Ada's
birthday), the U.S. Defense Department approved the reference
manual for its new computer programming language, called "Ada".

The while statement repeatedly executes a
simple statement or block (i.e. compound statement) until
a conditional EXPR becomes false (i.e. 0).
Each loop iteration is called a cycle.

while (EXPR) // typically, you don't want a semicolon
statement;
EXPR is the "conditional" test used to determine whether the loop
should continue for another cycle, and statement is to be repeated.
If multiple statements need to be executed, then use a compound
statement (or block).
EXPR is evaluated only at the beginning of a loop cycle.
Pseudo-code for a while loop:
top-of-loop
evaluate the EXPR
if EXPR is "true" // i.e. a non-zero value
execute statement
go to top-of-loop
else
go to end-of-loop (i.e. terminate the loop)
end-of-loop
statement
...
//Example: loop until user enters a positive number
int n = -1;
while (n <= 0)
cin >> n;
//Example: print out the numbers 1 through 5
int i = 1;
while (i <= 5) {
cout << i << endl;
i = i + 1;
}

Sentinel Values

One way to terminate (end) a loop is when a particular data value
is entered (e.g. the user enters a -1 or end-of-file is encountered),
a special value that is used to end the loop is called a
sentinel value.

Sentinel values should be defined as manifest (symbolic) constants.
Example:

Infinite Loops

When you use a loop in a program, it is important to make sure that
the condition used to control the loop will eventually become
false, so that the loop can end. A loop
that never finishes is called an infinite loop.

To stop an infinite loop, a special command sequence must be typed
on the keyboard to interrupt the program and forcibly cause it to quit.
This command differs from machine to machine.

Sometimes infinite loops are used by design; therefore, existenance
of an infinite loop does not necessarily imply a program defect.

The do while Statement

The do while statement supports iteration (i.e.
it is a repetition control statement). Iteration
is the process of repeating an operation.

The do while statement repeatedly executes a
simple statement or block (i.e. compound statement) until
a conditional EXPR becomes false (i.e. 0).
Each loop iteration is called a cycle.

do
statement;
while (EXPR); //semicolon must follow the while statement
EXPR is the "conditional" test used to determine whether the loop
should continue for another cycle, and statement is to be repeated.
If multiple statements need to be executed, then use a compound
statement (or block). A compound statement is almost always used.
EXPR is evaluated only at the end of a loop cycle.
Pseudo-code for a do-while loop:
top-of-loop
execute statement
evaluate the EXPR
if EXPR is "true" // i.e. a non-zero value
go to top-of-loop
else
go to end-of-loop (i.e. terminate the loop)
end-of-loop
statement
...
//Example: print out the numbers 1 through 3
int i = 1;
do {
cout << i << endl;
i = i + 1;
} while (i <= 3);
Could the previous loop be rewritten:
int i = 1;
do cout << i++ << endl; while (i <= 3);
How about:
int i = 1;
do cout << i << endl; while(i++ <= 3);

When you know for sure that a loop must cycle at least
once, then a do-while is a good loop construct to use.

set item counter to 0
do {
prompt user for data
get data from user
if (data equals sentinel value)
break;
if (data is junk)
continue; //get more data from the user
process the data
increment the item counter
} while (1);
print the item counter

Comment on Style

The do-while can be difficult to read;
therefore, to help it "stick" out, I suggest
the following.

The for Statement

The for statement supports iteration (i.e.
it is a repetition control statement). Iteration
is the process of repeating an operation.

The for statement repeatedly executes a
simple statement or block (i.e. compound statement)
until a control-EXPR becomes false
(i.e. 0). Each loop iteration is called a cycle.

for ([initialization-step]; [conditional-step]; [increment-step])
statement;
The optional "initialization-step" is executed once before the loop
is ever executed (and before the "conditional-step" is evaluated
for the first time).
The optional "conditional-step" is an EXPR that is evaluated at
the top of the loop. If it is true, then the body of the
for statement is executed; otherwise, flow control jumps to
the first executable statement after the for loop body. If
no conditional-step is specified, then it is taken as
permanently true.
After the body of a for loop has been executed, the optional
"increment-step" is executed.
After the increment-step is executed; the conditional-step
is re-evaluated.
Example:
//print the numbers 1 through 3
int i;
for (i = 1; i <= 3; i = i + 1)
cout << i << endl;

If the body of the for contains multiple statements,
then a compound statement is needed.

All three steps for a for loop are EXPRs.
Most commonly, the initialization-step and the increment-step
are assignments or functions calls, and the conditional-step
is a relational EXPR.

The for is frequently used when there are simple
initialization and increment steps because it keeps the loop
control statements close together and visible at the top of
the loop.

The initialization and increment steps often take advantage
of the sequence operator.

while (...) {
...
if (...) {
...
if (...)
break; // the programmer wants to break out of the
// body of the enclosing if statement,
// but instead the break will cause the
// flow control of the program to jump to
// the 1st executable statement after the
// body of the while statement (/*B*/)
...
}
/*A*/ ...
}
/*B*/ ...

The continue Statement

The continue statement is a jump control
statement that is used inside of repetition control
statements.

The continue statement causes the next
iteration of the enclosing loop statement to begin.
In the while and do this
means that the control-EXPR is executed immediately;
in the for control passes to the step-EXPR.

The continue statement is often used when
the part of the loop that follows is complicated, so
that reversing a test and indenting another level would
nest the program too deeply.

Structured programming purist are not overly fond of
the continue statement.

while (input != SENTINEL) {
/* Part A */
...
if (EXPR)
continue;
/* Part B */
...
}
When if (EXPR) evaluates to true, the continue statement
is executed and the flow control of the program jumps to
control expression of the while (i.e. input != SENTINEL)
is re-evaluated.

An aside: In Java, goto is not a keyword,
but it is a reserved word. In addition, to handle the
aforementioned example, Java supports labeled break
statements.

The goto statement is frequently found in
code that is generated by other programs.

If you want to go somewhere, goto is the best way to get there.
-- Ken Thompson (creator of Unix)

Edsger Dijkstra (01930-02002) was a Dutch
computer scientist. Dijkstra won the ACM Turing Award in
01972. According to the Wikipedia, Dijkstra was also known
for his "low opinion of the GOTO statement in computer programming,
culminating in the 1968 article 'A Case against the GO TO Statement',
regarded as a major step towards the widespread deprecation of the
GOTO statement and its effective replacement by structured control
constructs such as the while loop. This methodology was also called
structured programming."
{Wikipedia.org::Edsger
W. Dijkstra}