ICS 141 Klefstad

Expressions and Assignment

Outline

Introduction

issues
- detecting type mismatches
- type conversions
- short-circuit evaluation

Order of Evaluation

operators can be unary, binary, ternary, ...
precedence and associativity rules determine order of evaluation
order of evaluation must be understood by programmer
```
x + y / 2 * z <= c && b > 0
```
parenthesis may be used to over-ride precedence
```
( x + y ) / z;
```
APL uses strict left-to-right evaluation
LISP requires explicit parens

Evaluation

constants - use their literal value or fetch value
variables - fetch their value
operators
- evaluate their operands (in some order)
- apply the operand to resulting values

Side Effects

'side effect' a modification to a non-local variable

int global = 0;
int foo( int & j )
{
  j = 10;
  global = 20;
}
int main()
{
  int x = 30;
  foo( x );
  cout << global << x;
}

Conditional Expressions

a common situation

if ( cond )
  x = value1;
else
  x = value2;

conditional expression makes this notational simpler
```
x = cond ? value1 : value2;
```
can create cryptic code if misused

Overloaded Operators

overloading is when several different functions have the same name
most languages have some operator overloading
- EG + or * for both integers and floating point numbers

overloading allows natural notation for user defined types

EG class Complex

Complex a,b,c;
assign(a, add(b, c)); // awkward functional notation
a.assign(b.add(c)); // awkward object-oriented notation
a = b * c; // natural notation

can be misused as well
- EG using unary plus for type conversion

Ada and C++ allow overloading of subprograms and most operators
Java allows + for string concatenation, no operator overloading
over-use of symbols can be confusing:
- EG C++ use of * or &

Type Conversion

'narrowing conversion'
- conversion to a type that has less precision
- may lose some precision
- EG double to float or long to short or long (32 bit) to float (32 bit)
'widening conversion'
- conversion to a type that has more precision
- EG short to long or long to double

'coercion'

implicit operand conversion

float x, y; int i;
x = i + y; // C++ will coerce i to a float

explicit conversion
- in Ada: float(i) or integer(x)
- in C++: float(i) or (float)i or (char *)p

Boolean Expressions

equality: ==, !=
relational: <, >, <=, >=
logical: &&, ||, !, XOR
alternatives:
- Ada: and, or, /=
- FORTRAN: .AND., .OR., .NE.
- C++: &&, ||, !=

Short-Circuit Evaluation

evaluation stops when value is known

if (p != null && p->field == value)

...

while ( i < length && list[i] != key )
  i++;

C++: && and || are short circuited
Ada: and then, or else are short circuited

Assignment Statements

typically of the form
```
name Assign expression
```
FORTRAN, BASIC, PL/I, C, C++ use = for Assign
Algol, Pascal, Ada use :=
most languages make it a stand-alone statement
other operators may do assignments:
```
++, --, +=, -=
```

C/C++ treats it like an operator

int ch;
while ( (ch = getchar()) != EOF )
  putchar(ch);

allows common error:
```
int a = 0;
if ( a = 0 ) // never true
```
Java (sort of) fixes this by defining type Boolean

while, for, if expressions must be Boolean

if ( a == 0 ) // returns boolean
if ( a = b ) // returns int - error

Mixed-Mode Assignment

can use coercion or mismatch error
Ada, Modula-2 have no implicit type conversion
FORTRAN, C++ automatically coerce to type of destination
Pascal will convert integer to real, but not vice-versa