Chapter 7

Expressions and Assignment Statements

Chapter 7 Topics

1-2

IntroductionArithmetic ExpressionsOverloaded OperatorsType ConversionsRelational and Boolean ExpressionsShort-Circuit EvaluationAssignment StatementsMixed-Mode Assignment

Introduction

1-3

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

Other issues in expression semantics are type mismatches, coercions, and short-circuit evaluation.

Essence of imperative languages is dominant role of assignment statements

Arithmetic Expressions

1-4

Arithmetic evaluation was one of the motivations for the development of the first programming languages

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

Arithmetic Expressions: Design Issues

1-5

Design issues for arithmetic expressions operator precedence rules operator associativity rules order of operand evaluation operand evaluation side effects operator overloading mode mixing expressions

Arithmetic Expressions: Operators

1-6

A unary operator has one operandA binary operator has two operandsA ternary operator has three operands

Arithmetic Expressions: Operator Precedence Rules

1-7

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) *, / +, -

Arithmetic Expressions: Operator Associativity Rule

1-8

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

Typical associativity rulesLeft to right, except **, which is right to leftSometimes 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 overriden with parentheses

Ruby ExpressionsAll arithmetic, relational, and assignment

operators, as well as array indexing, shifts, and bit-wise logic operators, are implemented as methods

- One result of this is that these operators can all

be overriden by application programs

Arithmetic Expressions: Conditional Expressions

1-10

Conditional ExpressionsC-based languages (e.g., C, C++)An example:

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

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

Arithmetic Expressions: Operand Evaluation Order

1-11

Operand evaluation order1. Variables: fetch the value from memory2. Constants: sometimes a fetch from

memory; sometimes the constant is in the machine language instruction

3. Parenthesized expressions: evaluate all operands and operators first

If neither of the operands of an operator has side effects, then operand evaluation is irrelevant.

Arithmetic Expressions: Potentials for Side Effects

1-12

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

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;

/* assume that fun changes its parameter */

b = a + fun(a);

Functional Side Effects

1-13

Two possible solutions to the problem1. Write the language definition to disallow

functional side effects No two-way parameters in functions No non-local references in functions Advantage: it works! Disadvantage: inflexibility of two-way

parameters and non-local references

2. Write the language definition to demand that operand evaluation order be fixed Java definition guaranties left-to-right order Disadvantage: limits some compiler

optimizations

Referential Transparency

1-14

A program has the property of referential transparency if any two expressions in the program that have the same value can be substituted for one another anywhere in the program.

result1 = (fun(a) + b) / (fun(a) – c);

temp = fun (a);

result2 = (temp + b) / temp – c);If the function fun has no side effects, result1

and result2 will be equal and therefore referential transparency will stand.

Overloaded Operators

1-15

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 (e.g., ampersant (&) in C and C++)Loss of compiler error detection (omission of

an operand should be a detectable error)Some loss of readabilityCan be avoided by introduction of new

symbols (e.g., Pascal’s div for integer division)

Overloaded Operators (continued)

1-16

C++ and Ada allow user-defined overloaded operators

Potential problems: Users can define nonsense operationsReadability may suffer, even when the

operators make senseC++ has a few operators that can not be

overloaded (i.e. class or structure member operator (.) and the scope resolution operator (::).

Type Conversions

1-17

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

Type Conversions: Mixed Mode

1-18

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

A coercion is an implicit type conversionDisadvantage 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

In C-based languages byte and short types are coerced to int whenever any operator is applied to them.

Explicit Type Conversions

1-19

Explicit Type ConversionsCalled casting in C-based languageExamples

C: (int) angleAda: Float (sum)

Note that Ada’s syntax is similar to function calls

Type Conversions: Errors in Expressions

1-20

CausesInherent limitations of arithmetic

e.g., division by zero

Limitations of computer arithmetic

e.g. overflow or underflow Caught at run-time run-time errors (also

called exceptions)

Relational and Boolean Expressions

1-21

Relational ExpressionsUse relational operators and operands of various typesEvaluate to some Boolean representationOperator symbols vary somewhat among languages (!=, /=, .NE., <>, #)

In JavaScript and PHP !== and ===prevent their operands from being coerced:

“7” == 7 : True but “7” === 7: falseIn Ruby == is with coercions and eql? Is with no

coercion.The relational operators always have lower precedence

than the arithmetic operators. i.e. a+ 1 > 2 * b

Relational and Boolean Expressions

1-22

Boolean ExpressionsOperands are Boolean and the result is

BooleanExample operators

FORTRAN 77 FORTRAN 90 C Ada

.AND. and && and .OR. or || or .NOT. not ! not xorIn Perl and Ruby both && and AND exist, but

the spelled version has lower precedence.

Relational and Boolean Expressions: No Boolean Type in C

1-23

C (prior to C99) had 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 1The evaluation result is then compared with the third

operand (i.e., c)Some languages (i.e. Perl and Ruby) provide two

sets of binary operators. The spelled version usually have lower precedence.

Readability dictates that a language should have Boolean type.

Relational and Boolean Expressions: Operator Precedence

1-24

Precedence of C-based operatorspostfix ++, --unary +, -,Prefix ++,--,!*,/,% binary +, -<, >, <=, >==, !=&&||

Short Circuit Evaluation

1-25

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)

Problem with non-short-circuit evaluationindex = 1;while (index <= length) && (LIST[index] != value)

index++;When index=length, LIST [index] will cause an

indexing problem (assuming LIST has length -1 elements)

Short Circuit Evaluation (continued)

1-26

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 operators AND and OR by using either and then and or else

Short-circuit evaluation exposes the potential problem of side effects in expressions

e.g. (a > b) || (b++ / 3)

Assignment Statements

1-27

The general syntax<target_var> <assign_operator> <expression>

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

1-28

Conditional targets (C, C++, and Java)(flag)? total : subtotal = 0

Which is equivalent to

if (flag)total = 0

elsesubtotal = 0

Assignment Statements: Compound Operators

1-29

A shorthand method of specifying a commonly needed form of assignment

Introduced in ALGOL; adopted by CExample

a = a + b

is written as

a += b

Assignment Statements: Unary Assignment Operators

1-30

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

Examplessum = ++count (count incremented, then assigned to sum)

sum = count++ (count assigned to sum, then incremented)

count++ (count incremented)

-count++ (count incremented then negated) equivalent to

–(count++)

Assignment as an Expression

1-31

In C, C++, and Java, the assignment statement produces a result, which is the same as the value assigned to the target, and can be used as operands

An example: while ((ch = getchar())!= EOF){…}

ch = getchar() is carried out; the result (assigned to ch) is compared to EOF and the result is used as a conditional value for the while statementanother example:

a = b + ( c = d / b) - 1

List AssignmentsPerl and Ruby support list assignments e.g., ($first, $second, $third) = (20, 30, 40);

Mixed-Mode Assignment

1-33

Assignment statements can also be mixed-mode, for exampleint 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, C++, C#, only widening assignment coercions are doneSo int value can be assigned to a float variable, but

not vice versa.In Ada, there is no assignment coercion