1. Chapter 7
Expressions and Assignment Statements

2. Introduction
A Brief Introduction to Predicate Calculus
Predicate Calculus and Proving Theorems
An Overview of Logic Programming
Applications of Logic Programming

3. - Expressions are the fundamental means of specifying computations in a programming language
- To understand expression evaluation, we need to be familiar with the orders of operator and operand evaluation
- The essence of imperative languages is the dominant role of assignment statements

4. Introduction
Arithmetic Expressions
Overloaded Operators
Type Conversions
Relational and Boolean Expressions
Short-Circuit Evaluation
Assignment Statements
Mixed-Mode Assignment

5. Introduction Issues Assignment statement 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.

6. 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 a single operand, or binary, meaning they have two operands.
C, C++, and Java include a ternary operator, which has three operands.

7. Arithmetic Expressions (continued)
Design issues for arithmetic expressions
What are the operator precedence (priority) 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?

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

9. 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 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.

10. 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:
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 overridden 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

11. 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

12. 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 Java?) 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;

13. 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

14. 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, either during compilation or during run time. A typical example would be an expression mixing integer and floating point numbers (like ), where the integers are normally converted into the latter
The disadvantage of coercions:
They decrease 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

15. 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

16. 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., <>, #)
Boolean Expressions:
Operands are Boolean and the result is Boolean
Operators:
FORTRAN 90 Java C Ada
and & && and
or | || or
not ! ! not
^ xor
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

17. Relational and Boolean Expressions (continued)
The precedence of the arithmetic, relational, and Boolean operators in the C-based languages is as follows:
postfix ++, --
unary +, -, prefix ++, --, !
*, /, %
binary +, -
<, >, <=, >=
==, !=
&& ||
C, C++, and Java have over 40 operators and least 14 different levels of precedence

18. 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 0*x = 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.
C, C++, and Java: use short-circuit evaluation for the usual Boolean operators (&& and ||).
Short-circuit evaluation exposes the potential problem of side effects in expressions e.g. (a > b) || (b++ / 3)

19. 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.

20. 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

21. 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.

22. 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

23. Summary Expressions Operator precedence and associativity
Operator overloading
Mixed-type expressions
Various forms of assignment