ICS 141 Klefstad

Statement-Level Control Structures

Outline Introduction Compound Statements Selection Statements Iterative Statements Unconditional Branching Guarded Commands Exception Handling

Introduction

control structures dictate the control flow through a program
unit level e.g., subroutine calls
statement level
- sequencing
- selection
- repetition
early languages used goto/gosub
writability and readability are primary concerns

Compound Statements

allows grouping several statements into a single statement
statements are typically executed in sequence from first to last
some languages allow local declarations in these (called blocks)
e.g., Pascal begin/end, C++ { }

Selection Statements

a choice between statements
examples include 'if' or 'switch'

two-way selectors

AKA binary selection or conditional

e.g., if statement

if ( cond )
  <statement>
else
  <statement>

classic problem:

if ( cond )
  if ( cond2 )
    stmt
else
  stmt

Ada if-then

if cond1 then
  stmt_list1
elsif cond2 then
  stmt_list2
else
  stmt_listN
end if;

N-way branch (or multiple selection)

e.g., case or switch statement

char c = getchar();
switch ( c )
{
  case 'A':
  case 'B':
    cout << "a letter";
    break;
  case '0':
  case '1':
    cout << "a digit";
    break;
  default:
    cout << "something else";
    break;
}

case of Ada and Pascal is less error prone

Iterative Statements

looping statements
e.g., for, while, do-while, iterators

counter controlled loops

useful when the number of iterations is known
particularly for processing arrays
C++/Java for is also useful for processing lists and files
e.g., for, do

what about scope of loop control variable?
- Ada, C++, Java over for loop statement
should programmers be able to assign the loop control variable?
- Ada loop control variable is read-only

are loop parameters evaluated once or each iteration?

N: integer := 5;
for i in 1..N loop
  put(i);
  N := N + 1;
end loop;

logically controlled loops

aka 'condition driven loops'
useful for doing something until a condition is met
e.g., while, do-while, repeat-until

Iterators

some languages allow user defined iterators
e.g., going through a linked list or binary tree

CLU iterators

FOR atom:node IN list(x) DO
  put(atom);
list=ITER(z:linked_list) YIELDS (node)

...
YIELD(node);
...

END LIST;

C++ iterators:

Vector v;
for ( VectorIter e = v; e.isMore(); e.advance() )
  cout << e.current();

Java enumerations:

Vector v;
for ( Enumeration e = v.elements(); e.hasMoreElements(); )
  System.out.println(e.nextElement());

Unconditional Branching

goto statements can make programs difficult to follow
may be restricted
- UCSD Pascal only use goto when given permission
- Ada can't goto into a compound statement or across procedures
may be eliminated (Java, Modula, CLU, Euclid, Gypsy)
a rich set of control structures eliminates need for goto

Guarded Commands

Dijkstra (1975) proposed an alternative control structure
proposed a guarded 'if' and a guarded 'do'

Guarded if

general form

if <boolean expression1> -> <statement-list1>
[] <boolean expression2> -> <statement-list2>
[] ...
[] <boolean expressionN> -> <statement-listN>
fi

all boolean expressions are evaluated
one of true ones is selected non-deterministically (at randomly)
associated statement-list is executed

Guarded do

general form

do <boolean expression1> -> <statement-list1>
[] <boolean expression2> -> <statement-list2>
[] ...
[] <boolean expressionN> -> <statement-listN>
od

all boolean expressions are evaluated
one of true ones is selected non-deterministically (at randomly)
associated statement-list is executed
repeats until all expressions are false

Exception Handling

an 'exception' is an event that requires special processing
- e.g., errors or boundary conditions
an exception is 'raised' when its associated event occurs
an 'exception handler' is code that executes when an exception is raised
- examples: division by zero, null pointer reference, index out of bounds
examples from Ada, C++/Java
must decide: scope of exceptions, raising, defining handlers, propagation