Operator precedence in C++

Introduction

Operator precedence tells the computer which math or logic operation to do first when there are many in one line.

When you write math expressions with +, -, *, / together.

When you combine conditions using &&, ||, and ! in if statements.

When you mix assignment (=) with other operations in one line.

When you want to avoid mistakes in complex calculations.

When you want to make your code easier to read by knowing what happens first.

Syntax

C++

expression with multiple operators, e.g. a + b * c - d / e

Operators like * and / have higher precedence than + and -.

Use parentheses () to change the order and make it clear.

Examples

Multiplication (*) happens before addition (+), so 3*4=12, then 2+12=14.

C++

int result = 2 + 3 * 4;

Parentheses change order: 2+3=5 first, then 5*4=20.

C++

int result = (2 + 3) * 4;

&& has higher precedence than ||, so false && false = false, then true || false = true.

C++

bool check = true || false && false;

Parentheses first: true || false = true, then true && false = false.

C++

bool check = (true || false) && false;

Sample Program

This program shows how operator precedence affects math and logic results. Multiplication happens before addition. Logical AND happens before OR. Parentheses change the order.

C++

#include <iostream>

int main() {
    int a = 5, b = 10, c = 2;
    int result1 = a + b * c;  // 5 + (10*2) = 25
    int result2 = (a + b) * c; // (5+10)*2 = 30

    bool val1 = true || false && false; // true || (false && false) = true
    bool val2 = (true || false) && false; // (true || false) && false = false

    std::cout << "result1: " << result1 << "\n";
    std::cout << "result2: " << result2 << "\n";
    std::cout << std::boolalpha;
    std::cout << "val1: " << val1 << "\n";
    std::cout << "val2: " << val2 << "\n";

    return 0;
}

Important Notes

Remember: multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-).

Logical AND (&&) has higher precedence than logical OR (||).

Use parentheses to make your code clear and avoid mistakes.

Summary

Operator precedence decides which operation runs first in an expression.

Use parentheses to control or clarify the order of operations.

Knowing precedence helps avoid bugs and makes code easier to understand.

Practice

1. Which operator has the highest precedence in the expression 3 + 4 * 5?

easy

A. Addition (+)

B. Subtraction (-)

C. Multiplication (*)

D. Division (/)

Solution

1. Step 1: Identify operators in the expression

   The expression has addition (+) and multiplication (*).

2. Step 2: Recall operator precedence rules

   Multiplication (*) has higher precedence than addition (+), so it is evaluated first.

3. Final Answer:

   Multiplication (*) -> Option C

4. Quick Check:

   Multiplication before addition = Multiplication (*) [OK]

Hint: Multiplication and division come before addition and subtraction [OK]

Common Mistakes:

• Thinking addition runs before multiplication
• Ignoring operator precedence rules
• Assuming left-to-right always applies

2. Which of the following expressions is syntactically correct in C++?

easy

A. int x = 5 + (3 * 2);

B. int x = 5 + 3 *;

C. int x = 5 + *3;

D. int x = 5 + 3 * 2);

Solution

1. Step 1: Check each expression for syntax errors

   int x = 5 + *3; has an invalid use of * before 3. int x = 5 + 3 *; ends with * which is incomplete. int x = 5 + 3 * 2); has an unmatched closing parenthesis.

2. Step 2: Confirm correct syntax

   int x = 5 + (3 * 2); uses parentheses correctly and has valid operators and operands.

3. Final Answer:

   int x = 5 + (3 * 2); -> Option A

4. Quick Check:

   Valid syntax with parentheses and operators = int x = 5 + (3 * 2); [OK]

Hint: Check for balanced parentheses and proper operator placement [OK]

Common Mistakes:

• Misplacing operators without operands
• Unbalanced parentheses
• Using operators incorrectly

3. What is the output of the following code?

int a = 2, b = 3, c = 4;
int result = a + b * c / a - b;
std::cout << result;

medium

A. 5

B. 2

C. 4

D. 3

Solution

1. Step 1: Evaluate multiplication and division first

   b * c = 3 * 4 = 12; then 12 / a = 12 / 2 = 6.

2. Step 2: Evaluate addition and subtraction left to right

   a + 6 = 2 + 6 = 8; then 8 - b = 8 - 3 = 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Multiplication/division before addition/subtraction = 5 [OK]

Hint: Do * and / before + and -, left to right [OK]

Common Mistakes:

• Adding before multiplying
• Ignoring division precedence
• Calculating subtraction before addition

4. Find the error in the following code snippet:

int x = 10;
int y = 5;
int z = x + y * / 2;
std::cout << z;

medium

A. Division by zero error

B. Syntax error due to misplaced operator

C. Logical error in calculation

D. No error, code runs fine

Solution

1. Step 1: Analyze the expression for syntax correctness

   The expression x + y * / 2 has two operators (*) and (/) together without an operand, which is invalid syntax.

2. Step 2: Confirm the error type

   This causes a syntax error because the compiler cannot parse the expression correctly.

3. Final Answer:

   Syntax error due to misplaced operator -> Option B

4. Quick Check:

   Invalid operator sequence causes syntax error [OK]

Hint: Check operator placement for missing operands [OK]

Common Mistakes:

• Assuming code runs despite syntax errors
• Confusing syntax error with runtime error
• Ignoring operator adjacency rules

5. Consider the expression int result = 10 - 3 * 2 + 4 / 2;. How can you change it using parentheses to make addition happen before multiplication and division?

hard

A. int result = 10 - ((3 * 2) + 4) / 2;

B. int result = ((10 - 3) * 2 + 4) / 2;

C. int result = 10 - ((3 * 2) + (4 / 2));

D. int result = 10 - (3 * (2 + 4)) / 2;

Solution

1. Step 1: Understand original precedence

   Original expression evaluates multiplication and division before addition and subtraction.

2. Step 2: Use parentheses to force addition before multiplication/division

   int result = 10 - (3 * (2 + 4)) / 2; groups (2 + 4) first, so addition happens before multiplication and division.

3. Final Answer:

   int result = 10 - (3 * (2 + 4)) / 2; -> Option D

4. Quick Check:

   Parentheses change order to add before multiply/divide [OK]

Hint: Use parentheses to group additions before other ops [OK]

Common Mistakes:

• Misplacing parentheses changing meaning
• Not grouping addition properly
• Assuming left-to-right overrides precedence