Connor's Notes

⬅️ Back to portfolio

COSC 2P05: Week 5 Notes

7 min read

Expressions

Expressions are the fundamental means of specifying computations in a programming language.

Design Issues

  • What are the operator precedence rules?
    • Does 3\*x+1 mean (3\*x) + 1 (good) or 3\*(x+1) (bad)
  • 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 type mixing is allowed in expressions?

Operator Evaluation Order

The operator precedence and associativity rules of a language dictate the order of evaluation of its operators.

Precedence

a + b * c

The operator precedence rules for expression evaluation partially define the order in which the operators of different precedence levels are evaluated.

RubyC-Based LanguagesAda
Highest**postfix ++, --**, abs
unary +, -prefix ++, --, unary +, -*/, mod, rem
*, /, %*, /, %unary +, -
Lowestbinary +, -binary +, -binary +, -

Associativity

a - b + c - d

When the expression contains two adjacent 2 occurances of operators with the same level of precedence, the question of which operator is evaluated first is answered by the associativity rules of the language

  • left or right associativity
LanguageAssociativity Rule
RubyLeft: *, /, +, -
Right: **
C-based languagesLeft: *, /, %, binary +, binary -
Right: ++, --, unary -, unary +
AdaLeft: all except **
Nonassociative: **

Conditional Expression

if-then-else statement vs conditional expression

if-then-else statement

if (count == 0)
	average = 0;
else
	average = sum / count;

Conditional Expression

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

Operand Evaluation Order

  • Order of evaluation of operands
    • If neither the operands of an operator has side effects, then operand evaluation order is irrelevant. Therefore, the only interesting case arises when the evaluation of an operand does have side effects.
    • A side effect of a function, naturally called a functional side effect, occurs when the function changes either one of its parameters or a global variable
    • Example:
int a = 5;
int fun1() {
	a = 17;
	return 3;
}

void main() {
	a = a + fun1();
}

Referential Transparency

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, without affecting the action of the program.

  • The value of a referentially transparent function depends entirely on its parameters.
result1 = (fun(a) + b) / (fun(a) - c);
temp = fun(a);
result2 = (temp + b) / (temp - c);

There are several advantages to referentially transparent programs. The most important of these is that the semantics of such programs is much easier to understand than the semantics of programs that are not referentially transparent. Being referentially transparent makes a function equivalent to a mathematical function, in terms of ease of understanding.

Overloading Operators

Arithmetic operators are often used for more than one purpose.

  • For example, + usually is used to specify integer addition and floating-point addition
  • Some languages (Java) also use it for string catenation

This multiple use of an operator is called operator overloading and is generally thought to be acceptable, as long as neither readability nor reliability suffers.

Problems

  • Using the same symbol for two completely unrelated operations is detrimental to readability (& in C++)
  • Input error may lead to “correct” program due to overloading
  • Some languages allow the programmer to further overload operator symbols (C++, C#, F#)

Type Conversions

Type conversions are either narrowing or widening.

  • A narrowing conversion converts the value to a type that cannot store even approximations of all values of the original type
    • Narrowing conversions are not always safe; sometimes the magnitude of the converted value is changed in the process
    • Example: double to int
  • A widening conversion converts a value to a type that can include at least approximations of al values of the original type
    • Widening conversions are nearly always safe, meaning that the approximate magnitude of the converted value is maintained
    • Can result in reduced accuracy
    • int to double

Coercion in Expressions

Coercion = implicit type conversion

Java

int a;
float b, c;
// ...
c = b * a;

Because error detection is reduced when mixed-mode expressions are allowed, F# and ML do not allow them.

Explicit Type Conversion

Most languages provide some capability for doing explicit conversions, both widening and narrowing.

C-based languages (casts)

(int) angle
  • potential errors due to failed conversion or coercions of operands in expressions.

Floating-point overflow, underflow, and division by zero are examples of run-time errors, which are sometimes called exceptions.

Relational and Boolean Expressions

The syntax of the relational operators for equality and inequality differs among some programming languages.

  • C-based languages use !=
  • Lua uses ~=
  • Fortran 95+ uses .NE. or <>
  • ML and F# use <>

JavaScript == vs ===

console.log("7" == 7); // prints true
// this is because == does implicit type conversions
 
console.log("7" === 7); // prints false
// === is strictly checking.  now automatic type conversion

Boolean Expressions

Boolean expressions consist of boolean variables, boolean constants, relational expressions, and boolean operators.

The precedence of the arithmetic, relational, and boolean operators in the C-based languages is as follows:

Precedence LevelOperators
Highestpostfix ++, --
unary +, unary -, prefix ++, --, !
*, /, %
binary +, binary -
<, >, <=, >=
=, !=
&&
Lowest||

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

(13 * a) * (b / 13 - 1)
(a >= 0) && (b < 10)

Problem with non-short-circuit evaluation of boolean expressions:

index = 0;
while ((index < listlen) && (list[index] != key))
	index = index + 1;

Side effects and short-circuit evaluation:

(a > b) || ((b++) / 3)

End of lecture 4 slides

Assignments

  • Symbol
    • Most contemporary languages: =
    • ALGOL 60, Ada: :=
  • Fortran, Ada
    • Assignment can only appear as a stand-alone statement iwth one variable on the left-hand side.
  • Conditional target (Perl)
    • ($flag ? $count1 : $count2) = 0;
  • Compound assignment
    • sum += value
  • Unary assignment operators (C-based languages, Perl, JavaScript)
    • sum = ++count;
    • sum = count++;
    • Associativity
      • count++
      • (-count)++
  • Assignment as an expression (C-based languages, Perl, JavaScript)
    • while (ch = getChar() != EOF) {/* ... */}
    • Expression side-effect!
      • a = b + (c = d / b) - 1
    • Multiple-target assignment
      • sum = count = 0
    • C syntax hides errors
      • if (x = y) { /* ... */}
      • x = y assigns and returns true
  • List assignments, multiple-target assignments (Perl, Ruby, Lua)
    • ($first, $second, $third) = (20, 40, 60);
    • ($first, $second) = ($second, $first)

Control Statements

Control statements alter the flow

  • Early languages such as Fortran used GOTOs
  • Two control statements necessary to implement any algorithm:
    • selection and iteration

Design Issue

Does the control structure have multiple entries?

Multiple exists

  • Multiple exists in control structures correspond to GOTOs

Selection Statements

A selection statement provides the means of choosing between two or more execution paths in a program.

Two-way Selection Statements

if control_expression
	then clause
	else clause

Design Issues

  • What is the form and type of the expression that controls the selection?
  • How are the then and else clauses specified?
  • How should the meaning of nested selectors be specified

Control Expression

Boolean data type vs arithmetic expression

Clause form

  • Single statement or compound statement
  • Perl: always compound statement
  • Fortran 95, Ada, Python, Ruby: Clauses are statement sequences terminated by a reserved word (Python uses indentation)

Nesting Selectors

<if stmt> → if <logic expr> then <stmt>
          | if <logic expr> then <stmt> else <stmt>

if (sum == 0)
    if (count == 0)
        result = 0;
    else
        result = 1;
if sum == 0 then
    if count == 0 then
        result = 0
    else
        result = 1
    end
end

Multiple-Selection Constructs

Design Issues

  • What is the form and type of the expression that controls the selection?
  • How are the seelctable segments specified?
  • Is execution flow through the structure restricted to include just a single selectable segment?
  • How are all the case values specified?
  • How should unrepresented selector expression values be handled, if at all?

C-multiple-selector construct switch (C, C++, Java, JavaScript)

switch (expression) {
	case constant_expression_1:  statement_1;
 	// ...
	case constant_n: statement_n;
 	[default: statement_n+1]
}
  • use of break!
  • C# disallows the implicit execution of more than one segment; break or goto case n
  • Ada
case
	when Boolean_expression then expression
	// ...
	when Boolean_expression then expression
	[else expression]
end
  • Subranges and choice lists; 10 | 15 | 20; allowed

Graph View