Programming Chapter 6: Expressions & Assignment

Chapter 6: Expressions and Assignment Statements

• Expressions are the fundamental means of specifying computations in a programming language.
• Understanding expression evaluation involves knowing the order of operators and operand evaluation.
• Imperative languages primarily use assignment statements.
• Arithmetic expressions consist of operators, operands, parentheses, and function calls.

Chapter 5 Topics

• The topics for chapter 5 involve expressions and assignment statements.
• This chapter includes introduction to expressions, arithmetic expressions, overloaded operators, type conversions, relational and Boolean expressions, short-circuit evaluation, assignment statements, and mixed-mode assignment.

Introduction

• Expressions are the essential tools for defining computations within a programming language.
• To grasp expression evaluation, understanding operator and operand evaluation order is essential.
• Assignment statements are crucial for imperative languages as they dominate programming.

Arithmetic Expressions

• Arithmetic evaluation was a driving force behind the creation of the very first programming languages.
• Arithmetic expressions in programming comprise operators, operands, parentheses, and function calls.

Arithmetic Expressions: Design Issues

• The design of arithmetic expressions includes operator precedence, operator associativity rules, operand evaluation order, operand evaluation side effects, operator overloading, and mode mixing.

Arithmetic Expressions: Operators

• A unary operator has one operand.
• A binary operator has two operands.
• A ternary operator has three operands.

Arithmetic Expressions: Operator Precedence Rules

• Operator precedence rules dictate the order in which adjacent operators with differing precedence levels are evaluated.
• Typical precedence levels include parentheses, unary operators, exponentiation (if supported), multiplication/division, and addition/subtraction.

Arithmetic Expressions: Operator Associativity Rule

• Operator associativity rules define the order in which adjacent operators of the same precedence are executed.
• Typical associativity is left-to-right, except for exponentiation, which is usually right-to-left.

Arithmetic Expressions: Conditional Expressions

• C-based languages use conditional expressions, like average = (count == 0) ? 0 : sum / count to represent conditional operations.
• This expression checks if the count is zero ; if it is, the average is set to zero else it computes the sum/count

Arithmetic Expressions: Operand Evaluation Order

• Variables fetch their values directly from memory.
• Constant values may be directly available or fetched.
• Parenthesized expressions are evaluated first (precedence over other sub-expressions), followed by evaluating all their operands and operators.

Arithmetic Expressions: Potentials for Side Effects

• Functional side effects happen when a function changes a two-way parameter or a non-local variable making code potentially unpredictable.

Functional Side Effects

• Addressing the issues of side effects involves two main approaches controlling side effects within function definitions.
• Controlling parameter passing in function definitions can reduce issues.
• Compilers can also be designed to eliminate issues related to operand evaluation orders.

Overloaded Operators

• Overloading operators signifies using a single operator symbol for multiple operations.
• This can be helpful but potentially create problems with compiler error detection and readability, especially when operators have different meanings.

Overloaded Operators (continued)

• Programs can implement different meanings for overloaded operators.
• This may, however, make the program less readable and less reliable.
• User-defined operators can sometimes result in unintended behavior.

Type Conversions

• Narrowing conversions: When a conversion loses some of the possible values of the original data type (e.g., float to int)
• Widening conversions: When a conversion expands the possible values of the original type in the new data type (e.g., int to float).

Type Conversions: Mixed Mode

• A mixed-mode expression mixes different types.
• Coercions are implicit type conversions from one type to another which are commonly used in programming languages.
• An added concern is that implicit conversions lower the ability of a compiler to detect some potential type errors.
• In many languages, numeric types are implicitly converted using widening conversion to fit the intended computation.

Explicit Type Conversions

• Explicit type conversions (casting) are used in C-based languages to explicitly change the data type.

Type Conversions: Errors in Expressions

• Inherent limitations of arithmetic, like division by zero, or overflow issues.
• These issues are usually silently handled by the runtime environment.

Relational and Boolean Expressions

• Relational expressions utilize relational operators on operands of different types.
• The outcome of such comparisons is typically represented as Boolean values.
• Operator symbols for relational comparisons may vary between languages, though they generally mean the same thing!

Relational and Boolean Expressions: No Boolean Type in C

• C does not have a distinct Boolean type, using integers (0 for false, non-zero for true) instead.
• Relational expressions like a<b<c sometimes yield unexpected results in C due to the lack of boolean type or short-circuit evaluation, the way operators are applied one at a time.

Relational and Boolean Expressions: Operator Precedence

• The relative precedence of operators, especially those that take on similar roles and overlap in languages like C, needs to be considered.

Short Circuit Evaluation

• Short-circuit evaluation is a method of evaluating expressions where further evaluation is unnecessary, potentially saving computational resources, once sufficient information is gathered to know the result.

Short Circuit Evaluation (continued)

• The evaluation order in situations where short circuiting is possible is important; the outcome could be different and potentially lead to errors like segmentation faults or incorrect results.

Assignment Statements

• Assignment statements use a special syntax which uses assignment operators to set a variable value to a given expression that has a value.
• Examples of such operators include the simple equals sign (=) and the compounded-assignment operator (+= , -=, etc).

Assignment Statements: Conditional Targets

• Certain languages offer conditional assignments, enabling short forms for conditional statements and assignment.

Assignment Statements: Compound Assignment Operators

• Compound assignment operators are shorthand notations adopted from other languages to shorten assignment operations when using previously computed values for further operations.

Assignment Statements: Unary Assignment Operators

• Certain languages allow combined assignment operations, like those including increment or decrement operations as part of the assignment.

Assignment as an Expression

• Assignment statements produce a result, which can also be used as part of larger expressions and larger programs.

Mixed-Mode Assignment

• Mixed-mode assignment can occur when different data types are involved in an assignment statement, and how these are handled vary between programming languages.