Chapter 7 Expressions and Assignment Statements

Yüklə 447 b.
ölçüsü447 b.

Chapter 7

Chapter 7 Topics

  • Introduction

  • Arithmetic Expressions

  • Overloaded Operators

  • Type Conversions

  • Relational and Boolean Expressions

  • Short-Circuit Evaluation

  • Assignment Statements

  • Mixed-Mode Assignment


  • Expressions are the fundamental means of specifying computations in a programming language.

  • To understand expression evaluation, need to be familiar with the orders of operator and operand evaluation.

  • It is important to understand the syntax and semantics of expressions.

Arithmetic Expressions

  • Arithmetic expressions was one of the motivations for the development of the first programming languages.

  • Arithmetic expressions consist of operators, operands, parentheses, and function calls.

  • Design issues for arithmetic expressions

    • operator precedence rules
    • operator associativity rules
    • order of operand evaluation
    • operand evaluation side effects
    • operator overloading
    • mode mixing expressions


  • A unary operator has one operand.

  • A binary operator has two operands.

  • A ternary operator has three operands. For example, the C-based languages ternary operator ?:

Operator Precedence Rules

  • The operator precedence rules for expression evaluation define the order in which “adjacent” operators of different precedence levels are evaluated

  • Typical precedence levels

    • parentheses
    • unary operators
    • ** (if the language supports it)
    • *, /
    • +, -
  • In most imperative languages, the unary minus can appear in an expression as long as it is parenthesized. For example,

  • A + (- B) * C

Operator Precedence Rules

  • APL is odd among languages because it has a single level of precedence.

  • Thus, the order of evaluation of operators in APL expression is determined by the associativity rule.

Operator Associativity Rule

  • The operator associativity rules for expression evaluation define the order in which adjacent operators with the same precedence level are evaluated

  • Typical associativity rules

    • Left to right, except **, which is right to left
    • Sometimes unary operators associate right to left (e.g., in FORTRAN)
  • APL is different; all operators have equal precedence and all operators associate right to left.

  • Precedence and associativity rules can be overridden with parentheses. For example

        • A – B + C equivalent to (A - B) + C
        • A ** B ** C equivalent to A ** ( B ** C)

Ternary Operator

  • Conditional Expressions is a Ternary Operator in C-based languages

  • Example:

  • average = (count == 0)? 0 : sum / count

    • Evaluates as
    • if (count == 0) average = 0
    • else average = sum /count

Arithmetic Expressions: Operand Evaluation Order

  • Operand evaluation order

    • Variables: fetch the value from memory
    • Constants: sometimes fetch from memory; sometimes the constant is in the machine language instruction.
    • Parenthesized expressions: evaluate all operands and operators first.
  • If neither of the operands of an operator has side effects, then operand evaluation order is irrelevent.

Side Effects

  • Functional side effects: when a function changes a two-way parameter or a non-local variable.

  • Consider the expression

        • a + fun(a)
  • If fun does not have side effect of changing a, then the order of evaluation of the two operands, a and fun(a), has no effect on the value of the expression.

  • If fun changes a, there is an effect.

Side Effects

  • Problem with functional side effects:

  • Consider the following situation: fun returns the value of its arqument divided by 2 and changes the value of its parameter to 20. Suppose we have the following

        • a = 10;
        • b = a + fun(a);
  • If the value of a is fetched first (in the expression evaluation process), its value is 10 and the value of the expression is 15.

  • If the second operand (fun(a)), is evaluated first, then the value of the first operand is 20 and the value of the expression is 25.

Side Effects

  • Two possible solutions to the problem

    • Write the language definition to disallow functional side effects
      • Disadvantage: inflexibility of two-way parameters and global references.
    • Write the language definition to demand that operand evaluation order be fixed.
      • Disadvantage: limits some compiler optimizations.

Overloaded Operators

  • Use of an operator for more than one purpose is called operator overloading

  • Some are common (e.g., + for int and float)

  • Some are potential trouble

    • For example the ampersand operator (&) in C.
    • A binary (&) specifies a bitwise logical AND operator.
    • A unary (&) specifies an address (x = &y).
  • Can be avoided by introduction of new symbols

    • For example, Pascal use div for integer division and / for float division.

Overloaded Operators (continued)

  • C++ and Ada allow user-defined overloaded operators.

  • For example, * and + can be defined to work on array data types.

  • Potential problems:

    • Users can define nonsense operations, define + for multiplication.
    • Readability may suffer, even when the operators make sense. For example, seeing an * operator in a program, the reader must find both the types of the operands and the definition of the operator.

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, e.g. float to int

  • 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, e.g. int to float

Mixed Mode Expression

  • A mixed-mode expression is one that has operands of different types

  • A coercion is an implicit type conversion.

  • In most languages, all numeric types are coerced in expressions, using widening conversions.

Explicit Type Conversions

  • Most languages provide some capability for doing explicit conversion, both widening and narrowing.

  • In C-based language, explicit conversion is called casting.

  • Examples

    • C: (int) angle
    • Ada: Float(sum)
  • Note that Ada’s syntax is similar to function calls

Errors in Expressions

  • A number of errors can occur in expression evaluation.

  • Causes

    • Limitations of arithmetic
    • e.g., division by zero
    • Limitations of computer arithmetic, when the result cannot be represented in memory cell
    • e.g. overflow and underflow.

Relational Expressions

  • Relational Expressions

    • Use relational operators and operands of various types
    • Evaluate to some Boolean representation
    • Operator symbols used vary somewhat among languages
    • For example, the operator “not equal” is represented differently in many language:
      • (!=, /=, .NE., <>, #)
  • The relational operators always have lower precedence than the arithmetic operators, for example

        • a + 1 > 2 * b
    • The arithmetic expression are evaluated first.

Boolean Expressions

  • Boolean Expressions

    • Operands are Boolean and the result is Boolean
    • Example operators
    • FORTRAN 77 FORTRAN 90 C Ada
    • .AND. and && and
    • .OR. or || or
    • .NOT. not ! not
    • xor

No Boolean Type in C

  • C has no Boolean type--it uses int type with 0 for false and nonzero for true

  • One odd characteristic of C’s expressions: a < b < c is a legal expression, but the result is not what you might expect:

    • Left operator is evaluated, producing 0 or 1
    • The evaluation result is then compared with the third operand (i.e., c)

Relational and Boolean Expressions: Operator Precedence

  • Precedence of C-based operators

    • prefix ++, --
    • unary +, -, prefix ++, --, !
    • *,/,%
    • binary +, -
    • <, >, <=, >=
    • =, !=
    • &&
    • ||

Short Circuit Evaluation

  • An expression in which the result is determined without evaluating all of the operands and/or operators

  • Example: (13*a) * (b/13–1)

    • If a is zero, there is no need to evaluate (b/13-1)
    • However, in arithmetic expressions this is not easily detected during execution, so it is never taken.
  • Example: (a >= 0) && (b < 10)

    • If a < 0, there is no need to evaluate (b < 10)
    • Unlike the case of arithmetic expression, this shortcut can be easily discovered during execution.

Problem with Short Circuit Evaluation

  • Assume list is an array of length elements (list has length -1 as the upper-bound subscript value)

    • index = 1;
    • while (index < length) && (list [index] != key)
    • index++;
    • If evaluation is not short-circuit, both relational expressions are evaluated.
    • If key is not in list then index=length, and list [index] will cause an indexing problem (subscript out-of-range error).

Short Circuit Evaluation (Cont’d)

  • 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 |).

  • Ada: programmer can specify short circuit evaluation of the Boolean operator AND and OR by using the two-word operator and then and or else.

  • For example, in Ada assume that List is declared to have a subscript range of 1 .. Listlen, the Ad code

      • Index := 1;
      • while (Index <= Listlen) and then (List (Index) /= Key)
      • loop
      • Index := Index + 1;
      • end loop;
  • Will not cause an error when Key is not in List and Index becomes larger than Listlen.

Assignment Statements

  • The general syntax

  • The assignment operator

    • = FORTRAN, BASIC, PL/I, C, C++, Java
    • := ALGOLs, Pascal, Ada
  • = can be bad when it is overloaded for the relational operator for equality.

Assignment Statements: Conditional Targets

  • C and C++ allows Conditional targets on assignment statements.

        • (flag)? total : subtotal = 0
  • Which is equivalent to

        • if (flag)
        • total = 0
        • else
        • subtotal = 0

Assignment Statements: Compound Operators

  • A shorthand method of specifying a commonly needed form of assignment

  • Introduced in ALGOL; adopted by C

  • Example

    • a = a + b is written as a += b

Assignment Statements: Unary Assignment Operators

  • Unary assignment operators in C-based languages combine increment and decrement operations with assignment

  • Examples

    • sum = ++count; is equivalent to
        • count = count + 1;
        • sum = count;
    • sum = count++ ; is equivalent to
        • sum = count;
        • count = count + 1;
    • count++; (count incremented)
    • -count++; (count incremented then negated)

Assignment as an Expression

  • In C, C++, and Java, the assignment statement produces a result and can be used as an operands

  • An example:

  • while ((ch = getchar())!= EOF){…}

  • ch = getchar() is carried out; the result (assigned to ch) is used as a conditional value for the while statement

Mixed-Mode Assignment

  • Assignment statements can also be mixed-mode, for example

    • int a, b;
    • float c;
    • c = a / b;
  • In Pascal, integer variables can be assigned to real variables, but real variables cannot be assigned to integers

  • In Java, only widening assignment coercions are done.

  • In Ada, there is no assignment coercion.


  • Expressions

  • Operator precedence and associativity

  • Operator overloading

  • Mixed-type expressions

  • Various forms of assignment

Dostları ilə paylaş:

Verilənlər bazası müəlliflik hüququ ilə müdafiə olunur © 2019
rəhbərliyinə müraciət

    Ana səhifə