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.