Ownership with smart pointers in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using Rc?

Consider the following Rust code using Rc smart pointers. What will be printed?

Rust

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);
    let b = Rc::clone(&a);
    println!("{}", Rc::strong_count(&a));
}

A 1

B Compilation error

C 2

D 0

💡 Hint

Think about how many owners the Rc pointer has after cloning.

Cloning an Rc pointer increases the reference count. Here, a and b both own the data, so the count is 2.

❓ Predict Output

intermediate

What happens when you try to mutate data inside an Rc without RefCell?

What error or output will this Rust code produce?

Rust

use std::rc::Rc;

fn main() {
    let data = Rc::new(5);
    let mut_ref = Rc::get_mut(&mut Rc::clone(&data));
    match mut_ref {
        Some(v) => *v = 10,
        None => println!("Cannot get mutable reference"),
    }
}

A Cannot get mutable reference

B Compilation error due to mutability

C Program panics at runtime

D Value is changed to 10

💡 Hint

Rc allows mutation only if there is exactly one owner.

Rc::get_mut returns None if there are multiple owners. Here, cloning increases owners, so mutable access is denied.

🔧 Debug

advanced

Why does this code cause a runtime panic with RefCell?

Examine the Rust code below. Why does it panic at runtime?

Rust

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);
    let _borrow1 = data.borrow_mut();
    let _borrow2 = data.borrow_mut();
}

A Because multiple mutable borrows are not allowed simultaneously

B Because RefCell does not allow any borrows

C Because the data is immutable

D Because borrow_mut returns an error that is not handled

💡 Hint

Think about Rust's borrowing rules enforced at runtime by RefCell.

RefCell enforces borrowing rules at runtime. Two simultaneous mutable borrows cause a panic.

🧠 Conceptual

advanced

What is the main difference between Box and Rc in Rust?

Choose the best explanation of the difference between Box and Rc smart pointers.

A Box automatically clones data; Rc does not

B Box allows multiple owners; Rc allows only one owner

C Box is for stack allocation; Rc is for heap allocation

D Box provides single ownership and heap allocation; Rc provides shared ownership with reference counting

💡 Hint

Think about ownership and how many owners each pointer type supports.

Box has single ownership and stores data on the heap. Rc allows multiple owners by counting references.

❓ Predict Output

expert

What is the output of this code mixing Rc and RefCell?

Analyze the following Rust code. What will it print?

Rust

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    let data = Rc::new(RefCell::new(10));
    let data_clone = Rc::clone(&data);
    *data_clone.borrow_mut() += 5;
    println!("{}", data.borrow());
}

A 10

B 15

C Compilation error due to borrow rules

D Runtime panic due to multiple mutable borrows

💡 Hint

Consider how Rc and RefCell work together to allow mutation.

Rc allows shared ownership, and RefCell allows interior mutability. The value is changed to 15.