Chapter 7
Chapter 7 Topics Introduction Overloaded Operators Type Conversions Relational and Boolean Expressions Short-Circuit Evaluation Assignment Statements Mixed-Mode Assignment
Introduction 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. It is important to understand the syntax and semantics of expressions.
Arithmetic Expressions Arithmetic expressions was one of the motivations for the development of the first programming languages. Arithmetic expressions consist of operators, operands, parentheses, and function calls. Design issues for arithmetic expressions - operator precedence rules
- operator associativity rules
- order of operand evaluation
- operand evaluation side effects
- operator overloading
- mode mixing expressions
Operators A unary operator has one operand. A binary operator has two operands. A ternary operator has three operands. For example, the C-based languages ternary operator ?:
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)
- *, /
- +, -
In most imperative languages, the unary minus can appear in an expression as long as it is parenthesized. For example, A + (- B) * C
Operator Precedence Rules APL is odd among languages because it has a single level of precedence. Thus, the order of evaluation of operators in APL expression is determined by the associativity rule.
Operator Associativity Rule 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., in 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. For example - A – B + C equivalent to (A - B) + C
- A ** B ** C equivalent to A ** ( B ** C)
Ternary Operator Conditional Expressions is a Ternary Operator in C-based languages Example: average = (count == 0)? 0 : sum / count - Evaluates as
- if (count == 0) average = 0
- else average = sum /count
Arithmetic Expressions: Operand Evaluation Order Operand evaluation order - Variables: fetch the value from memory
- Constants: sometimes fetch from memory; sometimes the constant is in the machine language instruction.
- Parenthesized expressions: evaluate all operands and operators first.
If neither of the operands of an operator has side effects, then operand evaluation order is irrelevent.
Side Effects Functional side effects: when a function changes a two-way parameter or a non-local variable. If fun does not have side effect of changing a, then the order of evaluation of the two operands, a and fun(a), has no effect on the value of the expression. If fun changes a, there is an effect.
Side Effects Problem with functional side effects: Consider the following situation: fun returns the value of its arqument divided by 2 and changes the value of its parameter to 20. Suppose we have the following If the value of a is fetched first (in the expression evaluation process), its value is 10 and the value of the expression is 15. If the second operand (fun(a)), is evaluated first, then the value of the first operand is 20 and the value of the expression is 25.
Side Effects Two possible solutions to the problem - Write the language definition to disallow functional side effects
- Disadvantage: inflexibility of two-way parameters and global references.
- Write the language definition to demand that operand evaluation order be fixed.
- Disadvantage: limits some compiler optimizations.
Overloaded Operators 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 - For example the ampersand operator (&) in C.
- A binary (&) specifies a bitwise logical AND operator.
- A unary (&) specifies an address (x = &y).
- For example, Pascal use div for integer division and / for float division.
Overloaded Operators (continued) C++ and Ada allow user-defined overloaded operators. For example, * and + can be defined to work on array data types. Potential problems: - Users can define nonsense operations, define + for multiplication.
- Readability may suffer, even when the operators make sense. For example, seeing an * operator in a program, the reader must find both the types of the operands and the definition of the operator.
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
Mixed Mode Expression A mixed-mode expression is one that has operands of different types A coercion is an implicit type conversion. In most languages, all numeric types are coerced in expressions, using widening conversions.
Explicit Type Conversions Most languages provide some capability for doing explicit conversion, both widening and narrowing. In C-based language, explicit conversion is called casting. Examples - C: (int) angle
- Ada: Float(sum)
Note that Ada’s syntax is similar to function calls
Errors in Expressions A number of errors can occur in expression evaluation. Causes - Limitations of arithmetic
- e.g., division by zero
- Limitations of computer arithmetic, when the result cannot be represented in memory cell
- e.g. overflow and underflow.
Relational Expressions Relational Expressions - Use relational operators and operands of various types
- Evaluate to some Boolean representation
- Operator symbols used vary somewhat among languages
- For example, the operator “not equal” is represented differently in many language:
The relational operators always have lower precedence than the arithmetic operators, for example - The arithmetic expression are evaluated first.
Boolean Expressions Boolean Expressions - Operands are Boolean and the result is Boolean
- Example operators
- FORTRAN 77 FORTRAN 90 C Ada
- .AND. and && and
- .OR. or || or
- .NOT. not ! not
- xor
No Boolean Type in C 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: - Left operator is evaluated, producing 0 or 1
- The evaluation result is then compared with the third operand (i.e., c)
Relational and Boolean Expressions: Operator Precedence Precedence of C-based operators - prefix ++, --
- unary +, -, prefix ++, --, !
- *,/,%
- binary +, -
- <, >, <=, >=
- =, !=
- &&
- ||
Short Circuit Evaluation 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)
- However, in arithmetic expressions this is not easily detected during execution, so it is never taken.
Example: (a >= 0) && (b < 10) - If a < 0, there is no need to evaluate (b < 10)
- Unlike the case of arithmetic expression, this shortcut can be easily discovered during execution.
Problem with Short Circuit Evaluation Assume list is an array of length elements (list has length -1 as the upper-bound subscript value) - index = 1;
- while (index < length) && (list [index] != key)
- index++;
- If evaluation is not short-circuit, both relational expressions are evaluated.
- If key is not in list then index=length, and list [index] will cause an indexing problem (subscript out-of-range error).
Short Circuit Evaluation (Cont’d) 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 operator AND and OR by using the two-word operator and then and or else. For example, in Ada assume that List is declared to have a subscript range of 1 .. Listlen, the Ad code - Index := 1;
- while (Index <= Listlen) and then (List (Index) /= Key)
- loop
- Index := Index + 1;
- end loop;
Will not cause an error when Key is not in List and Index becomes larger than Listlen.
Assignment Statements The general syntax - = 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 C and C++ allows Conditional targets on assignment statements. - (flag)? total : subtotal = 0
Which is equivalent to - if (flag)
- total = 0
- else
- subtotal = 0
Assignment Statements: Compound Operators A shorthand method of specifying a commonly needed form of assignment Introduced in ALGOL; adopted by C Example - a = a + b is written as a += b
Assignment Statements: Unary Assignment Operators Unary assignment operators in C-based languages combine increment and decrement operations with assignment Examples - sum = ++count; is equivalent to
- count = count + 1;
- sum = count;
- sum = count++ ; is equivalent to
- sum = count;
- count = count + 1;
- count++; (count incremented)
- -count++; (count incremented then negated)
Assignment as an Expression In C, C++, and Java, the assignment statement produces a result and can be used as an operands An example: while ((ch = getchar())!= EOF){…} ch = getchar() is carried out; the result (assigned to ch) is used as a conditional value for the while statement
Mixed-Mode Assignment Assignment statements can also be mixed-mode, for example - int 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, only widening assignment coercions are done. In Ada, there is no assignment coercion.
Summary Expressions Operator precedence and associativity Operator overloading Mixed-type expressions Various forms of assignment
Dostları ilə paylaş: |