Operators and Expressions

Operators are symbols that perform operations on variables and values. Expressions combine variables, operators, and values to produce results.

What are Operators?

Operators are special symbols that tell the compiler to perform specific mathematical, logical, or relational operations.

Expressions are combinations of operators, variables, and values that evaluate to a single value.

Types of Operators

1. Arithmetic Operators

Perform mathematical operations.

Example:

int a = 10, b = 3;
int sum = a + b;        // 13
int diff = a - b;       // 7
int product = a * b;    // 30
int quotient = a / b;   // 3 (integer division)
int remainder = a % b;  // 1

Important Notes:

• Integer division truncates (drops decimal part)
• Modulus only works with integers
• Division by zero causes runtime error

2. Assignment Operators

Assign values to variables.

Example:

int x = 10;
x += 5;   // x is now 15
x -= 3;   // x is now 12
x *= 2;   // x is now 24
x /= 4;   // x is now 6

3. Increment and Decrement Operators

Increase or decrease value by 1.

Example:

int a = 5;
int b = ++a;  // a becomes 6, b becomes 6
int c = a++;  // c becomes 6, a becomes 7

int x = 10;
int y = --x;  // x becomes 9, y becomes 9
int z = x--;  // z becomes 9, x becomes 8

4. Relational Operators

Compare two values and return true or false.

Example:

int age = 20;
bool isAdult = age >= 18;      // true
bool isTeen = age < 18;        // false
bool isExactly20 = age == 20;  // true

5. Logical Operators

Combine boolean expressions.

Truth Tables:

AND (&&):

OR (||):

NOT (!):

Example:

int age = 20;
bool hasLicense = true;
bool canDrive = age >= 18 && hasLicense;  // true

int score = 85;
bool passed = score >= 60 || score == 100;  // true

bool isWeekend = false;
bool isWorkday = !isWeekend;  // true

6. Bitwise Operators

Operate on individual bits (advanced topic).

7. Conditional (Ternary) Operator

Shorthand for if-else statements.

Syntax: condition ? value_if_true : value_if_false

Example:

int age = 20;
string status = (age >= 18) ? "Adult" : "Minor";
// status is "Adult"

int max = (a > b) ? a : b;  // Returns larger value

Operator Precedence

Operators are evaluated in a specific order when multiple operators appear in an expression.

Order (highest to lowest):

1. Parentheses ()
2. Unary operators (++, --, !, -)
3. Multiplicative (*, /, %)
4. Additive (+, -)
5. Relational (<, >, <=, >=)
6. Equality (==, !=)
7. Logical AND (&&)
8. Logical OR (||)
9. Assignment (=, +=, etc.)

Example:

int result = 2 + 3 * 4;        // 14 (not 20!)
int result2 = (2 + 3) * 4;      // 20
bool check = 5 > 3 && 2 < 4;    // true

Best Practice: Use parentheses to make precedence clear, even when not necessary.

Type Conversions in Expressions

When different types are used in expressions, C++ performs automatic conversions.

Rules:

1. Smaller types are promoted to larger types
2. int + double → double
3. char + int → int

Example:

int a = 5;
double b = 3.5;
double result = a + b;  // a is converted to double, result is 8.5

Common Expressions

Mathematical Expressions

double area = 3.14159 * radius * radius;  // Circle area
double celsius = (fahrenheit - 32) * 5.0 / 9.0;  // Temperature conversion

Boolean Expressions

bool isValid = age >= 18 && age <= 65;
bool isWeekend = day == 6 || day == 7;
bool isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

String Concatenation

string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName;  // "John Doe"

Best Practices

1. ✅ Use parentheses for clarity, even when not needed
2. ✅ Avoid complex expressions - break into multiple statements
3. ✅ Be careful with integer division - use double if you need decimals
4. ✅ Use meaningful variable names in expressions
5. ✅ Understand operator precedence or use parentheses
6. ✅ Avoid side effects in expressions (like ++ in complex expressions)

Common Mistakes

• ❌ Forgetting that integer division truncates: 5 / 2 = 2 (not 2.5)
• ❌ Using = instead of == in comparisons
• ❌ Confusing && (logical) with & (bitwise)
• ❌ Not understanding operator precedence
• ❌ Modulus with floating-point numbers (only works with integers)

Next Module

In Module 4, we'll learn about Control Flow - how to make decisions with if/else statements and repeat code with loops!