Operators & Expressions: Types, Precedence, Bitwise & Conditional Logic

TAKEAWAYS:

• Operators in C are classified by utility (arithmetic, relational, logical, bitwise, etc.) and operand count (unary, binary, ternary).
• Precedence rules dictate evaluation order; parentheses override defaults.
• Bitwise operators (&, |, ^, ~, <<, >>) manipulate individual bits for memory efficiency (e.g., flags, compression).
• The conditional operator (?:) is a shorthand for if-else in expressions.
• Side effects (e.g., i++ in expressions) can lead to undefined behavior if misused.
• sizeof returns the size in bytes of a variable or type, critical for dynamic memory allocation.

---

---

1. Introduction to Operators

Operators in C are symbols that perform operations on variables and values. They are the building blocks of expressions, which combine variables, operators, and literals to produce a result.

Classification of Operators

Operators are categorized based on their utility (function) and number of operands they require:

---

2. Arithmetic Operators

Arithmetic operators perform mathematical operations. They include:

• Binary operators: +, -, *, /, % (modulus)
• Unary operators: ++ (increment), -- (decrement)

Example: Modulus Operator (%)

The modulus operator returns the remainder of division.

#include <stdio.h>
int main() {
    int a = 10, b = 3;
    printf("Remainder: %d\n", a % b); // Output: 1
    return 0;
}

Trace:

Real-world use in Nepal:

• Ncell’s call duration billing: If a call lasts 10 minutes and the rate is 3 minutes per unit, the extra charge is calculated as 10 % 3 = 1 (extra minute).
• NEPSE stock trading: If a trader buys 10 shares and sells 3, the remaining shares are 10 % 3 = 1.

---

3. Relational Operators

Relational operators compare two values and return 1 (true) or 0 (false).

Example: Checking Even/Odd

#include <stdio.h>
int main() {
    int num = 7;
    if (num % 2 == 0)
        printf("Even\n");
    else
        printf("Odd\n"); // Output: Odd
    return 0;
}

---

4. Logical Operators

Logical operators combine boolean expressions.

Example: Multiple Conditions

#include <stdio.h>
int main() {
    int age = 20, hasLicense = 1;
    if (age >= 18 && hasLicense)
        printf("Eligible to drive\n"); // Output: Eligible
    return 0;
}

Real-world use in Nepal:

• eSewa’s transaction approval: A payment is processed only if:
  • balance >= amount AND account is active.
  • Logical AND (&&) ensures both conditions are met.

---

5. Bitwise Operators

Bitwise operators manipulate individual bits of integers. They are faster than arithmetic operations and used in:

• Memory optimization (e.g., flags in structures).
• Cryptography (e.g., XOR operations).
• Graphics programming (e.g., pixel manipulation).

Example: Setting a Flag

#include <stdio.h>
int main() {
    int flags = 0b0000; // Binary literal (C99)
    flags |= 0b0010;    // Set the 2nd bit (value = 2)
    printf("Flags: %d\n", flags); // Output: 2
    return 0;
}

Trace:

Real-world use in Nepal:

• Khalti’s transaction status: A transaction may have multiple flags (e.g., 0b0001 = pending, 0b0010 = failed). Using bitwise OR (|) updates the status:

  int status = 0b0001; // Pending
  status |= 0b0010;    // Now: 0b0011 (Pending + Failed)
  

---

6. Assignment Operators

Assignment operators assign values to variables. The compound assignment operators (+=, -=, etc.) combine an operation with assignment.

Example: Compound Assignment

#include <stdio.h>
int main() {
    int x = 5;
    x += 3; // Equivalent to x = x + 3
    printf("x = %d\n", x); // Output: 8
    return 0;
}

---

7. Conditional (Ternary) Operator (?:)

The ternary operator is a shorthand for if-else in expressions. Syntax:

condition ? expression1 : expression2;

Example: Maximum of Two Numbers

#include <stdio.h>
int main() {
    int a = 10, b = 20;
    int max = (a > b) ? a : b;
    printf("Max: %d\n", max); // Output: 20
    return 0;
}

Real-world use in Nepal:

• Pathao’s fare calculation: If distance <= 2km, fare = 100 NPR; else, fare = 150 NPR.

  int fare = (distance <= 2) ? 100 : 150;
  

---

8. Special Operators

(a) sizeof Operator

Returns the size in bytes of a variable or data type.

#include <stdio.h>
int main() {
    printf("Size of int: %zu bytes\n", sizeof(int)); // Typically 4
    printf("Size of float: %zu bytes\n", sizeof(float)); // Typically 4
    return 0;
}

Real-world use in Nepal:

• Bank loan calculations: If a bank stores 10,000 customer records, and each record is sizeof(struct Customer) = 100 bytes, total memory needed is 10,000 * 100 = 1,000,000 bytes.

(b) Comma Operator (,)

Evaluates expressions left to right and returns the last value.

#include <stdio.h>
int main() {
    int a = (5, 10, 15); // Returns 15
    printf("a = %d\n", a); // Output: 15
    return 0;
}

---

9. Operator Precedence and Associativity

Operators have precedence (evaluation order) and associativity (left-to-right or right-to-left).

Example: Precedence in Action

#include <stdio.h>
int main() {
    int a = 5, b = 3, c = 2;
    int result = a + b * c; // Multiplication first (6), then addition (11)
    printf("Result: %d\n", result); // Output: 11
    return 0;
}

Mermaid Diagram: Operator Precedence Flow

---

10. Side Effects and Undefined Behavior

• Side effects occur when an operator modifies a variable (e.g., i++ in x = i++ + 1).
• Undefined behavior happens when side effects interfere with evaluation order (e.g., modifying a variable twice in one expression).

Bad Example (Undefined Behavior):

int x = 5;
int y = x++ + ++x; // Undefined! (x is modified twice)

Correct Way:

int x = 5;
int y = x + 1; // Safe
x++;

---

11. Swapping Without a Temporary Variable

A common interview question: Swap two numbers without a third variable using arithmetic or bitwise operations.

Method 1: Arithmetic (Using + and -)

#include <stdio.h>
int main() {
    int a = 5, b = 10;
    printf("Before swap: a = %d, b = %d\n", a, b);
    a = a + b; // 15
    b = a - b; // 5
    a = a - b; // 10
    printf("After swap: a = %d, b = %d\n", a, b); // Output: 10, 5
    return 0;
}

Trace:

Real-world use in Nepal:

• Daraz’s order processing: If two orders have IDs 5 and 10, swapping them without a temp variable avoids extra memory usage in high-throughput systems.

Method 2: Bitwise XOR (No Arithmetic Overflow)

#include <stdio.h>
int main() {
    int a = 5, b = 10;
    printf("Before swap: a = %d, b = %d\n", a, b);
    a = a ^ b; // 15 (0101 ^ 1010 = 1111)
    b = a ^ b; // 5  (1111 ^ 1010 = 0101)
    a = a ^ b; // 10 (1111 ^ 0101 = 1010)
    printf("After swap: a = %d, b = %d\n", a, b); // Output: 10, 5
    return 0;
}

Trace:

---

12. Evaluating Complex Expressions

Problem: Calculate $5x\sqrt{y^2}+5$ for $x=3$, $y=4$. Solution:

#include <stdio.h>
#include <math.h>
int main() {
    int x = 3, y = 4;
    double result = 5 * x * sqrt(y * y) + 5;
    printf("Result: %.2f\n", result); // Output: 65.00
    return 0;
}

Trace:

Real-world use in Nepal:

• NTC’s electricity billing: If a consumer uses $x=10$ units and the rate is $5\times \sqrt{y^2}$ (where $y$ is demand factor), the bill is calculated similarly.

---

In the Real World

1. Khalti’s Transaction Flags

   • Idea Used: Bitwise operators (&, |, ^).
   • How? Khalti uses bitmasking to store multiple transaction states (e.g., 0b0001 = pending, 0b0010 = failed). A single int can represent multiple flags efficiently.
   • Example:

     int status = 0b0001; // Pending
     status |= 0b0010;    // Now: 0b0011 (Pending + Failed)
     

2. Ncell’s Call Duration Calculation

   • Idea Used: Modulus operator (%).
   • How? If a call lasts 10 minutes and billing is per 3-minute unit, the extra charge is 10 % 3 = 1 minute.
   • Example:

     int minutes = 10, unit = 3;
     int extra = minutes % unit; // 1
     

3. Pathao’s Dynamic Fare Adjustment

   • Idea Used: Ternary operator (?:).
   • How? If distance <= 2km, fare = 100 NPR; else, fare = 150 NPR.
   • Example:

     int fare = (distance <= 2) ? 100 : 150;
     

4. Bank Loan Interest Calculation

   • Idea Used: Arithmetic operators (*, /).
   • How? Simple interest is calculated as: $$\text{Interest}=P\times R\times T/100$$ where $P$ = principal, $R$ = rate, $T$ = time.
   • Example:

     float interest = (principal * rate * time) / 100;
     

---

Exam Tip

1. Operator Precedence is Critical

   • Always use parentheses to clarify intent. For example:
     • Correct: (a + b) * c
     • Ambiguous: a + b * c (multiplication has higher precedence).
   • Exam Pitfall: Forgetting precedence leads to wrong answers. Example:

     int x = 2 + 3 * 4; // x = 14 (not 20)
     

2. Bitwise Operators are High-Weightage

   • Questions often ask for bitwise AND/OR/XOR operations or flag manipulation.
   • Example Question: "Given a = 5 (0101) and b = 3 (0011), compute a & b, a | b, and a ^ b."

3. Swapping Without Temp Variable

   • A common 5-mark question. Know both arithmetic and bitwise methods.
   • Exam Tip: Show binary traces for bitwise swapping to get full marks.

4. sizeof Operator

   • Often tested with structures or arrays. Example: "Write a program to find the size of an array of 10 integers."

     int arr[10];
     printf("Size: %zu bytes\n", sizeof(arr)); // Typically 40 (10 * 4)
     

5. Side Effects and Undefined Behavior

   • Avoid modifying a variable twice in one expression (e.g., x = ++x + 1).
   • Exam Tip: If asked to explain undefined behavior, cite:
     • Modifying a variable multiple times in one expression.
     • Unsequenced modifications (e.g., i++ and i-- in the same statement).

6. Ternary Operator Shortcuts

   • Replace if-else with ?: where possible. Example:

     // Instead of:
     if (x > y) max = x; else max = y;
     // Use:
     int max = (x > y) ? x : y;
     

7. Real-World Applications

   • Expect 1-2 questions linking operators to real-world scenarios (e.g., billing, flags, swapping).
   • Example: "How would you use bitwise operators to optimize memory in a system storing user permissions?"

---