Box pointer in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using Box pointer?

Consider the following Rust program that uses a Box pointer. What will it print when run?

Rust

fn main() {
    let b = Box::new(5);
    println!("{}", *b + 10);
}

A Compilation error

B 5

C 10

D 15

💡 Hint

Remember that Box stores the value on the heap and you need to dereference it to get the value.

The Box pointer b holds the value 5 on the heap. Using *b dereferences it to 5, then adding 10 results in 15.

❓ Predict Output

intermediate

What happens when you try to move a Box pointer?

What will be the output or result of this Rust code?

Rust

fn main() {
    let b1 = Box::new(7);
    let b2 = b1;
    println!("{}", *b1);
    println!("{}", *b2);
}

A 7

B Runtime panic

C Compilation error due to use of moved value

D 0

💡 Hint

Box pointers have ownership semantics. Moving them invalidates the original variable.

When b1 is moved to b2, b1 is no longer valid. Using b1 after move causes a compile-time error.

🔧 Debug

advanced

Why does this Box pointer code cause a compilation error?

Identify the error in this Rust code and what causes it.

Rust

fn main() {
    let b = Box::new(10);
    let r1 = &b;
    let r2 = &mut b;
    println!("{} {}", r1, r2);
}

A Cannot borrow `b` as mutable because it is also borrowed as immutable

B Cannot borrow `b` as immutable because it is also borrowed as mutable

C Box pointer cannot be borrowed

D No error, prints '10 10'

💡 Hint

Rust enforces borrowing rules: you cannot have mutable and immutable borrows at the same time.

The code tries to borrow `b` immutably and mutably at the same time, which Rust forbids.

❓ Predict Output

advanced

What is the output of this recursive Box pointer example?

What will this Rust program print?

Rust

enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn main() {
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
    match list {
        List::Cons(x, box List::Cons(y, box List::Nil)) => println!("{} {}", x, y),
        _ => println!("No match"),
    }
}

A No match

B 1 2

C Compilation error

D Runtime panic

💡 Hint

Pattern matching with Box requires unboxing with `box` keyword.

The pattern matches the nested Box structure correctly and prints the two values 1 and 2.

🧠 Conceptual

expert

Why use Box pointer in Rust for recursive types?

Which is the main reason to use Box pointer for recursive data types in Rust?

A To allocate recursive data on the heap and have a known size for the enum

B To improve runtime speed by avoiding heap allocation

C To allow multiple ownership of the recursive data

D To automatically clone the recursive data when copied

💡 Hint

Rust needs to know the size of types at compile time. Recursive types without indirection have unknown size.

Box allocates data on the heap, giving the enum a fixed size pointer, enabling recursive types to compile.