1. Chapter 8: Statement-Level Control Structures
Introduction
Selection Statements
Iterative Statements
Unconditional Branching
Invariants (Ch 3.5.2)

2. Control Statements: Evolution
Statements that select or repeat control flow
Statements in FORTRAN I were based directly on IBM 704 hardware
Much research and argument in the 1960s about the issue
One important result: It was proven that all algorithms represented by flowcharts can be coded with only two-way selection and pretest logical loops, without needing “goto”

3. Control Structure
A control structure is a control statement and the statements whose execution it controls
Design question
Should a control structure have multiple entries? Or allowing “goto”?
Structured programming:
The structure of the program text should help us understand what the program does.
The flow of control through the program is evident from the syntactic structure of the program text, i.e., single-entry/single-exit.

4. Selection Statements
A selection statement provides the means of choosing between two or more paths of execution
Two-way selectors
General form:
if control_expression
then clause
else clause
ALGOL 60:
if (boolean_expr)
then statement (then clause)
else statement (else clause)
The statements could be single or compound

5. Nesting Selectors Java example Which if gets the else?
if (sum == 0)
if (count == 0)
result = 0;
else result = 1;
Which if gets the else?
static semantics rule in Java, C, C++, and C# : else matches with the nearest if
To force an alternative semantics, compound statements may be used:
if (sum == 0) { }
Perl requires that all then and else clauses to be compound

6. Multiple-Way Selection Statements
Allow the selection of one of any number of statements or statement groups
C’s switch statement
switch (expression) {
case const_expr_1: stmt_1; …
case const_expr_n: stmt_n;
[default: stmt_n+1] }
Example
Switch (index) {
case 1:
case 3: odd += 1; sumodd += index; break;
case 2:
case 4: even += 1; sumeven += index; break;

7. Multiple-Way Selection: C
Design choices for C’s switch statement
Control expression can be only an integer type
Selectable segments can be statement sequences, blocks, or compound statements
Any number of segments can be executed in one execution of the construct (there is no implicit branch at the end of selectable segments)
default clause is for unrepresented values (if there is no default, the whole statement does nothing)

8. Multiple-Way Selection: Ada
The Ada case statement
case expression is
when choice list => stmt_sequence; …
[when others => stmt_sequence;]
end case;
More reliable than C’s switch (once a stmt_sequence execution is completed, control is passed to the first statement after the case statement

9. Multiple-Way Selection Using if
Multiple Selectors can appear as direct extensions to two-way selectors, using else-if clauses, for example in Ada:
if ...
then ...
elsif ...
else ...
end if

10. Iterative Statements
The repeated execution of a statement or compound statement is accomplished either by iteration or recursion
General design issues for iteration control statements:
1. How is iteration controlled?
2. Where is the control mechanism in the loop?

11. Counter-Controlled Loops
A counting iterative statement has a loop variable, and a means of specifying the loop parameters (initial, terminal, and stepsize values)
Design Issues:
What are the type and scope of the loop variable?
What is the value of the loop variable at loop termination?
Should it be legal for the loop variable or loop parameters to be changed in the loop body, and if so, does the change affect loop control?
Should the loop parameters be evaluated only once, or once for every iteration?

12. Counter-Controlled Loops: FORTRAN
FORTRAN 90 syntax
DO label var = start, finish [, stepsize]
Example:
Do 10 Index = 1, 10
...
10 Continue
Stepsize can be any value but zero
Parameters can be expressions
Design choices:
1. Loop variable must be INTEGER
2. Loop variable always has its last value
3. The loop variable cannot be changed in the loop, but the parameters can; because they are evaluated only once, it does not affect loop control
4. Loop parameters are evaluated only once

13. Counter-Controlled Loops: Pascal
Pascal’s for statement
for variable := initial (to|downto) final do statement
Example
for i := 1 to 5 do A[i] := 0
Design choices:
Loop variable must be an ordinal type of usual scope
After normal termination, loop variable is undefined
The loop variable cannot be changed in the loop; the loop parameters can be changed, but they are evaluated just once, so it does not affect loop control
Loop parameters are evaluated Just once

14. Counter-Controlled Loops: C
C’s for statement
for ([expr_1] ; [expr_2] ; [expr_3]) statement
Example:
For (count = 1; count <= 10; count++) {…}
The expressions are usually statements, or even statement sequences, with the statements separated by commas
The value of a multiple-statement expression is the value of the last statement in the expression
There is no explicit loop variable
Everything can be changed in the loop
The first expression is evaluated once before the loop entry , but the other two are evaluated with each iteration
expr_2: condition for staying within the loop
expr_3: evaluated before every next iteration
missing expr_2 is true.

15. Counter-Controlled Loops: C++
C++ differs from C in two ways:
The control expression can also be Boolean
The initial expression can include variable definitions (scope is from the definition to the end of the loop body)
Example:
For (int count = 1; count <= 10; count++) {…}
Java and C#
Differs from C++ in that the control expression must be Boolean

16. Logically-Controlled Loops
Repetition control is based on a Boolean
Design issues:
Pre-test or post-test?
General forms:
while (ctrl_expr) do
loop body loop body
while (ctrl_expr)
C and C++ also have both, but the control expression for the post-test version is treated just like in the pre-test case (while-do and do- while)

17. Logically-Controlled Loops: Pascal
Pascal has separate pre-test and post-test logical loop statements (while-do and repeat-until)
Example of remove adjacent duplicates:
1, 1, 2, 2, 2, 3, 1, 4, 4 -> 1, 2, 3, 1, 4
program uniq (input, output);
var x, next: integer;
begin
read(x);
while x <> 0 do begin
writeln(x);
repeat read(next); until next <> x;
x := next;
end;
end.

18. User-Located Loop Control Mechanisms
Sometimes it is convenient for the programmers to decide a location for loop control (other than top or bottom of the loop)
The break statement
C , C++: sends control out of the enclosing loop to the statement following the loop; for any loop or switch; one level only for nested loops
Java and C#: a labeled break statement; send control out of the labeled loop
The continue statement
C, C++, Phthon: it skips the remainder of this iteration, but does not exit the loop

19. Examples of break and continue
Java
outerLoop:
for (row = 0; row < numRows; row++)
for (col = 0; col < numCols; col++) {
sum += mat[row][col];
if (sum > )
break outerLoop; } C
while (sum < 1000) {
getnext(value);
if (value < 0) continue;
sum += value;

20. Examples of break and continue (cont)
The following program fragment skips over consecutive blank, tab, and newline characters, and keeps track of line numbers when encountering a newline character.
for ( ; ; c= getchar( ) ) {
if ( c == ‘ ‘ | | c == `\t`)
continue;
if ( c ! = ‘\n’ )
break;
++lineno; }

21. Iteration Based on Data Structures
Number of elements of in a data structure control loop iteration
Control mechanism is a call to an iterator function that returns the next element in some chosen order, if there is one; else loop is terminate
C#’s foreach statement iterates on the elements of arrays and other collections:
Strings[] strList = {“Bob”, “Carol”, “Ted”};
foreach (Strings name in strList)
Console.WriteLine (“Name: {0}”, name);
The notation {0} indicates the position in the string to be displayed

22. Unconditional Branching
Transfers execution control to a specified place in the program
Well-known mechanism: goto statement
Represented one of the most heated debates in 1960’s and 1970’s
Major concern: Readability
Some languages do not support goto statement (e.g., Module-2 and Java)
C# offers goto statement (can be used in switch statements)

23. Syntax of statements in C

24. Invariants
An assertion is a true/false condition about the state of a computation, e.g., x > y.
An invariant at some point in a program is an assertion that holds whenever the point is reached at run time.
Correctness is a property of dynamic computation. Invariants are a bridge between the static program text and the dynamic progress of a computation.
It is best to start with invariants and use them to design the program.
Invariants will be enclosed with braces { and }.

25. Examples of invariants
while x >= y do
{ x >= y if we get here }
x := x -y
{ x >= 0 and y > 0 }
while x > = y do
{ y > 0 and x > = y }
x: = x - y
{ x > = 0 and y > 0 }

26. Precondition and Postcondition
precondition: an assertion before a statement.
states the relationships and constraints among variables that are true at that point in execution
postcondition: an assertion after a statement
They play the following roles with while loops:
precondition: captures the conditions for executing the loop.
loop invariant: captures the condition for staying within the loop.
postcondition: captures the condition upon leaving the loop.

27. Invariants: Program Design (in Pascal)
Example: programs to remove adjacent duplicates
e.g., =>
(run)
read ( x );
while x is not the end marker do begin
{here, x is the first element of a run}
writeln ( x );
repeat read ( next ) until next ≠ x;
{here, we have read one element too many}
x := next;
end

28. Program Proof Process
A weakest precondition is the least restrictive precondition that will guarantee the postcondition
An example
a = b + 1 {a > 1}
One possible precondition: {b > 10}
Weakest precondition: {b > 0}
The postcondition for the entire program is the desired result
Work back through the program to the first statement. If the precondition on the first statement is the same as the program specification, the program is correct.