Chapter 7: Expressions and Assignment Statements in CSC204 Principles of Programming Languages

Using an operator for more than one purpose.

A conversion that converts a value to a type that cannot include all of the values of the original type.

An implicit type conversion in a mixed-mode expression.

Users can define nonsense operations and readability may suffer.

Compilers don't detect the coercion as a type error.

When the result of an operation cannot be represented in the memory cell where it must be stored.

Dominant role of assignment statements

Arithmetic evaluation was one of the motivations

Operator precedence rules

Two operands

Parentheses, Unary operators, **, *, /, +, -

The two main limitations of arithmetic operations are overflow/underflow and division by zero.

Relational expressions evaluate to some Boolean representation, using relational operators and operands of various types.

"7" == 7 is true, while "7" === 7 is false.

The main Boolean operators used in C, Ada, Perl, and Ruby are && (and), || (or), and ! (not).

The order of precedence from highest to lowest is: postfix ++, --, unary +, unary -, prefix ++, --, !, *, /, %, binary +, binary -, =, ==, !=, &&, ||.

Boolean expressions evaluate to a Boolean result, with operands that are Boolean values and operators such as && (and), || (or), and ! (not).

Unary assignment operators combine increment and decrement operations with assignment.

The assignment statement produces a result and can be used as operands.

An example of a mixed-mode assignment statement is: c = a / b;

In Java, only widening assignment coercions are done (int to float only), while in Perl, C, and C++, any numeric type value can be assigned to any numeric type variable.

Assignment statements can be used as conditional values by assigning a value to a variable and using it in a conditional expression.

The use of assignment statements as operands may lead to the loss of error detection, potentially resulting in program errors.

Short-circuit evaluation is an evaluation technique where the result is determined without evaluating all operands and/or operators. In C, C++, and Java, short-circuit evaluation is used for the logical operators && (and) and || (or). For example, if the expression (a > 0) && (b / a > 10) is evaluated, and a is 0, the second operand (b / a > 10) is not evaluated since the result is already determined as false due to short-circuiting.

The assignment operator = is used in languages like FORTRAN, BASIC, and the C-based languages. However, some languages like ALGOL, Pascal, and Ada use the := operator for assignment. The rationale for using := is to avoid confusion with the = operator, which is often overloaded as the relational operator for equality in these languages. The C-based languages use == as the relational operator to avoid this ambiguity.

Conditional targets are a feature in some programming languages that allow conditional expressions to be used as targets of assignment statements. In Perl, for example, the syntax ($flag ? $total : $subtotal) = 0; assigns the value 0 to either $total or $subtotal depending on the value of $flag. This is equivalent to the if-else statement: if ($flag) { $total = 0 } else { $subtotal = 0 }.

Compound assignment operators provide a shorthand method for performing a common form of assignment operation. They were introduced in ALGOL and later adopted by languages like C and others. For example, in C, the expression a = a + b can be written using the compound assignment operator += as a += b. This is a more concise way of expressing the operation of adding b to a and assigning the result back to a.

The general syntax for assignment statements in programming languages typically involves a target variable or expression on the left-hand side, followed by an assignment operator (e.g., =, :=), and an expression or value to be assigned on the right-hand side. The specific assignment operator used may vary across languages, but the overall structure follows this pattern.

The purpose of short-circuit evaluation for logical operators like && (and) and || (or) is to improve performance and avoid unnecessary computations. When evaluating a logical expression with multiple operands, short-circuit evaluation allows the evaluation to stop as soon as the result can be determined, without evaluating the remaining operands. This is beneficial in situations where the remaining operands involve computationally expensive or potentially invalid operations. For example, in the expression (x != 0) && (y / x > 10), if x is 0, short-circuit evaluation avoids the division by zero error by not evaluating the second operand.