Chapters 6, 7 and 8 - PowerPoint PPT Presentation

About This Presentation
Title:

Chapters 6, 7 and 8

Description:

Title: Data Types Author: Barbara Hecker Last modified by: bhecker Created Date: 1/6/1997 6:13:42 PM Document presentation format: On-screen Show Other titles – PowerPoint PPT presentation

Number of Views:50
Avg rating:3.0/5.0
Slides: 84
Provided by: BarbaraH173
Category:

less

Transcript and Presenter's Notes

Title: Chapters 6, 7 and 8


1
Chapters 6, 7 and 8
  • Data Types
  • Expressions and Assignment Structures
  • Statement-Level Control Structures

2
Chapter 6Data Types
  • Primitive Data Types
  • User_Defined Ordinal Types
  • Array Types
  • Record types
  • Union Types
  • Set Types
  • Pointer Types

3
Evolution of Data Types
  • FORTRAN I (1956)
  • - INTEGER, REAL, arrays
  • Ada (1983)
  • - User can create a unique type for every
    category of variables in the problem space and
    have the system enforce the types
  • Abstract Data Type
  • - the use of type is separated from the
    representation and operations on values of that
    type

4
Design Issues for all data types
  • What is the syntax of references to variables?
  • What operations are defined and how are they
    specified ?
  • Def A descriptor is the collection of the
    attributes of a variable
  • In an implementation, a descriptor is a
    collection of the memory sells that store the
    variables attributes.

5
Primitive Data Types
  • Data Types that are not defined in terms of
    others types are called Primitive Type
  • Some of this types are merely reflection of
    hardware
  • Integer
  • Almost always an exact reflection of the
    hardware, so the mapping is trivial
  • There may be as many as eight different integer
    types in a language
  • Integers are represented as a string of bits(
    positive or negative)

6
Floating Point
  • Model real numbers, but only as approximations
  • Languages for scientific use support at least two
    floating-point types sometimes more
  • Usually exactly like the hardware, but not
    always some languages allow accuracy specs in
    code.

7
Decimal
  • For business applications (money)
  • Store a fixed number of decimal digits (coded)
  • Advantage accuracy
  • Disadvantages limited range, wastes memory
  • Primary data types for business data processing (
    COBOL)
  • They are stored very much like character strings
    using binary code for decimal digits (BCD)

8
Boolean
  • First introduced in Algol 60
  • Most of all general purpose languages have them
  • Advantage readability
  • Character Type
  • Character data are stored in computer as numeric
    coding.
  • ASCII 128 different characters ( 0 .. 127)
  • A 16 bit character set named Unicode

9
Character String Types
  • Is one in which the Values consist of sequences
    of characters
  • Design issues
  • 1. Is it a primitive type or just a
    special kind of array?
  • 2. Is the length of objects static or
    dynamic?
  • Operations
  • - Assignment
  • - Comparison (, gt, etc.)
  • - Catenation
  • - Substring reference
  • - Pattern matching

10
Examples
  • Pascal, - Not primitive assignment and
    comparison only (of packed arrays)
  • FORTRAN 77, FORTRAN 90, SNOBOL4 and BASIC
  • - Somewhat primitive
  • Assignment, comparison, catenation, substring
    reference
  • FORTRAN, SNOBOL4 have an intrinsic for
    pattern matching
  • C, C, ADA not primitive, strcpy, ctrcat
    strlen, strcmp - commonly used string
    manipulation library functions (string.h) N
    N1 N2 (catenation) N(2..4) (substring
    reference) ( ADA)
  • JAVA strings are supported as a primitive type
    by the String class ( constant strings) and
    StringBuffer class ( changeable strings)

11
String Length Options
  • There are several design choices regarding the
    length of string values
  • 1. Static length string (length is specified at
    the declaration time) - FORTRAN 90, Ada, COBOL,
    Pascal
  • CHARACTER (LEN 15) NAME
    (FORTRAN 90)
  • Static length strings are always full
  • 2. Limited Dynamic Length strings can store any
    number of characters between 0 and maximum
    (specified by the variables declaration)
  • - C and C
  • - actual length is indicated by a null
    character
  • 3. Dynamic - SNOBOL4, Perl, JavaScript
  • provides maximum flexibility, but requires of
    overhead of dynamic storage allocation and
    de-allocation

12
Evaluation
  • - Aid to writability
  • - As a primitive type with static length, they
    are inexpensive to provide
  • - Dynamic length is nice, but is it worth the
    expense?
  • Implementation
  • - Static length - compile-time descriptor
  • - Limited dynamic length - may need a run-time
    descriptor for length (but not in C and C)
  • Dynamic length - need run-time descriptor
    allocation/
  • de-allocation is the biggest implementation
    problem

13
Implementation Static length
  • - Static length - compile-time descriptor name
    of type, length( in characters ) and address of
    first character
  • Limited dynamic length - may need a run-time
    descriptor for length (but not in C and C)

14
Limited dynamic strings
  • Limited dynamic strings require a run time
    descriptor to store both max length and current
    length
  • Dynamic length - need run-time descriptor( only
    current length) allocation/de-allocation is the
    biggest implementation problem.There are two
    possible approaches to this
  • - linked list, or
  • - adjacent storage

15
Ordinal Types ( user defined )
  • An ordinal type is one in which the range of
    possible values can be easily associated with the
    set of positive integers.
  • Enumeration Types
  • - one in which the user enumerates all of
    the possible values, which are symbolic constants
  • Design Issue
  • Should a symbolic constant be allowed to be
    in more than one type definition?

16
Examples
  • Pascal
  • cannot reuse constants they can be used for
    array subscripts, for variables, case selectors
    NO input or output can be compared
  • C and C -
  • like Pascal, except they can be input and
    output as integers
  • Java does not include an enumeration type but can
    be implemented as a nice class.

17
Evaluation
  • Enumeration types provide advantages in both
  • Aid to readability
  • --e.g. no need to code a color as a number
  • Aid to reliability
  • --e.g. compiler can check operations and
    ranges of values

18
Sub range Type
  • Sub range Type - an ordered contiguous
    subsequence of an ordinal type
  • Examples
  • Pascal - Sub range types behave as their parent
    types can be used as for variables and array
    indices
  • e.g. type pos 0 .. MAXINT
  • Ada - Subtypes are not new types, just
    constrained existing types (so they are
    compatible) can be used as in Pascal, plus case
    constants
  • subtype INDEX is INTEGER range 1 .. 100
  • All of operations defined for the parent type are
    also defined for subtype, except assignment of
    values out of range.

19
Implementation of user-defined ordinal types
  • Enumeration types are implemented by associating
    a nonnegative integer value with each symbolic
    constant in that type.
  • Sub range types are the parent types with code
    inserted (by the compiler) to restrict
    assignments to sub range variables

20
Arrays
  • An array is an aggregate of homogeneous data
    elements in which an individual element is
    identified by its position in the aggregate,
    relative to the first element.
  • Specific element of an array is identified by
  • i) Aggregate name
  • ii) Index (subscript)
  • position relative to the first element.

21
Design Issues
  • 1. What types are legal for subscripts?
  • 2. Are subscripting expressions in element
    references range checked?
  • 3. When are subscript ranges bound?
  • 4. When does allocation take place?
  • 5. What is the maximum number of subscripts?
  • 6. Can array objects be initialized?

22
Arrays and Indexes
  • Indexing is a mapping from indices to elements
  • map(array_name, index_value_list) ? an element
  • Syntax
  • - FORTRAN, PL/I, Ada use parentheses
  • - Most others use brackets
  • Example simple_array.C
  • include ltstream.hgt
  • void main()
  • char a8 "abcdefg"
  • cout ltlt a0 ltlt a
  • cout ltlt a1 ltlt (a1)

23
Subscript Types
  • FORTRAN, C, C, Java - int only
  • Pascal - any ordinal type (int, boolean, char,
    enum)
  • Ada - int or enum (includes boolean and char)
  • In some languages the lower bound of subscript
    range is fixed
  • C, C, Java - 0
  • FORTRAN - 1
  • In most other languages it needs to be specified
    by the programmer.

24
Number of subscripts
  • - FORTRAN I allowed up to three
  • - FORTRAN 77 allows up to seven
  • - C, C, and Java allow just one, but elements
    can be arrays
  • - Others - no limit
  • Array Initialization
  • - Usually just a list of values that are put in
    the array in the order in which the array
    elements are stored in memory

25
Examples
  • 1. FORTRAN - uses the DATA statement, or put
    the values in / ... / on the declaration
  • 2. C and C - put the values in braces can
    let the compiler count them
  • e.g.
  • int stuff 2, 4, 6, 8
  • 3. Ada - positions for the values can be
    specified
  • e.g.
  • SCORE array (1..14, 1..2)
  • (1 gt (24, 10), 2 gt (10, 7),
  • 3 gt(12, 30), others gt (0, 0))
  • 4. Pascal and Modula-2 do not allow array
    initialization in the declaration section of
    program.

26
Slices
  • A slice is some substructure of an array lt not a
    new data typegt,
  • nothing more than a referencing mechanism
  • 1. FORTRAN 90
  • INTEGER MAT (1 3, 1 3)
  • MAT(1 3, 2) - the second column
  • MAT(2 3, 1 3) - the second and
    third row
  • 2. Ada - single-dimensioned arrays only
  • LIST(4..10)

27
Implementation of Arrays
  • Access function maps subscript expressions to an
    address in the array - Row major (by rows) or
    column major order (by columns)
  • Column major order is used in FORTRAN, but most
    of other languages use row major order.

Location of the i, j element in a
matrix. LocationI,j address of a1,1
( i -1)(size of row)
(j -1)( element size).
28
Associative Arrays
  • An associative array is an unordered collection
    of data elements that are indexed by an equal
    number of values called keys.
  • Each element of a associative array is in fact a
    pair of entities, a key and value
  • - Design Issues
  • 1. What is the form of references to elements?
  • 2. Is the size static or dynamic?
  • Associative arrays are supported by the standard
    class library of Java.
  • But the main languages which supports an
    associative arrays is Perl.

29
Structure and Operations in Perl (hashes)
  • In Perl, associative arrays are often called
    hashes.
  • - Names begin with
  • - Literals are delimited by parentheses
  • hi_temps ("Monday" gt 77,
  • "Tuesday" gt 79,)
  • - Subscripting is done using braces and keys
  • hi_temps"Wednesday" 83
  • - Elements can be removed with delete
  • delete hi_temps"Tuesday"
  • _at_hi_temp () empties the entire hash

30
Records
  • A record is a possibly heterogeneous aggregate
    of data elements in which the individual elements
    are identified by names.
  • First was introduced in1960 COBOL since than
    almost all languages support them ( except pre 90
    FORTRAN).
  • Design Issues that are specific for records
  • 1. What is the form of references?
  • 2. What unit operations are
    defined?

31
Record Field References
  • 1. COBOL
  • field_name OF record_name_1 OF ... OF
    record_name_n
  • 2. Others (dot notation)
  • record_name_1.record_name_2. ...
    .record_name_n.field_name
  • Fully qualified references must include all
    record names
  • Elliptical references allow leaving out record
    names as long as the reference is unambiguous (
    COBOL and PL/I)
  • Pascal and Modula-2 provide a with clause to
    abbreviate references
  • In C and C, individual fields of structures
    are accessed by member selection operators .
    and -gt.

32
Example
  • structure type in C and C, program
    simple_struct.C
  • include ltstream.hgt
  • struct student
  • int ssn
  • char grade
  • void main()
  • struct student john
  • struct student p_john
  • john.grade 'A'
  • p_john john
  • cout ltlt p_john ? grade ltlt endl

33
Record Operations
  • 1. Assignment
  • - Pascal, Ada, and C allow it if the types
    are identical
  • 2. Initialization
  • - Allowed in Ada, using an aggregate
    constant
  • 3. Comparison
  • - In Ada, and / one operand can be an
    aggregate constant
  • 4. MOVE CORRESPONDING
  • - In COBOL - it moves all fields in the
    source record to fields with the same names in
    the destination record
  • Comparing records and arrays
  • 1. Access to array elements is much slower than
    access to record fields, because subscripts are
    dynamic (field names are static)
  • 2. Dynamic subscripts could be used with record
    field access, but it would disallow type
    checking and it would be much slower

34
Implementation of Record Type
  • The fields of record are stored in adjacent
    memory locations. The offset address relative to
    beginning is associated with each field.The
    field accesses are handled by using this offsets.

35
Unions
  • A union is a type whose variables are allowed to
    store different type
  • values at different times during execution
  • Design Issues for unions
  • 1. What kind of type checking, if any, must
    be done?
  • 2. Should unions be integrated with records?
  • Examples
  • 1. FORTRAN - with EQUIVALENCE in C or C
    construct union is used
  • (free unions)
  • 2. Algol 68 - discriminated unions
  • - Use a hidden tag to maintain the
    current type
  • - Tag is implicitly set by assignment
  • - References are legal only in
    conformity clauses
  • (see book example p. 231)
  • - This runtime type selection is a safe
    method of accessing union objects

36
Sets
  • A set is a type whose variables can store
    unordered collections of distinct values from
    some ordinal type called base type
  • Design Issue
  • What is the maximum number of elements in any
    set base type?
  • Examples
  • 1. Pascal
  • - No maximum size in the language definition
    (not portable, poor
  • writability if max is too small)
  • - Operations union (), intersection (),
    difference (-), , lt gt, superset
  • 2. Java includes a class for set operations

37
Sets
  • Evaluation
  • - If a language does not have sets, they must
    be simulated, either with enumerated types or
    with arrays
  • - Arrays are more flexible than sets, but have
    much slower operations
  • Implementation
  • - Usually stored as bit strings and use logical
    operations for the set operations

38
Pointers
  • A pointer type is a type in which the range of
    values consists of memory addresses and a special
    value, nil (or null) The value nil indicates
    that a pointer cannot currently be used to
    reference another object. In C and C, a value 0
    is used as nil.
  • Uses
  • 1. Addressing flexibility ( indirect addressing )
  • 2. Dynamic storage management ( access to heap)
  • Design Issues
  • 1. What is the scope and lifetime of pointer
    variables?
  • 2. What is the lifetime of heap-dynamic
    variables?
  • 3. Are pointers restricted to pointing at a
    particular type?
  • 4. Are pointers used for dynamic storage
    management, indirect addressing, or both?
  • 5. Should a language support pointer types,
    reference types, or both?

39
Fundamental Pointer Operations
  • 1. Assignment Sets a pointer variable to the
    address of some object.
  • 2. References (explicit versus implicit
    dereferencing)
  • Obtaining the value of the memory cell whose
    address
  • is in the memory cell to which the pointer
    variable
  • is bound to.
  • In C and C, dereferencing is specified by
    prefixing a identifier of a pointer type by the
    dereferencing operator ().

40
Example
  • (Example in C)
  • int j
  • int ptr // pointer to integer variables
  • ...
  • j ptr

Address-of operator () Produces the address of
an object.
41
Problems with pointers
  • 1. Dangling pointers (dangerous)
  • - A pointer points to a heap-dynamic variable
    that has been de-allocated
  • - Creating one
  • a. Allocate a heap-dynamic variable and set a
    pointer to point at it
  • b. Set a second pointer to the value of the
    first pointer
  • c. De-allocate the heap-dynamic variable, using
    the first pointer
  • (Example 1) dangling.C
  • include ltstream.hgt
  • void main()
  • int x, y
  • x new int
  • x 777
  • delete x
  • y new int
  • y 999
  • cout ltlt x ltlt endl

42
Example (C)
  • dangling.C
  • include ltstream.hgt
  • void main()
  • int x, y
  • x new int
  • x 777
  • delete x
  • y new int
  • y 999
  • cout ltlt x ltlt endl

Example 2 int x ... int y
1 x y ... cout ltlt x ltlt
endl // We don't know what's in x
43
Lost Heap-Dynamic Variables
  • - A heap dynamic variable that is no longer
    referenced by
  • any program pointer (wasteful)
  • - Creating one
  • a. Pointer p1 is set to point to a newly created
    heap-dynamic variable
  • b. p1 is later set to point to another newly
    created heap-dynamic variable
  • - The process of losing heap-dynamic variables is
    called memory leakage

44
Reference Types
  • C has a special kind of pointers Reference
    Types
  • which is constant pointers that are implicitly
  • de-referenced
  • Used for formal parameters in function
    definitions
  • Advantages of both pass-by-reference and pass-by
  • value
  • float stuff100
  • float p
  • p stuff
  • (p5) is equivalent to stuff5 and p5
  • (pi) is equivalent to stuffi and p

45
Java
  • Java - Only references
  • - No pointer arithmetic
  • - Can only point at objects (which are all on the
    heap
  • - No explicit deallocator (garbage collection is
    used
  • - Means there can be no dangling references
  • - Dereferencing is always implicit

46
Implementation of Pointer and Reference Types
  • In most larger computers, pointers and references
  • are single values stored in either two or
    four-byte
  • Memory cells depending on the size of the address
  • space of machine address.
  • Microcomputers
  • (thus are based on Intel microprocessors which
    uses two part addresses segment and offset)
    pointers and references are implemented as pair
    of 16 bit words, one for each part.

47
Garbage collection
  • Reference counter (eager approach) Each memory
    cell is associated with a counter which stores
    the number of pointers that currently point to
    the cell. When a pointer is disconnected from a
    cell, the counter is decremented by 1 if the
    reference counter reaches 0, meaning the cell has
    become a garbage, the cell is returned to the
    list of available space.

48
Garbage collection
  • (lazy approach) Waits until all available cells
    have
  • been allocated. A garbage collection process
    starts
  • by setting indicators of all the cells to
    indicate
  • they are garbage. Then every pointer in the
    program
  • is traced, and all reachable cells are marked as
  • not being garbage.

49
Chapter 7Expressions and Assignment Statements
  • Arithmetic Expressions
  • Overloaded Operators
  • Type Conversations
  • Relational and Boolean Expressions
  • Short Circuit Evaluation
  • Assignment Statements
  • Mixed Mode Assignments

50
Arithmetic Expressions
  • We have learned that variables are abstraction of
    memory cells in a computer
  • Abstraction of computation taking place in a CPU.
  • Corresponding to micro-operations executed in an
    arithmetic
  • logic unit (ALU), there are arithmetic and
    logical expressions.
  • Their evaluation was one of the motivations for
    the
  • development of the first programming languages
  • Arithmetic expressions consist of operators,
    operands, parentheses, and function calls

51
Design issues for arithmetic expressions
  • 1. What are the operator precedence rules?
  • 2. What are the operator associatively rules?
  • 3. What is the order of operand evaluation?
  • 4. Are there restrictions on operand evaluation
    side
  • effects?
  • 5. Does the language allow user-defined
    operator
  • overloading?
  • 6. What mode mixing is allowed in expressions?

52
Operators and operands
  • An expression consists of operators and operands.
    Operators
  • specify actions to be performed on data. Data
    processed by
  • an operator are called operands. Operators taking
    a single
  • operand is called unary
  • a (unary)
  • those taking two operators are called binary.
  • a b (binary)
  • A ternary operator has three operand C, C, and
    Java (?)
  • average (count 0)? 0 sum / count
  • In most imperative languages, binary operators
    are infix.

53
Operator Precedence
  • Def The operator precedence rules for expression
    evaluation define the order in which adjacent
    operators of different precedence levels are
    evaluated(adjacent means they are separated by
    at most one operand)
  • Typical precedence levels
  • 1. parentheses
  • 2. unary operators
  • 3. (if the language supports it) (
    exponentiation)
  • 4. , /
  • 5. , -
  • Language dependent ( see book for details)

54
Associatively rules
  • Def The operator associatively rules for
    expression evaluation define the order in which
    adjacent operators with the same precedence level
    are evaluated
  • Typical associatively rules
  • - usually left to right
  • - APL is different all operators have equal
    precedence and all operators associate right to
    left
  • Precedence and associatively rules can be
    overridden with parentheses
  • Example
  • A B C D

55
Operand evaluation order
  • The process
  • 1. Variables just fetch the value
  • 2. Constants sometimes a fetch from memory
    sometimes the constant is in the machine language
    instruction
  • 3. Parenthesized expressions evaluate all
    operands and operators first
  • 4. Function references The case of most
    interest.
  • - Order of evaluation is crucial
  • Functional side effects - when a function changes
    a parameter or a non-local variable

56
Operator Overloading
  • - Some is common (e.g., for int and float)
  • - Some is potential trouble (e.g., in C and
    C)
  • - Loss of compiler error detection
  • Can be avoided by introduction of new symbols
  • C allows user-defined overloaded operators
  • C a few operators cannot be overloaded
  • class or structure member (.)
  • scope resolution operator ()
  • Potential problems
  • - Users can define nonsense operations
  • - Readability may suffer

57
Implicit Type Conversions
  • A narrowing conversion is one that converts an
    object to a type that cannot include all of the
    values of the original type
  • A widening conversion is one in which an object
    is converted to a type that can include at least
    approximations to all of the values of the
    original type
  • A mixed-mode expression is one that has operands
    of different types
  • A coercion is an implicit type conversion
  • - The disadvantage of coercions
  • - They decrease in the type error detection
    ability of
  • the compiler
  • - In most languages, all numeric types are
    coerced in expressions, using widening
    conversions

58
Relational Expressions
  • Use relational operators and operands of various
    types
  • Evaluate to some Boolean representation
  • Relational operators always have lower precedence
    than arithmetic Operations
  • a 1 gt 2b
  • Boolean Expressions
  • Operands are Boolean and the result is Boolean
  • FORTRAN 77 FORTRAN 90 C Ada
  • .AND. and and
  • .OR. or or
  • .NOT. not ! not
  • C has no Boolean type--it uses int type with for
    false and
  • nonzero for true

59
Short Circuit Evaluation
  • A short-circuit evaluation of an expression is
    one in which the result is determined without
    evaluating all of the operands and/or operators.
  • index 1
  • while (index lt length) and
  • (LISTindex ltgt value) do
  • index index 1
  • C, C, and Java use short-circuit evaluation
    for the usual Boolean operators ( and ), but
    also provide bitwise Boolean operators that are
    not short circuit ( and )

60
Assignment Statements
  • The general syntax of the simple assignment
    statement is
  • lt target_valuegt ltassign_operatorgt ltexpressiongt
  • The operator symbol
  • 1. FORTRAN, BASIC, PL/I, C, C, Java
  • 2. ALGOLs, Pascal, Modula-2, Ada
  • can be bad if it is overloaded for the
    relational operator for equality

61
More complicated assignments
  • 1. Multiple targets A, B 10
  • 2. Conditional targets (C, C, and Java)
  • (first true) ? total subtotal 0
  • 3. Compound assignment operators (C, C, and
    Java)
  • sum next
  • 4. Unary assignment operators (C, C, and Java)
  • a
  • When two unary operators apply to the same
    operand, the association is right to left
  • a is same as (a)

62
Assignment as an Expression
  • In C, C, and Java, the assignment statement
    produces a result
  • - So, they can be used as operands in
    expressions
  • e.g. while ((ch getchar()) ! EOF) ...
  • Disadvantage
  • - Another kind of expression side effect
    often leads to expression that is hard to read
    and understand.
  • Example a b ( c d/b) 2

Assign b to temp Assign b 1 to b Assign d/temp
to c Assign b c to temp Assign temp - 2 to a.
63
Mixed-Mode Assignment
  • - In FORTRAN, C, and C, any numeric value can
    be assigned to any numeric scalar variable
    whatever conversion is necessary is done
  • - In Pascal, integers can be assigned to reals,
    but reals cannot be assigned to integers (the
    programmer must specify whether the conversion
    from real to integer is truncated or rounded)
  • In Java, only widening assignment coercions are
    done one of the effective ways to increase the
    reliability of Java, relative to C and C .
  • - In Ada and Modula 2 there is no assignment
    coercion
  • In all languages that allow mixed-mode
    assignment, the coercion
  • takes place only after the right side expression
    has been
  • evaluated

64
Chapter 8Statement-Level Control Structures
  • Compound Statements
  • Selection Statements
  • Iterative Statements
  • Unconditional Branching
  • Guarded Commands

65
Levels of Control Flow
  • The flow of control, or execution sequence, in
    program can be examined at several levels
  • 1. Within expressions
  • 2. Among program units
  • 3. Among program statements
  • Def Statements that provide capabilities such,
    selecting among alternative control flow paths or
    causing the repeated execution of certain
    collection of statements are called control
    statements
  • Def A control structure is a control statement
    and the statements whose execution it controls

66
Evolution
  • FORTRAN I control statements were based directly
    on IBM 704 hardware
  • Much research and argument in the1960s about
    the issue
  • goto or not having goto
  • One important result It was proven that all
    flowcharts can be coded with only two-way
    selection and pretest logical loops
  • Language features that helps make control
    statement design easier is
  • a method of forming statement collections.
  • Compound statements introduced by ALGOL60 in the
    form of begin.. .end
  • A block is a compound statement that can define a
    new scope (with local variables)
  • Overall Design Question
  • What control statements should a language have,
    beyond selection and pretest logical loops?
  • Whether the control structure can have multiple
    entry

67
Classification of Control Statements
  •  Selection statements Choose between two or more
    execution paths in a program.
  • Two-way selection statements
  • Select one of two execution pathsif-then-else
    statements.
  • Design issues
  • What is the form and type of the expression that
    controls the selection
  • Can a single statement, a sequence of statements,
    or a compound statement be selected
  • How should be meaning of nested selectors be
    specified

68
Nesting Selectors
  • Consider the following Java like code
  • if (sum 0)
  • if ( count 0)
  • result 0
  • else
  • result 1
  • In Java, as in many other imperative languages,
    the semantics of language specify that the else
    clause is always paired with the most recent
    unpaired then clause.
  • In ALGOL 60 it was done by using syntax an if
    must be nested in a then clause, it must be
    placed in a compound statement. This means that
    if statement is not allowed to be nested inside
    of than clause directly.

69
  • In ALGOL 60 it was done by using syntax If an if
    must be nested in a then clause, it must be
    placed in a compound statement. This means that
    if statement is not allowed to be nested inside
    of than clause directly.

if sum 0 then begin if count 0
then result 0 else
result 1 end
if sum 0 then begin if count
0 then result 0 end
else result 1
An alternative to ALGOL 60s design is to require
special closing words for then and else clauses
(if end if) ADA
70
Multiple selection constructs
  • Multiple selection construct allows the
    selection of one or any number of statements or
    statement groups switch construct. The original
    form came from FORTRAN
  • Design issues for multiple way selectors
  • What is the type and form of expression that
    controls the selection?
  • May single statement, sequence of statements or
    compound statement be selected?
  • Is the entire construct encapsulated in a
    syntactic structure?
  • Is execution flow through the structure
    restricted to include just one selectable
    segment?
  • How should unrepresented selector expression
    values be handled, if at all?

71
Early Multiple Selectors
  • 1. FORTRAN arithmetic IF (a three-way selector)
  • Bad aspects
  • - Not encapsulated (selectable segments
    could
  • be anywhere)
  • - Segments require GOTOs
  • 2. FORTRAN computed GOTO and assigned GOTO

72
Modern Multiple Selectors
  • Pascal case
  • case expression of
  • constant_list_1 statement_1
  • ...
  • constant_list_n statement_n
  • end
  • Design choices
  • 1. Expression is any ordinal type (int,
    boolean, char, enum)
  • 2. Segments can be single or compound
  • 3. Construct is encapsulated
  • 4. Only one segment can be executed per
    execution of the construct
  • 5. Result of an unrepresented control
    expression value is undefined
  • - Many dialects now have otherwise or else clause

73
The C and C switch
  • switch (expression)
  • constant_expression_1

  • statement_1
  • ...
  • constant_expression_n

  • statement_n
  • default
  • statement_n1
  • Design Choices (for switch)
  • 1. Control expression can be only an integer
    type
  • 2. Selectable segments can be statement
    sequences, blocks, or compound statements
  • 4. Any number of segments can be executed in
    one execution of the construct (there is no
    implicit branch at the end of selectable
    segments)
  • 5. default clause is for unrepresented values
    (if there is no default, the whole statement does
    nothing)

74
Example C
  • include ltstream.hgt
  • int days_in_month(int month)
  • int days
  • switch (month)
  • case 2
  • days 29
  • break
  • case 4 case 6 case 9 case 11
  • days 30
  • break
  • default
  • days 31
  • return days
  • void main()
  • cout ltlt days_in_month(3) ltlt endl

75
Iterative Statements
  • The repeated execution of a statement or compound
    statement is accomplished either by iteration or
    recursion here we look at iteration, because
    recursion is unit-level control
  • General design Issues for iteration control
    statements
  • 1. How is iteration controlled?
  • 2. Where is the control mechanism in the
    loop?
  • The primary possibilities for iteration
    control are logical, counting or combination of
    this two. Main choices for the location of the
    control mechanism are top or bottom of the loop.(
    posttest, or pretest)

76
Counter-Controlled Loops
  • Design Issues
  • 1. What is the type and scope of the loop var?
  • 2. What is the value of the loop var at loop
    termination?
  • 3. Should it be legal for the loop var or loop
    parameters to be changed in the loop body, and if
    so, does the change affect loop control?
  • 4. Should the loop parameters be evaluated only
    once, or once for every iteration?

77
C- Syntax
  • for (expr_1 expr_2 expr_3)
    statement
  • The expressions can be whole statements, or
    statement sequences, with the statements. If the
    second expression is absent, it is an infinite
    loop
  • C Design Choices
  • 1. There is no explicit loop var
  • 2. Irrelevant
  • 3. Everything can be changed in the loop
  • 4. Pretest
  • 5. The first expression is evaluated once, but
    the other two are evaluated with each iteration
  • - This loop statement is the most flexible

78
C and Java
  • C Differs from C in two ways
  • 1. The control expression can also be
    Boolean
  • 2. The initial expression can include
    variable definitions
  • (scope is from the definition to the end of
    the function in which it is defined)
  • Java Differs from C in two ways
  • 1. Control expression must be Boolean
  • 2. Scope of variables defined in the
    initial expression is only the loop body

79
Logically-Controlled Loops
  • Design Issues
  • 1. Pretest or posttest?
  • 2. Should this be a special case of the
    counting loop statement (or a separate
    statement)?
  • - Language Examples
  • 1. Pascal has separate pretest and posttest
    logical loop statements (while-do and
    repeat-until)
  • 2. C and C also have both, but the control
    expression for the posttest version is treated
    just like in the pretest case (while - do and do
    - while)
  • 3 Java is like C, except the control expression
    must be Boolean (and the body can only be entered
    at the beginning)

80
User-Located Loop Control Mechanisms
  • Design issues
  • 1. Should the conditional be part of the exit?
  • 2. Should the mechanism be allowed in an
    already controlled loop?
  • 3. Should control be transferable out of more
    than one loop?
  • Examples
  • 1. Ada - conditional or unconditional for any
    loop
  • any number of levels
  • for ... loop LOOP1
  • ... while ... loop
  • exit when ... ...
  • ... LOOP2
  • end loop for ... loop
  • ...
  • exit LOOP1 when ..
  • ...
  • end loop LOOP2
  • ...

81
User-Located Loop Control Mechanisms
  • C , C, and Java - break
  • Unconditional for any loop or switch one
    level only (Javas can have a label)
  • There is also a continue statement for loops
    it skips the remainder of this iteration, but
    does not exit the loop
  • FORTRAN 90 - EXIT
  • Unconditional for any loop, any number of
    levels
  • FORTRAN 90 also has CYCLE, which has the same
    semantics as C's continue

82
Iteration Based on Data Structures
  • Concept use order and number of elements of
    some data structure to control iteration
  • - Control mechanism is a call to a function that
    returns the next element in some chosen order,if
    there is one else exit loop
  • C's for can be used to build a user-defined
    iterator
  • e.g. for (phdr p pnext(p)) ...
  • Perl has a built-in iterator for arrays and
    hashes
  • e.g.,
  • foreach name (_at_names) print name

83
End of Lecture
Write a Comment
User Comments (0)
About PowerShow.com