Expressions and Assignment Statements

1
Expressions and Assignment Statements

• Chapter 7

2
Introduction

• Expression are the fundamental means of
  specifying computations in a programming
  language
• Issues
• Order of evaluation
• Type mismatch and coercions
• Short circuit evaluation
• Assignment statement
• Used in imperative languages to change the value
  of a variable
• Contains an expression to be evaluated and a
  target location for the answer.

3
Arithmetic Expressions

• Most of the characteristics of arithmetic
  expressions in programming languages were
  inherited from conventions that had evolved in
  mathematics.
• The purpose of an arithmetic expression is to
  specify an arithmetic computation. The two
  actions of this are
• fetching the operands, usually from memory,
• executing the arithmetic operations on those
  operands
• In programming languages, arithmetic expressions
  consist of operators, operands, parentheses, and
  function calls.
• The operators can be unary, meaning they have
  single operand, or binary, meaning they have two
  operands.
• C, C, and Java include a ternary operator,
  which has three operands.

4
Arithmetic Expressions (continued)

• Design issues for arithmetic expressions
• What are the operator precedence rules?
• What are the operator associativity rules?
• What is the order of operand evaluation?
• Are there restrictions on operand evaluation side
  effects?
• Does the language allow user-defined operator
  overloading?
• What mode mixing is allowed in expressions?

5
Arithmetic Expressions (continued)

• Number of operands for an operator
• A unary operator has one operand
• A binary operator has two operands
• A ternary operator has three operands
• 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)
• , /
• , -

6
Arithmetic Expressions (continued)

• The order of an expression depends on the order
  of evaluation of the operators
• The operator precedence rules for expression
  evaluation define the order in which the
  operators of different precedence levels are
  evaluated. These rules are based on the
  hierarchy of operator priorities.
• Unary addition is called identity operator
  because it usually has no associated operation
  and thus has no effect on its operand.

7
Arithmetic Expressions (continued)

• 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., FORTRAN)
• APL is different all operators have equal
  precedence and all operators associate right to
  left
• Precedence and associativity rules can be
  overriden with parentheses
• Operand evaluation order
• The process
• Variables just fetch the value
• Constants sometimes a fetch from memory
  sometimes the constant is in the machine language
  instruction
• Parenthesized expressions evaluate all operands
  and operators first
• Function references The case of most interest!
• Order of evaluation is crucial

8
Arithmetic Expressions (continued)

• Functional side effects - when a function changes
  a two-way parameter or a nonlocal variable
• The problem with functional side effects
• When a function referenced in an expression
  alters another operand of the expression e.g.,
  for a parameter change
• a 10
• b a fun(a)
• / Assume that fun changes its parameter /
• Same problem with global variables

9
Arithmetic Expressions (continued)

• Two Possible Solutions to the Problem
• Write the language definition to disallow
  functional side effects
• No two-way parameters in functions
• No nonlocal references in functions
• Advantage it works!
• Disadvantage Programmers want the flexibility of
  two-way parameters (what about C?) and nonlocal
  references
• Write the language definition to demand that
  operand evaluation order be fixed
• Disadvantage limits some compiler optimizations
• Conditional Expressions
• C, C, and Java (?) e.g.
• average (count 0)? 0 sum / count

10
Overloaded Operators

• Operator overloading is the multiple use of
  operators.
• Example, the is used for addition and for
  string concatenation in Java.
• The in C is a problem and overloading the
  and operator is also a problem.
• Loss of compiler
• Loss of readability
• Can be avoided by introducing new symbols
• C and Ada allow user-defined overloaded
  operators
• Potential problem if user defines nonsense
  operators like using to mean multiply

11
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
• 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
• In Ada, there are virtually no coercions in
  expressions

12
Type Conversions (cont.)

• Explicit Type Conversions
• Often called casts e.g.
• Ada
• FLOAT(INDEX) -- INDEX is INTEGER type
• Java
• (int)speed / speed is float type /
• Errors in Expressions
• Caused by
• Inherent limitations of arithmetic e.g. division
  by zero
• Limitations of computer arithmetic e.g. overflow
• Such errors are often ignored by the run-time
  system

13
Relational and Boolean Expressions

• Relational Expressions
• Use relational operators and operands of various
  types
• Evaluate to some Boolean representation
• Operator symbols used vary somewhat among
  languages (!, /, .NE., ltgt, )
• Boolean Expressions
• Operands are Boolean and the result is Boolean
• Operators
• FORTRAN 77 FORTRAN 90 C Ada
• .AND. and and
• .OR. or or
• .NOT. not ! not
• xor
• C has no Boolean type--it uses int type with 0
  for false and nonzero for true
• One odd characteristic of Cs expressions a lt b
  lt c is a legal expression, but the result is not
  what you might expect

14
Relational and Boolean Expressions (continued)

• Precedence of all Ada Operators
• , abs, not
• , /, mod, rem
• unary -,
• binary , -,
• relops, in, not in
• and, or, xor, and then, or else
• C, C, and Java have over 40 operators and least
  15 different levels of precedence

15
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.
• Ex., (13 A) (B / 13 1) is independent of
  the value (B / 13 1) if a is 0. Because 0x
  0 for any x. So if A is 0 there is no need to
  evaluate (B / 13 1).
• Short-circuit evaluation of expressions exposes
  the problem of allowing side effects in
  expressions.
• Suppose Java did not use short-circuit evaluation
• C, C, and Java use short-circuit evaluation
  for the usual Boolean operators ( and ).
• Ada programmer can specify either (short-circuit
  is specified with and then and or else)
• Short-circuit evaluation exposes the potential
  problem of side effects in expressions e.g. (a gt
  b) (b / 3)

16
Assignment Statements

• The operator symbol
• FORTRAN, BASIC, PL/I, C, C, Java
• ALGOLs, Pascal, Ada
• Can be bad if it is overloaded for the
  relational operator for equality
• e.g. (PL/I) A B C A is set to the Boolean
  value for the result of B C
• In the C statement A B C, the value of C is
  assigned to B, and the value of B is assigned to
  A.

17
Assignment Statements (continued)

• More complicated assignments
• Multiple targets (PL/I)
• A, B 10
• Conditional targets (C, C, and Java)
  if(flag) count1 0 else count2 0
• Compound assignment operators (C, C, and Java)
• sum next
• Unary assignment operators (C, C, and Java)
• a
• C, C, and Java treat as an arithmetic binary
  operator
• e.g.
• a b (c d 2 1) 1
• This is inherited from ALGOL 68

18
Assignment Statements (continued)

• 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 of
  changing its left operand.

19
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
• In Ada, there is no assignment coercion

20
Important Questions

• Q1 What is the importance of expressions and
  assignment in PLs.
• Q2 Define precedence and its order of
  evalaution.
• Q3 When associativity arises.
• Q4 What do you mean by overloading and does
  overloading reduce the readability of PLs, give
  one example.
• Q5 identify the difference between implicit and
  explicit type conversion.
• Q6 What do you mean the short circuit
  evaluation, give one example.
• Q7 define narrowing conversion and widening
  conversion. Which conversion is mostly supported
  by PLs.
• Q8 Define Coercion.