Expressions & Assignments• One of the original intentions of computer programs was the

evaluation of mathematical expressions– languages would inherit much from math conventions– expressions are constructed from math operators, operands, parentheses,

functions• Design issues:

– what are the precedence and associativity rules? – what order are operands evaluated?– are there side effects?– is operator-overloading available?– what type mixing is allowed?

• All expressions consist of operators and operands, 3 forms of operators:– Binary (2 operands, the standard form of mathematical operator)– Unary (1 operand as in C’s i++ or in unary – as in -5)– Ternary (3 operands, as in C’s conditional statement)

• Expressions requiring fetching the operator followed by operands, then applying the operator to those operands

Precedence Rules and Associativity

Highest ** postfix ++, -- **, abs ** *, / prefix ++, -- *, /, mod, rem unary +, - +, - unary +, - unary +,- *, /, % *, /, % binary +,- binary +, -

Lowest binary +, -

FORTRAN C-languages Ada Ruby

“(” and “)” have the highest precedence in all languages

• If two or more operators are of the same precedence, then they are applied based on associativity– all languages use left-to-right associativity except when

dealing with exponent and unary operators• in FORTRAN, exponent is the only right-to-left operator• in Ada, a**b**c is illegal and so most be parenthesized

– NOTE: in Ada, unary – has lower precedence than mod, so –a mod b is not the same as –(a mod b)

• in C-langauges, ++/-- and unary +/- are right associative and there is no exponent operator

• In VB, exponent (^) is left associative

Side Effects• A side effect is when a function changes a parameter passed to it

– or changes a global variable

• This may lead to associativity not being maintained, for instance in– A + Fun(A)

• if Fun(A) does not alter A, then the order of evaluation between A and Fun(A) is unimportant

• but if Fun changes A, then A + Fun(A) < > Fun(A) + A

• Side effects can occur when the parameter is passed by reference (a pointer)– side effects become unimportant if you require that any function call be located at

the end of an expression– some languages disallow side effects (that is, you are not able to pass pointers to

pointers to functions, or use global vars in functions)

• Here is how some languages deal with side effects– C/C++: side effects are allowed to leave the language flexible– FORTRAN 77: expressions with function calls are legal only if the function does

not change the value of any operands in the expression– Pascal and Ada: allow all side effects– Java: operands evaluated left-to-right, programmer can avoid side effects by

placing function calls to the right in an expression

Overload Operators• When the same operator is used for different types

– arithmetic operators (+, -, *, /) are all used for byte, short, int, long, float and double, so they are all overloaded

• however, for each, the implementation differs

– overloading can aid readability and writability but requires type checking

• + may also be used for and, union or string concatenation• * is overloaded in C/C++ for pointer dereferencing• & is overloaded in C/C++ to generate an address and bitwise AND

– in cases where overloading causes the type of operation to differ (addition versus concatenation, dereferencing versus multiplication), then overloading damages readability

• the compiler must choose the correct meaning of the operator given operand types

• Question: can the programmer overload an operator? – available in Ada, C++, FORTRAN 95, Common Lisp, C#

• C++ restricts which operators can be overloaded (., .*, ::, ?:, sizeof)

Type Conversions/Coercions• Narrowing – going from a larger type to smaller type (e.g. int to

short int)– narrowing is rarely safe

• Widening – going from a smaller type to larger– widening is almost always safe however consider going from a 32-bit int to

a 32-bit float, while this is thought of as widening, you might lose precision!• Coercion:

– implicit type conversion initiated by the compiler• for instance, doing x + y where x is an int and y is a float

• Casts (in C/C++, Java, C#) are explicit conversion commands• Ada and Modula-2 also have them as in Float(X)

– Ada does not do implicit coercions, so the assignment below is not legal since * cannot apply to both an integer and a float

• A : Integer;• B, C : Float;• C = A * B;

• Java also has methods to perform explicit conversions• Most languages have at least round and truncate operations

Relational and Boolean Expressions• Evaluate to True/False rather than numeric

– relational operators always have lower precedence than arithmetic so that the relational comparison is performed after any arithmetic operations (ex. a+1 > b-2)

– boolean operators usually have lower precedence than relational operators except possibly NOT

Operation Ada C/Java FORTRAN77

Equal = = = .EQ.Not equal /= != .NE.Greater Than > > .GT.Less Than < < .LT.Greater/Equal >= >= .GE.Less/Equal <= <= .LE.AND and && .AND.OR or | | .OR.NOT not ! .NOT.

The FORTRAN abbreviations originated because early keypunches did not have <, > symbols available

FORTRAN 95 continued to use the abbreviations, but also included = =, <>, <, >, <=, >=

JavaScript/PHP add = = = and != = for equality/inequality with coercion disabled

Example expressions• In FORTRAN:

– A+B .GT. 2 * C . AND. K .NE. 0• order of operations: *, +, GT, NE, AND

• In Ada– A > B and A < C or K=0

• is illegal because and/or have equal precedence and therefore must parenthesize, the proper expression is

– (A > B and A < C) or K = 0• with order of precedence as <, > and =

performed first in a left-to-right order, followed by and followed by or

• In C: a > b > c– is legal as a > b returns a 1 or 0 which is

then compared to c

C-languageoperatorprecedence postfix++,-- prefix ++, --, !

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

Short Circuiting• A short circuited evaluation of an expression occurs if the result can be

determined without evaluating the entire expression– (13 * A) * (B / 13 - 1)

• if A=0, then the expression evaluates to 0 and the right term (B / …) is ignored

– (A >= 0) and (B < 10) • if A < 0 then the entire expression is false

• We often take advantage of short circuiting to simplify code to avoid errors– while(ptr!=NULL && ptr->value > target) ptr = ptr->next;– without short circuiting, we either risk an error arising (if ptr is NULL and we still

try to evaluat ptr->value, then we get an error) or we have to separate this into a while loop with an if statement inside it

• In Ada, short-circuiting is available using AND THEN and OR ELSE – While (Index <= Listlen) and then (List[index] /= key) do

• In Modula-2, Turbo Pascal, AND and OR are short-circuited– this is not true of Standard Pascal

• In C, C++, Java, && and || are short circuited and & and | are not– one must be cautious in C-languages when using short circuiting, consider this:– (a > b) && ((b++) / 3)

• if a > b is false, the right side of the expression is not performed and so b remains unchanged!

The Assignment Statement• Syntactic form:

– <target_var> <ass_op> <expr>

• FORTRAN, BASIC, PL/I, C, C++, Java, C#, Python all use = for <ass_op> whereas Ada/Algol/Pascal/Modula all use :=– in PL/I, the use of = is confusing as it is also used for “equal to” leading to

• A = B = C• this means “set A equal to true if B = C or false if B does not equal C”

• Some languages allow for multiple assignments in one statement– PL/I: SUM, TOTAL = 0– C, C++, Java can use incr/decr operators and nested assignments:

• a = b+(c = d / b++) - 1– b gets b+1, c gets d / b (old b), a gets b + c - 1 (old b, old c)

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

– Python: a, b, c = <expr1>, <expr2>, <expr3>– Common Lisp: (setf a b c d) same as a=b, c=d– Perl: ($a, $b, $c) = (1, 2, 3);

• C/C++/ Java also have the conditional target (ternary operator)– flag ? count1 : count2 = 0