Operator precedence in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is operator precedence in Rust?

Operator precedence determines the order in which parts of an expression are evaluated. Operators with higher precedence are evaluated before those with lower precedence.

beginner

Which operator has higher precedence: multiplication (*) or addition (+)?

Multiplication (*) has higher precedence than addition (+). So in an expression like 2 + 3 * 4, the multiplication happens first.

beginner

How does parentheses affect operator precedence?

Parentheses change the normal precedence by forcing the expression inside them to be evaluated first, regardless of operator precedence.

intermediate

In Rust, which has higher precedence: logical AND (&&) or logical OR (||)?

Logical AND (&&) has higher precedence than logical OR (||). So && operations are evaluated before || in expressions.

intermediate

What happens if operators have the same precedence?

If operators have the same precedence, Rust evaluates them based on their associativity, usually left to right for most operators.

In Rust, which operator is evaluated first in the expression 5 + 4 * 3?

A Addition (+)

B Multiplication (*)

C Both at the same time

D Depends on variable types

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

What does parentheses do in the expression (5 + 4) * 3?

A They have no effect

B They make addition happen after multiplication

C They force addition to happen before multiplication

D They change the variable types

Parentheses force the expression inside to be evaluated first, so 5 + 4 happens before multiplication.

Which operator has higher precedence in Rust: && or ||?

A && (logical AND)

B Depends on the expression

C They have the same precedence

D || (logical OR)

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

If two operators have the same precedence, how does Rust decide which to evaluate first?

A It always evaluates right to left

B Randomly

C Based on variable names

D Based on associativity (usually left to right)

Rust uses associativity rules, usually left to right, to decide evaluation order for operators with the same precedence.

In the expression 10 - 3 - 2, how is the evaluation done?

A (10 - 3) - 2

B 10 - (3 - 2)

C All at once

D Depends on compiler

Subtraction is left-associative, so it evaluates from left to right: (10 - 3) - 2.

Explain operator precedence and how it affects the evaluation of expressions in Rust.

Think about which parts of an expression are calculated first.

Describe how Rust handles operators with the same precedence and give an example.

Consider how expressions like 10 - 3 - 2 are evaluated.

Practice

1. In Rust, which operator has the highest precedence among these: +, *, -, /?

easy

A. Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-).

B. Addition (+) and subtraction (-) have higher precedence than multiplication (*) and division (/).

C. All operators have the same precedence and are evaluated left to right.

D. Subtraction (-) has the highest precedence among all.

Solution

1. Step 1: Recall Rust operator precedence rules

   Multiplication (*) and division (/) operators have higher precedence than addition (+) and subtraction (-).

2. Step 2: Compare given operators

   Among the given operators, * and / are evaluated before + and - in expressions.

3. Final Answer:

   Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-). -> Option A

4. Quick Check:

   *, / > +, - [OK]

Hint: Remember: multiply/divide before add/subtract [OK]

Common Mistakes:

• Thinking addition has higher precedence than multiplication
• Assuming all operators have equal precedence
• Confusing subtraction precedence with multiplication

2. Which of the following Rust expressions is correctly written to add 2 and 3, then multiply the result by 4?

easy

A. 2 + 3 * 4

B. (2 + 3) * 4

C. 2 + (3 * 4)

D. 2 * 3 + 4

Solution

1. Step 1: Understand operator precedence and parentheses

   Multiplication (*) has higher precedence than addition (+), so without parentheses, multiplication happens first.

2. Step 2: Check each expression

   (2 + 3) * 4 uses parentheses to add 2 and 3 first, then multiplies by 4, which matches the requirement.

3. Final Answer:

   (2 + 3) * 4 -> Option B

4. Quick Check:

   Parentheses force addition first [OK]

Hint: Use parentheses to change default order [OK]

Common Mistakes:

• Ignoring parentheses and relying on default precedence
• Misplacing parentheses causing wrong order
• Assuming left-to-right always applies

3. What is the output of this Rust code?

let result = 10 - 4 / 2 + 3 * 2;
println!("{}", result);

medium

A. 13

B. 10

C. 11

D. 14

Solution

1. Step 1: Apply operator precedence to expression

   Division and multiplication happen before addition and subtraction:
   4 / 2 = 2
   3 * 2 = 6

2. Step 2: Calculate left to right with results

   Expression becomes: 10 - 2 + 6
   10 - 2 = 8
   8 + 6 = 14

3. Final Answer:

   14 -> Option D

4. Quick Check:

   */ before +- gives 14 [OK]

Hint: Calculate * and / first, then + and - left to right [OK]

Common Mistakes:

• Doing operations strictly left to right ignoring precedence
• Adding before multiplying
• Miscomputing division or multiplication

4. Identify the error in this Rust expression:

let value = 5 + 3 * / 2;

medium

A. No error, expression is valid

B. Logical error: multiplication should be addition

C. Syntax error due to misplaced operator '/'

D. Runtime error due to division by zero

Solution

1. Step 1: Analyze the expression syntax

   The expression has * / operators together without a number between them, which is invalid syntax in Rust.

2. Step 2: Confirm error type

   This causes a syntax error because Rust expects an operand between operators.

3. Final Answer:

   Syntax error due to misplaced operator '/' -> Option C

4. Quick Check:

   Operators must have operands between them [OK]

Hint: Check for missing operands between operators [OK]

Common Mistakes:

• Assuming expression is valid without checking syntax
• Confusing syntax error with runtime error
• Ignoring operator placement rules

5. Given the Rust expression:

let x = 2 + 3 * 4 - 6 / 3 + (8 - 5) * 2;

What is the correct value of x after evaluation?

hard

A. 18

B. 20

C. 19

D. 21

Solution

1. Step 1: Evaluate parentheses and high precedence operators

   Calculate inside parentheses:
   (8 - 5) = 3
   Then multiplication and division:
   3 * 4 = 12
   6 / 3 = 2
   3 * 2 = 6 (from parentheses result * 2)

2. Step 2: Substitute and calculate addition and subtraction left to right

   Expression becomes: 2 + 12 - 2 + 6
   2 + 12 = 14
   14 - 2 = 12
   12 + 6 = 18

3. Final Answer:

   18 -> Option A

4. Quick Check:

   Parentheses and */ first, then +- left to right [OK]

Hint: Calculate parentheses first, then * and /, then + and - left to right [OK]

Common Mistakes:

• Ignoring parentheses and calculating in wrong order
• Doing addition before multiplication
• Mixing up left-to-right evaluation for + and -