Scope of variables in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the scope of a variable in Rust?

The scope of a variable in Rust is the part of the program where the variable is valid and can be accessed. It usually starts from where the variable is declared and ends at the end of the enclosing block.

beginner

What happens if you try to use a variable outside its scope in Rust?

Rust will give a compile-time error because the variable is not accessible outside its scope. This helps prevent bugs and keeps code safe.

intermediate

How does shadowing affect variable scope in Rust?

Shadowing allows you to declare a new variable with the same name inside a new scope. The new variable hides the old one within that scope, but the old variable is still accessible outside it.

beginner

Consider this Rust code:<br><pre>let x = 5;<br>{<br>  let x = 10;<br>  println!("{}", x);<br>}<br>println!("{}", x);</pre><br>What will be printed?

Inside the block, 10 is printed because the inner x shadows the outer x. Outside the block, 5 is printed because the outer x is still valid there.

beginner

Why is understanding variable scope important in Rust?

Understanding scope helps you write safer and cleaner code. It prevents accidental use of variables where they don't belong and helps manage memory and resources efficiently.

What defines the scope of a variable in Rust?

A The block where the variable is declared

B Anywhere in the program

C Only inside functions

D Only inside loops

The scope of a variable is the block where it is declared, including any inner blocks.

What happens if you declare a variable with the same name inside an inner block in Rust?

A The inner variable shadows the outer one

B It causes a compile error

C Both variables merge

D The outer variable is deleted

The inner variable shadows the outer one within the inner block.

Can you access a variable declared inside a block from outside that block in Rust?

A Yes, always

B Only if it is mutable

C Only if you use unsafe code

D No, it is out of scope

Variables declared inside a block are not accessible outside that block.

What will this Rust code print?
let a = 3;
{
let a = 7;
println!("{}", a);
}
println!("{}", a);

A 3 and 3

B 7 and 7

C 7 and 3

D 3 and 7

Inside the block, 7 is printed (inner a). Outside, 3 is printed (outer a).

Why does Rust enforce strict variable scope rules?

A To make code run faster

B To prevent bugs and ensure safety

C To allow variables to be global

D To make code longer

Strict scope rules help prevent bugs and keep code safe and predictable.

Explain what variable scope means in Rust and why it matters.

Think about where a variable can be used and why Rust limits this.

Describe how shadowing works in Rust and give a simple example.

Consider declaring the same variable name twice in nested blocks.

Practice

1. What does the scope of a variable in Rust determine?

easy

A. Where the variable can be accessed or used

B. The type of the variable

C. The value stored in the variable

D. The memory size of the variable

Solution

1. Step 1: Understand the meaning of scope

   Scope means the part of the code where a variable is valid and can be used.

2. Step 2: Identify what scope controls

   Scope controls access to the variable, not its type, value, or memory size.

3. Final Answer:

   Where the variable can be accessed or used -> Option A

4. Quick Check:

   Scope = access area [OK]

Hint: Scope means where you can use the variable [OK]

Common Mistakes:

• Confusing scope with variable type
• Thinking scope controls variable value
• Mixing scope with memory size

2. Which of the following is the correct way to declare a variable inside a block in Rust?

easy

A. var x = 5;

B. let x = 5;

C. int x = 5;

D. declare x = 5;

Solution

1. Step 1: Recall Rust variable declaration syntax

   Rust uses let keyword to declare variables.

2. Step 2: Check each option

   Only let x = 5; is valid Rust syntax; others are from other languages or invalid.

3. Final Answer:

   let x = 5; -> Option B

4. Quick Check:

   Rust variables start with let [OK]

Hint: Rust variables start with let keyword [OK]

Common Mistakes:

• Using var instead of let
• Using type declarations like int
• Using declare keyword

3. What will be the output of this Rust code?

fn main() {
    let x = 10;
    {
        let x = 20;
        println!("{}", x);
    }
    println!("{}", x);
}

medium

A. 10\n10

B. 20\n20

C. 10\n20

D. 20\n10

Solution

1. Step 1: Identify variable shadowing inside inner block

   Inside the inner block, x is redefined as 20, shadowing outer x.

2. Step 2: Trace the print statements

   First print shows inner x = 20; second print shows outer x = 10.

3. Final Answer:

   20 10 -> Option D

4. Quick Check:

   Inner shadow = 20, outer original = 10 [OK]

Hint: Inner block shadows outer variable [OK]

Common Mistakes:

• Ignoring shadowing and printing outer value twice
• Assuming inner variable changes outer variable
• Confusing print order

4. Identify the error in this Rust code snippet:

fn main() {
    {
        let y = 5;
    }
    println!("{}", y);
}

medium

A. Variable y is used outside its scope

B. Missing semicolon after let y = 5

C. println! macro is misspelled

D. No error, code runs fine

Solution

1. Step 1: Check where y is declared and used

   Variable y is declared inside inner block and goes out of scope after block ends.

2. Step 2: Analyze usage of y outside block

   Using y in println! outside block causes error because y is not visible there.

3. Final Answer:

   Variable y is used outside its scope -> Option A

4. Quick Check:

   Use inside scope only [OK]

Hint: Variables vanish outside their block scope [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming println! is wrong
• Ignoring variable scope rules

5. Consider this Rust code:

fn main() {
    let mut count = 0;
    for i in 0..3 {
        let count = count + i;
        println!("{}", count);
    }
    println!("Final count: {}", count);
}

What will be the output and why?

hard

A. 0\n1\n2\nFinal count: 6

B. 0\n1\n2\nFinal count: 2

C. 0\n1\n2\nFinal count: 0

D. Compilation error due to variable shadowing

Solution

1. Step 1: Understand variable shadowing inside the loop

   Inside the loop, count is shadowed by a new variable count equal to outer count plus i. Outer count remains unchanged.

2. Step 2: Trace loop iterations and prints

   Iterations: i=0 -> inner count=0, print 0; i=1 -> inner count=1, print 1; i=2 -> inner count=2, print 2. Outer count stays 0.

3. Step 3: Final print shows outer count

   After loop, outer count is still 0, so prints "Final count: 0".

4. Final Answer:

   0 1 2 Final count: 0 -> Option C

5. Quick Check:

   Shadowing hides outer count, outer unchanged [OK]

Hint: Shadowing inside loop doesn't change outer variable [OK]

Common Mistakes:

• Assuming outer count changes inside loop
• Confusing shadowing with mutation
• Expecting sum accumulation in outer count