RefCell overview in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this RefCell borrow example?

Consider this Rust code using RefCell. What will it print?

Rust

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);
    {
        let borrow1 = data.borrow();
        println!("First borrow: {}", *borrow1);
    }
    {
        let mut borrow2 = data.borrow_mut();
        *borrow2 += 10;
        println!("Modified inside borrow_mut: {}", *borrow2);
    }
    println!("Final value: {}", data.borrow());
}

A

First borrow: 5
Modified inside borrow_mut: 15
Final value: 15

B

First borrow: 5
Modified inside borrow_mut: 10
Final value: 10

C

First borrow: 5
Modified inside borrow_mut: 15
Final value: 5

D Compilation error due to multiple borrows

💡 Hint

Remember that borrow() gives an immutable reference and borrow_mut() gives a mutable reference, but they cannot coexist.

The first borrow prints 5. Then the mutable borrow adds 10, making the value 15. The final print shows 15.

🧠 Conceptual

intermediate

What error occurs when borrowing RefCell incorrectly?

What error will this Rust code produce when run? use std::cell::RefCell; fn main() { let data = RefCell::new(10); let _borrow1 = data.borrow(); let _borrow2 = data.borrow_mut(); }

A compile-time borrow checker error

B panic at runtime: already borrowed

C no error, runs fine

D syntax error

💡 Hint

RefCell enforces borrowing rules at runtime, not compile time.

RefCell allows multiple immutable borrows or one mutable borrow. Borrowing mutably while immutable borrow exists causes a runtime panic.

🔧 Debug

advanced

Why does this RefCell code panic at runtime?

Identify the cause of the runtime panic in this code: use std::cell::RefCell; fn main() { let data = RefCell::new(vec![1, 2, 3]); let borrow1 = data.borrow(); data.borrow_mut().push(4); println!("{:?}", borrow1); }

A No panic, code runs fine

B Cannot push to vector inside RefCell

C Immutable borrow is dropped too early

D Mutable borrow while immutable borrow is active causes panic

💡 Hint

Check the order and lifetime of borrows.

The immutable borrow borrow1 is still active when borrow_mut() is called, causing a runtime panic.

📝 Syntax

advanced

Which option correctly creates a RefCell with initial value 42?

Choose the correct Rust code to create a RefCell holding the integer 42.

A let cell = RefCell::new(42);

B let cell = RefCell(42);

C let cell = RefCell::create(42);

D let cell = new RefCell(42);

💡 Hint

Use the standard constructor method for RefCell.

RefCell is created with RefCell::new(value). Other options are invalid syntax or methods.

🚀 Application

expert

How many items are in the vector after this RefCell code runs?

What is the length of the vector inside RefCell after this code executes? use std::cell::RefCell; fn main() { let data = RefCell::new(vec![1, 2]); { let mut borrow_mut = data.borrow_mut(); borrow_mut.push(3); } { let borrow = data.borrow(); println!("Vector contents: {:?}", *borrow); } { let mut borrow_mut = data.borrow_mut(); borrow_mut.push(4); } println!("Length: {}", data.borrow().len()); }

A 2

B 3

C 4

D Compilation error

💡 Hint

Each mutable borrow adds one element to the vector.

Two mutable borrows add 3 and 4 to the vector, starting from [1, 2], so length is 4.