control flow expressions sequencing selection section 6 1 6 4
Skip this Video
Download Presentation
Control Flow: Expressions, Sequencing & Selection (Section 6.1- 6.4)

Loading in 2 Seconds...

play fullscreen
1 / 26

Control Flow: Expressions, Sequencing & Selection (Section 6.1- 6.4) - PowerPoint PPT Presentation

  • Uploaded on

Control Flow: Expressions, Sequencing & Selection (Section 6.1- 6.4). CSCI 431 Programming Languages Fall 2003. A compilation of material developed by Felix Hernandez-Campos and Michael Scott. Control Flow. Control flow refers to the order in which a program executes

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Control Flow: Expressions, Sequencing & Selection (Section 6.1- 6.4)' - devi

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
control flow expressions sequencing selection section 6 1 6 4

Control Flow: Expressions, Sequencing & Selection(Section 6.1- 6.4)

CSCI 431 Programming Languages

Fall 2003

A compilation of material developed by Felix Hernandez-Campos and Michael Scott

control flow
Control Flow
  • Control flow refers to the order in which a program executes
  • This is fundamental in the imperative programming paradigm
    • E.g. Java, C++, Pascal, Fortran, Ada, etc.
  • In other programming paradigms, the compilers or the interpreters take care of the ordering
    • E.g. logic programming
control flow mechanisms
Control Flow Mechanisms
  • Sequencing
    • Textual order, precedence and associativity in expression
  • Selection
  • Iteration
  • Procedural abstraction
  • Recursion
  • Concurrency
  • Nondeterminacy
expression evaluation
Expression Evaluation
  • Expressions consist of operands (e.g. a variable) and operators or functions (e.g. +, abs())
    • By definition, operators and functions return a value
  • Operators are also functions
    • Infix notation is just syntactic sugar
    • In C++, a + b means a.operator+ (b)
  • Operators are used in
    • Prefix notation
      • E.g. Expression (* (+ 1 3) 2) in Lisp
    • Infix notation
      • E.g. Expression (1 + 3) * 2 in Java
    • Postfix notation
      • E.g. Increment a++ in C
  • Operators can have 1 or more operands
    • Increment in C is a one-operand operator: a++
    • Subtraction in C is a two-operand operator: a-b
    • Conditional expression in C is a three-operand operators:

(a == 3 ? 0 : 1)

operators precedence and associativity
OperatorsPrecedence and Associativity
  • Precedence and associativity deal with the evaluation order within expressions
  • Precedence rules specify the order in which operators of different precedence level are evaluated
    • * usually groups more tightly than +
  • What is the results of 4 * 5 ** 6 ?
operators associativity
  • Associativity rules specify the order in which operators of the same precedence level are evaluated
    • + is usually evaluated from left-to-right
  • What is the results of 4 ** 5 ** 6 ?
  • In Fortran, ** associates from right-to-left, as in Math
  • In Ada, ** does not associate, so you have to write the previous expression as 4 ** (5 ** 6) to obtain the expected answer
  • The basic operation in imperative language is assignment
    • The side effect of this operation is a change in memory
    • Assignments affect the whole state of the program
  • Purely functional language do not have assignment
    • Side effects are not possible
    • Expression in purely functional languages depend only in their referencing environment
  • Expressions produce values
  • Statements do not return values, but they have side effects
  • Value model of variables
    • E.g. Pascal’s A := 3
    • A is an l-value, and it denotes a position in memory
    • 3 is a r-value, and it denotes a value with no explicit location
  • Reference model of variables
    • E.g. Java’s A = new Integer(3)
    • Variables are references to values
  • Value and Reference model of variables
  • Variables in Java
expressions other issues
ExpressionsOther Issues
  • Initialization may be implicit or explicit (at declaration or execution)
    • E.g. All variables have a default value in Perl, while Java requires all variables to be initialized
      • As a consequence, a simple typo in the name of variable in a Perl program may become a nasty bug
  • Orthogonality means that features can be used in any combination and their meaning is consistent regardless of the surrounding features
    • E.g. Assignment within conditional expressions in C++
    • This is powerful but problematic, since typos may be legal
      • E.g.if (a==b) { … } and if (a = b) { … }
expressions other issues14
ExpressionsOther Issues
  • Execution ordering within expressions is complicated by side effects (and code improvements)
    • E.g. In Java,

b = 1

int increment(int a) {

b += 1;

return a + 1;


c = (3 * b) * increment(b)

    • If the function call is evaluated before (3 * b)the final value of c is 12. If the product is evaluated before the function call, the value of c is 6.
    • But side effects within functions are a bad idea!
expressions other issues15
ExpressionsOther Issues
  • Expressions may be executed using short-circuit evaluation
    • E.g. In C,

p = my_list;

while (p && p->key != val)

p = p->next;

      • Field key is not accessed if the pointer p is null
    • This is not available in Pascal, so an additional variable is required (e.g.keep_searching)

p := my_list;

while (p<>nil) and (p^.key <> val) do (*ouch*)

p := p^.next

      • Access to key causes a run-time error at end of the search
short circuited conditions
Short-Circuited Conditions

if ((A>B) and (C>D)) or (E<>F) then




expressions examples
  • Expressions in Java
  • Regular Expressions in Perl
    • Regular expressions in Perl
unstructured flow the goto statement
Unstructured FlowThe GOTO Statement
  • Control flow in assembly languages is achieved by means of conditional jumps and unconditional jumps (or branches)
    • E.g.

JMP 30

30: ADD r1, #3

      • 30 is an assembly-level label
    • Higher level languages had similar statement: goto
      • E.g. In FORTRAN,

If A .lt. B goto 10

10: …

      • 10 is a statement label
unstructured flow the goto statement19
Unstructured FlowThe GOTO Statement
  • Goto is considered evil since the 70s
    • It potentially makes programs extremely convoluted
      • Spaghetti code
      • Code may be difficult to debug and even more difficult to read
    • In 1967, Dijkstra’s published an classic article, GoTo Considered Harmful, that pointed out the dangers of the goto statement in large programs
      • The larger the program, the worse the impact of goto statements
structured flow
Structured Flow
  • Structured flow eliminates goto
    • Nested constructs (blocks) provide the same expressive power
  • Any program can be expressed using sequencing, selection and iteration
    • This was proved in a 1964 paper by Bohm & Jacopini
  • However, there is a small number of cases in which unstructured flow is still more convenient
    • Modern structured languages like Java have addressed these cases in an structured manner
structured flow special cases
Structured FlowSpecial Cases
  • Break and continue
    • Java’s branching statements
  • Early subroutine returns
    • Java’s return statements
  • Exceptions and Errors
    • Java’s exception handling
  • Sequencing is central to imperative programming languages
  • Sequencing of statements is usually defined by textual orders
  • Enclosed sequences of statements are called compound statements or blocks
    • E.g. begin … end, { … }
    • Declarations (e.g. variable types) may also be part of a code block
  • If/Then/Else statement
  • Case/Switch statement
    • The motivation for this statement is not purely esthetical
    • In some cases, switch statements are faster than nested if/then/else
    • The argument of the conditional must be a discrete value so that selection can be accomplished using an array indexed by the values (rather than checking the cases sequentially)
  • The break statement in C/C++/Java makes code generation even more efficient in some case
selection efficient case switch example
SelectionEfficient Case/Switch Example

Inefficient Code


  • If interested in the history of programming, you can read these two classics
    • Edsger Dijkstra, Goto Considered Harmful, CACM 1968.
    • C. Bohm and G. Jacopini. Flow diagrams, Turing machines and languages with only two formation rules. Communications of the ACM, 9(5):366-- 371, May 1966.