Ownership with smart pointers in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a smart pointer in Rust?

A smart pointer is a data structure that not only holds a value but also has extra metadata and capabilities, like managing memory automatically.

beginner

How does Box<T> help with ownership?

Box<T> stores data on the heap and gives ownership to a single owner, automatically freeing memory when it goes out of scope.

intermediate

What problem does Rc<T> solve?

Rc<T> allows multiple parts of code to share ownership of the same data by keeping a count of references, freeing memory only when the last owner is gone.

intermediate

Why use RefCell<T> with Rc<T>?

RefCell<T> allows mutable borrowing checked at runtime, so you can change data inside an Rc<T> even though Rc<T> itself is immutable.

advanced

What happens if you try to create a reference cycle with Rc<T>?

A reference cycle causes a memory leak because the reference count never reaches zero, so Rust can’t free the memory automatically.

Which smart pointer in Rust allows multiple owners of the same data?

A Rc<T>

B Box<T>

C RefCell<T>

D String

Rc<T> enables multiple owners by reference counting.

What does Box<T> do with the data it owns?

A Stores it on the stack

B Stores it on the heap

C Copies it automatically

D Shares ownership

Box<T> stores data on the heap and owns it exclusively.

Which smart pointer allows mutation checked at runtime inside an immutable owner?

A Vec<T>

B Box<T>

C Rc<T>

D RefCell<T>

RefCell<T> provides interior mutability with runtime borrow checking.

What is a risk of using Rc<T> without care?

A Stack overflow

B Data races

C Reference cycles causing memory leaks

D Compile-time errors

Reference cycles prevent memory from being freed, causing leaks.

When does Rust free the memory owned by a Box<T>?

A When the Box goes out of scope

B When the Box is cloned

C When the program ends

D When the data is copied

Rust frees memory when the Box<T> owner goes out of scope.

Explain how ownership works with Box<T> and why it is useful.

Think about how Box stores data and what happens when it goes out of scope.

Describe the difference between Rc<T> and RefCell<T> and when you might use them together.

One manages how many owners exist, the other allows changing data inside an immutable owner.

Practice

1. Which smart pointer in Rust allows multiple parts of your program to own the same data safely?

easy

A. RefCell

B. Box

C. Rc

D. Arc

Solution

1. Step 1: Understand ownership types

   Box provides unique ownership, Rc allows shared ownership in single-threaded contexts, RefCell allows interior mutability, and Arc is for shared ownership across threads.

2. Step 2: Identify shared ownership in single-threaded code

   Rc is the smart pointer designed for multiple owners in single-threaded programs.

3. Final Answer:

   Rc -> Option C

4. Quick Check:

   Shared ownership = Rc [OK]

Hint: Shared ownership in single-threaded Rust uses Rc [OK]

Common Mistakes:

• Confusing Box with shared ownership
• Thinking RefCell shares ownership
• Mixing Arc with single-threaded Rc

2. Which of the following is the correct way to create a Box smart pointer holding the integer 10?

easy

A. let b = Box::new(10);

B. let b = Box(10);

C. let b = new Box(10);

D. let b = Box::create(10);

Solution

1. Step 1: Recall Box creation syntax

   The correct way to create a Box is using Box::new(value).

2. Step 2: Check each option

   let b = Box::new(10); uses Box::new(10), which is correct. Options A, C, and D use invalid syntax.

3. Final Answer:

   let b = Box::new(10); -> Option A

4. Quick Check:

   Box creation = Box::new(value) [OK]

Hint: Use Box::new(value) to create a Box smart pointer [OK]

Common Mistakes:

• Using Box(10) instead of Box::new(10)
• Trying new Box(10) like other languages
• Using non-existent Box::create method

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

use std::rc::Rc;

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

medium

A. 1

B. 2

C. 5

D. Compilation error

Solution

1. Step 1: Understand Rc cloning

   Cloning an Rc pointer increases the reference count but does not clone the data.

2. Step 2: Count strong references

   Initially, a has a count of 1. After b = Rc::clone(&a), the count becomes 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Rc clone increments count = 2 [OK]

Hint: Rc::clone increases strong_count by 1 [OK]

Common Mistakes:

• Thinking Rc::clone copies data
• Expecting count to remain 1
• Confusing Rc with Box ownership

4. Identify the error in this Rust code using RefCell:

use std::cell::RefCell;

let data = RefCell::new(10);
let r1 = data.borrow_mut();
let r2 = data.borrow_mut();
println!("{} {}", r1, r2);

medium

A. Cannot borrow mutably twice at the same time

B. RefCell cannot hold integers

C. Missing semicolon after borrow_mut()

D. Cannot print RefCell values directly

Solution

1. Step 1: Understand RefCell borrowing rules

   RefCell allows mutable borrowing at runtime but only one mutable borrow at a time.

2. Step 2: Analyze the code

   The code tries to create two mutable borrows r1 and r2 simultaneously, which causes a runtime panic.

3. Final Answer:

   Cannot borrow mutably twice at the same time -> Option A

4. Quick Check:

   RefCell mutable borrow rule = one at a time [OK]

Hint: Only one mutable borrow allowed with RefCell at once [OK]

Common Mistakes:

• Thinking RefCell forbids integers
• Assuming multiple mutable borrows are allowed
• Confusing compile-time and runtime borrow checks

5. You want to create a tree structure where each node can have multiple children and each child can access its parent. Which combination of smart pointers is best to avoid ownership errors?

hard

A. Use Weak for children and Box for parent references

B. Use Box for both children and parent references

C. Use RefCell for children and Rc for parent references

D. Use Rc for children and Weak for parent references

Solution

1. Step 1: Understand ownership in tree structures

   Children own their data, so Rc is used for shared ownership of children nodes.

2. Step 2: Avoid reference cycles

   Parents are referenced by children, but to avoid cycles, parents should be referenced with Weak pointers.

3. Step 3: Combine smart pointers correctly

   Using Rc for children and Weak for parents prevents memory leaks and ownership errors.

4. Final Answer:

   Use Rc for children and Weak for parent references -> Option D

5. Quick Check:

   Tree ownership = Rc children + Weak parents [OK]

Hint: Use Weak for back references to avoid cycles [OK]

Common Mistakes:

• Using Box for parent causes ownership conflicts
• Using Rc for parents causes reference cycles
• Ignoring Weak pointers to break cycles