Faculdade de Informática, PUCRS, Porto Alegre, RS
Coordenação: Isabel Harb Manssour
Instrutores: Eduardo Bezerra e Cristiane Woszezenki
Estruturas de controle
A program is usually not limited to a linear sequence of instructions. During its process it may bifurcate, repeat code or take decisions. For that purpose, C++ provides control structures that serve to specify what has to be done to perform our program.
With the introduction of control sequences we are going to have to introduce a new concept: the block of instructions. A block of instructions is a group of instructions separated by semicolons (;) but grouped in a block delimited by curly bracket signs: { and }.
Most of the control structures that we will see in this section allow a generic statement as a parameter, this refers to either a single instruction or a block of instructions, as we want. If we want the statement to be a single instruction we do not need to enclose it between curly-brackets ({}). If we want the statement to be more than a single instruction we must enclose them between curly brackets ({}) forming a block of instructions.
It is used to execute an instruction or block of instructions only if a condition is fulfilled. Its form is:
if (condition) statement
where condition is the expression that is being evaluated. If this condition is true, statement is executed. If it is false, statement is ignored (not executed) and the program continues on the next instruction after the conditional structure.
For example, the following code fragment prints out x is 100 only if the value stored in variable x is indeed 100:
if (x == 100)
cout << "x is 100";
If we want more than a single instruction to be executed in case that condition is true we can specify a block of instructions using curly brackets { }:
if (x == 100)
{
cout << "x is ";
cout << x;
}
We can additionally specify what we want that happens if the condition is not fulfilled by using the keyword else. Its form used in conjunction with if is:
if (condition) statement1 else statement2
For example:
if (x == 100)
cout << "x is 100";
else
cout << "x is not 100";
prints out on the screen x is 100 if indeed x is worth 100, but if it is not -and only if not- it prints out x is not 100.
The if + else structures can be concatenated with the intention of verifying a range of values. The following example shows its use telling if the present value stored in x is positive, negative or none of the previous, that is to say, equal to zero.
if (x > 0)
cout << "x is positive";
else if (x < 0)
cout << "x is negative";
else
cout << "x is 0";
Remember that in case we want more than a single instruction to be executed, we must group them in a block of instructions by using curly brackets { }.
Loops have as objective to repeat a statement a
certain number of times or while a condition is fulfilled.
while (expression) statement
// custom countdown using while #include <iostream.h> int main () { int n; cout << "Enter the starting number > "; cin >> n; while (n>0) { cout << n << ", "; --n; } cout << "FIRE!"; return 0; } |
Enter the starting number > 8 |
do statement while (condition);
// number echoer #include <iostream.h> int main () { unsigned long n; do { cout << "Enter number (0 to end): "; cin >> n; cout << "You entered: " << n << "\n"; } while (n != 0); return 0; } |
Enter number (0 to end): 12345 |
for (initialization; condition; increase) statement;
1, initialization is executed. Generally it is an initial value setting for a counter varible. This is executed only once.
2, condition is checked, if it is true the loop continues, otherwise the loop finishes and statement is skipped.
3, statement is executed. As usual, it can be either a single instruction or a block of instructions enclosed within curly brackets { }.
4, finally, whatever is specified in the increase field is executed and the loop gets back to step 2.
// countdown using a for loop #include <iostream.h> int main () { for (int n=10; n>0; n--) { cout << n << ", "; } cout << "FIRE!"; return 0; } |
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIRE! |
for ( n=0, i=100 ; n!=i ; n++, i-- ) { // whatever here... }
// break loop example #include <iostream.h> int main () { int n; for (n=10; n>0; n--) { cout << n << ", "; if (n==3) { cout << "countdown aborted!"; break; } } return 0; } |
10, 9, 8, 7, 6, 5, 4, 3, countdown aborted! |
// break loop example #include <iostream.h> int main () { for (int n=10; n>0; n--) { if (n==5) continue; cout << n << ", "; } cout << "FIRE!"; return 0; } |
10, 9, 8, 7, 6, 4, 3, 2, 1, FIRE! |
// goto loop example #include <iostream.h> int main () { int n=10; loop: cout << n << ", "; n--; if (n>0) goto loop; cout << "FIRE!"; return 0; } |
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIRE! |
void exit (int exit code);
The syntax of the switch instruction is a bit peculiar. Its objective is to check several possible constant values for an expression, something similar to what we did at the beginning of this section with the linking of several if and else if sentences. Its form is the following:
switch (expression) {
case constant1:
block of instructions 1
break;
case constant2:
block of instructions 2
break;
.
.
.
default:
default block of instructions
}
It works in the following way: switch evaluates expression
and checks if it is equivalent to constant1, if it
is, it executes block of instructions 1 until it
finds the break keyword, then the program will jump to the end
of the switch selective structure.
If expression
was not equal to constant1 it will check if
expression is equivalent to constant2.
If it is, it will execute block of instructions 2
until it finds the break keyword.
Finally, if the value of
expression has not matched any of the previously
specified constants (you may specify as many case sentences as
values you want to check), the program will execute the instructions
included in the default: section, if this one exists, since it
is optional.
Both of the following code fragments are equivalent:
switch example |
if-else equivalent |
switch (x) { case 1: cout << "x is 1"; break; case 2: cout << "x is 2"; break; default: cout << "value of x unknown"; } |
if (x == 1) { cout << "x is 1"; } else if (x == 2) { cout << "x is 2"; } else { cout << "value of x unknown"; } |
I have commented before that the syntax of the switch instruction is a bit peculiar. Notice the inclusion of the break instructions at the end of each block. This is necessary because if, for example, we did not include it after block of instructions 1 the program would not jump to the end of the switch selective block (}) and it would continue executing the rest of the blocks of instructions until the first appearance of the break instruction or the end of the switch selective block. This makes it unnecessary to include curly brackets { } in each of the cases, and it can also be useful to execute the same block of instructions for different possible values for the expression evaluated. For example:
switch (x) { case 1: case 2: case 3: cout << "x is 1, 2 or 3"; break; default: cout << "x is not 1, 2 nor 3"; } |
Notice that switch can only be used to compare an expression with different constants. Therefore we cannot put variables (case (n*2):) or ranges (case (1..3):) because they are not valid constants.
If you need to check ranges or values that are not constants use a concatenation of if and else if sentences.