Why smart pointers are needed in Rust - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use smart pointers instead of raw pointers in Rust?

Which reason best explains why Rust uses smart pointers like Box or Rc instead of raw pointers?

A Smart pointers allow direct access to hardware registers without safety checks.

B Smart pointers make the code run faster than raw pointers in all cases.

C Smart pointers automatically manage memory and prevent errors like double free or dangling pointers.

D Smart pointers are used only to make the syntax shorter and simpler.

💡 Hint

Think about what problems can happen if you manually manage memory with raw pointers.

Smart pointers in Rust help manage memory safely by automatically freeing memory when no longer used, avoiding common bugs like double frees or dangling pointers.

❓ Predict Output

intermediate

Output of code using Box smart pointer

What is the output of this Rust code?

Rust

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

A 15

B 10

C Box(10) + 5

D Compilation error

💡 Hint

Remember that Box stores the value on the heap and you can access the value by dereferencing.

The Box smart pointer holds the value 10 on the heap. Using *x dereferences it to 10, then adding 5 gives 15.

❓ Predict Output

advanced

What error occurs with raw pointer misuse?

What error will this Rust code produce?

Rust

fn main() {
    let mut x = 5;
    let r1 = &x as *const i32;
    let r2 = &mut x as *mut i32;
    unsafe {
        *r2 = 10;
        println!("{}", *r1);
    }
}

A Prints 10 without error

B Compilation error due to mutable and immutable borrow

C Runtime undefined behavior due to raw pointer aliasing

D Prints 5 without error

💡 Hint

Raw pointers allow unsafe code but you must be careful with aliasing rules.

This code uses raw pointers and unsafe block. It writes 10 through the mutable pointer and reads through the const pointer. It prints 10 without compile error, but this is unsafe and can cause undefined behavior if misused.

🧠 Conceptual

advanced

Why does Rust prefer smart pointers over garbage collection?

Why does Rust use smart pointers like Rc and Arc instead of a garbage collector?

A Garbage collectors are faster and simpler, so Rust avoids them for performance reasons.

B Smart pointers give precise control over memory without runtime overhead of garbage collection.

C Rust does not support dynamic memory allocation at all.

D Smart pointers automatically parallelize code execution.

💡 Hint

Think about how Rust manages memory without a background process cleaning unused data.

Rust uses smart pointers to manage memory with clear ownership and reference counting, avoiding the runtime cost and unpredictability of garbage collection.

🚀 Application

expert

How many strong references remain after cloning Rc?

Consider this Rust code using Rc smart pointer:

use std::rc::Rc;

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

What number will be printed?

A Compilation error

B 3

C 1

D 2

💡 Hint

Count how many Rc pointers are alive after dropping one.

Initially, a has 1 strong count. Cloning twice makes 3. Dropping b reduces count to 2. So printing strong_count(&a) outputs 2.