# Unit 2: Arithmetic Expressions and Conditional Branching ## 2.1 Arithmetic Expressions and Precedence ### Operators * **Arithmetic Operators**: `+`, `-`, `*`, `/`, `%` (modulo) * **Relational Operators**: `==`, `!=`, `>`, `<`, `>=`, `<=` (evaluate to **0 (false)** or **1 (true)**) * **Logical Operators**: * `&&` (Logical AND) * `||` (Logical OR) * `!` (Logical NOT) * **Bitwise Operators**: * `&` (Bitwise AND) * `|` (Bitwise OR) * `^` (Bitwise XOR) * `~` (Bitwise NOT) * `<<` (Left Shift) * `>>` (Right Shift) * **Assignment Operator**: `=` (assigns value to a variable) * Shorthand assignment operators: `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=` ### Expressions * An expression is a combination of operands and operators that evaluates to a single value. * **Numeric Operands**: Integers, floating-point numbers. * **Mixed Operands**: Operations involving different data types (e.g., `int` and `float`). * **Type Conversion**: * **Implicit (Coercion)**: Automatic conversion by the compiler (e.g., `int` to `float` in `float + int`). * **Explicit (Casting)**: Programmer-specified conversion using `(type) variable`. * **Example**: `(int) float_variable` ### Operator Precedence and Associativity * **Precedence**: Determines the order in which operators are evaluated in an expression. Higher precedence operators are evaluated first. * **Associativity**: Determines the order of evaluation when operators have the same precedence. * Left-to-right: `a - b + c` evaluated as `(a - b) + c`. * Right-to-left: Assignment operator (`a = b = c`) evaluated as `a = (b = c)`. **[Table: Operator Precedence and Associativity (Example - C language)]** This table is crucial for understanding how complex expressions are resolved and is frequently tested. It helps in predicting the output of expressions. | Precedence Level | Operator | Description | Associativity | | :--------------- | :------------------- | :----------------- | :------------ | | 1 (Highest) | `()` | Parentheses | | | 2 | `!`, `~`, `++`, `--` | Unary, Logical NOT | Right-to-left | | 3 | `*`, `/`, `%` | Multiplicative | Left-to-right | | 4 | `+`, `-` | Additive | Left-to-right | | 5 | `<<`, `>>` | Shift | Left-to-right | | 6 | `<`, `<=`, `>`, `>=` | Relational | Left-to-right | | 7 | `==`, `!=` | Equality | Left-to-right | | 8 | `&` | Bitwise AND | Left-to-right | | 9 | `^` | Bitwise XOR | Left-to-right | | 10 | `|` | Bitwise OR | Left-to-right | | 11 | `&&` | Logical AND | Left-to-right | | 12 | `||` | Logical OR | Left-to-right | | 13 | `?:` | Ternary Operator | Right-to-left | | 14 | `=`, `+=`, etc. | Assignment | Right-to-left | | 15 (Lowest) | `,` | Comma Operator | Left-to-right | ## 2.2 Conditional Branching * Allows programs to execute different blocks of code based on certain conditions. ### `if` Statement * Executes a block of code only if a specified condition is true. ```c if (condition) { // code to execute if condition is true } ``` * **`if-else` Statement**: * Executes one block if the condition is true, and another block if it is false. ```c if (condition) { // code if true } else { // code if false } ``` ### `switch` Statement * Selects one of many code blocks to be executed. Useful for comparing a single variable against multiple constant values. * Requires a **`case`** label and an optional **`default`** label. * **`break`** statement is essential to exit the `switch` block after a match. * If `break` is omitted, execution "falls through" to the next `case`. ```c switch (expression) { case constant_value1: // code for case 1 break; case constant_value2: // code for case 2 break; default: // code if no case matches } ``` ### Nesting `if` and `else` * Placing an `if-else` statement inside another `if-else` statement. * Allows for complex decision-making structures. * **Ambiguity**: The `else` clause is associated with the nearest preceding `if` that does not have a matching `else`. ```c if (condition1) { if (condition2) { // code } else { // code } } else { // code } ``` ### Nesting `switch` * A `switch` statement can be placed inside another `switch` statement. * Used for hierarchical or multi-dimensional conditional logic. ```c switch (outer_expression) { case 'A': switch (inner_expression) { case 1: // code break; // ... other inner cases } break; // ... other outer cases } ``` **[Diagram: Flowchart for if-else statement]** This flowchart visually represents the decision-making process of an `if-else` statement, making it easier to understand program control flow and how conditions dictate execution paths. It is a common way to explain conditional logic. **[Diagram: Flowchart for switch statement]** This flowchart illustrates the branching logic of a `switch` statement, showing how an expression is evaluated against multiple constant values to select a specific execution path. It's useful for visualizing the selection process.