Control Structures Ranga Rodrigo Control Structures in Brief

Control Structures Ranga Rodrigo

Control Structures in Brief C++ or Java Eiffel if-elseif-else-end case inspect for, while, do-while from-until-loop-end

Structured Programming Any structured program can be written using sequence statements, conditional statements, and repetition. Sequence Conditional Statements Loops

Control Structures They control the sequence of basic statements that is executed. They break a program up into relatively independent pieces, each of which behaves in a simple and predictable way: they introduce structure into programs. Eiffel tries to simplify the normal repertoire control structures in some aspects.

With No Control Structures Two mechanisms: Jump or goto instructions. Subroutine calls. FORTRAN example: 10 20 X = X + 1 A[X] =. . . IF (X. EQ. 10) GOTO 20 GOTO 10 CONTINUE

Structured: No gotos goto can create very complex programs: spaghetti-like. Edsgar Dijkstra: “goto statement … considered harmful. ” Structured: replace the use of jumps by a small set of simple and well-understood control structures. E. g. , the loop above is replaced by a for statement:

10 20 X = X + 1 A[X] =. . . IF (X. EQ. 10) GOTO 20 GOTO 10 CONTINUE for (x = 0; x < 10; x++) { a[x] =. . . }

One Entry- and Exit-Point Rule One commonly quoted rule of structured programming was that each control structure should have only one entry point and one exit point. The idea was that this would make it easy to understand what a program is going to do next.

One Entry- and Exit-Point Rule Eiffel enforces this rule consistently. C++/Java do not: break allows you to jump out of the middle of a loop. continue in effect jumps back to the beginning of the current loop. C and C++ have a goto statement.

Control Structures and Exceptions One problem with structured programming is that it can be awkward to deal with error trapping and exceptional situations. C++, Java, and Eiffel all have an exception mechanism which allow control to be transferred elsewhere in the program in certain circumstances.

Sequencing The default control structure is to perform statements one after another, in the order in which they are written: sequencing. Many languages use semi-colons to separate statements, but in Eiffel these are optional.

Conditional Statement: IF if test then. . . else. . . end The elseif and else clauses are optional. Control enters an if statement at the top, and leaves at the end.

Case or Switch: INSPECT if option = 'c' then counter. clear elseif option = 'i' then counter. increment elseif option = 'p' then counter. print else io. print_string("Invalid option") end

Case or Switch: INSPECT inspect exp when a, b, c then. . . when x. . z then. . . else. . . end exp must be of type INTEGER or CHARACTER. After when the programmer can specify lists or subranges of values. The else part of the instruction is optional.

Iteration: from-until-loop-end from initialization until exit condition loop. . . end

Iteration This loop will continue until the exit condition becomes true. This is the opposite behaviour from C++ or Java while loops, which terminate when the condition becomes false. There is no loop statement in Eiffel with the test of the exit condition at the end (No do-while loop. ) There is no for statement.

Iteration This loop will continue until the exit condition becomes true. This is the opposite behaviour from C++ or Java while loops, which terminate when the condition becomes false. There is no loop statement in Eiffel with the test of the exit condition at the end (No do-while loop. ) There is no for statement.

for in Eiffel from i : = 0 until i = 10 loop -- do stuff i : = i + 1 end

Iteration The only way an Eiffel loop can finish is by the exit condition becoming true. Unlike C, C++ and Java there are no break or continue statements. This follows the structured programming principle of making the flow of control easy to follow. Arguably, it makes the conditions of some loops harder to write and read.

E. g. , Locating a Value in an Array

find(v : INTEGER; a : ARRAY[INTEGER]) : INTEGER is local i : INTEGER do from i : = a. lower found : = false until found or i > a. upper loop if a. item(i) = v then found : = true else i : = i + 1 end Result : = i end

The debug Statement debug io. put_string("x = ") io. put_integer(x) end debug("all") io. put_string("y = ") io. put_real(y) end

Procedures p (arg 1 : Type ; . . . ; argn : Type) is require -- precondition here local -- local entities declared here do -- compound statement here ensure -- postcondition here end

Procedures The only way of exiting from a routine body is by reaching its end. Eiffel has no return statement. Formal parameters (the args) cannot be assigned to in the body of a routine. Parameters are initialized by assignment. Procedure calls are written using p(x, y) notation. If there are no parameters, however, the brackets are omitted.

Functions f (a 1 : T 1 ; . . . ; an : Tn) : T is require -- precondition local -- local entities declared here do -- statement, assignment to 'Result' Result : = return value -- more statements ensure -- postcondition end

Fucntions In addition to the points made about routines: Result is an implicitly declared local variable of the return type of the function. The value held in Result when the function ends is the value returned by the function When a function is called, you must do something with the returned value.

Control Structures and DBC Pre- and post-conditions state properties that should be true at the beginning and end of a routine. They are not called by client code. They are not usually specified as formally as routines. However, it can be useful to annotate code with expected properties. As with DBC, this can be a good way of catching errors in program development.

Assertions The check statement can be used to add runtime checks at any point in a program. For example, after completion of the loop in the find function, the value of i should beat most one more than the upper bound of the array: check a. lower <= i and then i <= a. upper + 1 end

Specifying Loops: Variants and Invariants Loop design can be difficult: the exit condition must be correct, and the loop must execute the correct number of times. Eiffel supports the use of loop variants and loop invariants (not to be confused with class invariants) to specify the behaviour of loops. The invariant is an expression that must be true every time the loop restarts. The variant is an integer expression that must get less every time the loop repeats. This ensures that it will terminate.

make is local v : INTEGER a : ARRAY[INTEGER] i : INTEGER found : BOOLEAN do create a. make(1, 10) from i : = 1 found : = false invariant -- v not in the array slice [1. . i) variant 10 - i CONTD.

until found or i > 10 loop if a[i] = v then found : = true else i : = i + 1 end io. put_integer(i) end CONTD.