Rc pointer in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rc pointer code?

Consider the following Rust code using Rc. What will it print?

Rust

use std::rc::Rc;

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

A 2

B Compilation error

C 0

D 1

💡 Hint

Think about how many Rc pointers point to the same data.

Both a and b point to the same data, so the strong count is 2.

🧠 Conceptual

intermediate

Which statement about Rc pointers is true?

Choose the correct statement about Rc pointers in Rust.

A <code>Rc</code> allows multiple ownership but is not thread-safe.

B <code>Rc</code> allows multiple ownership and is thread-safe.

C <code>Rc</code> allows only single ownership and is thread-safe.

D <code>Rc</code> allows only single ownership and is not thread-safe.

💡 Hint

Think about whether Rc can be shared across threads.

Rc allows multiple ownership but is not safe to share between threads. For thread-safe reference counting, Arc is used.

🔧 Debug

advanced

What error does this Rc code produce?

What error will this Rust code produce?

Rust

use std::rc::Rc;

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

A Prints 2

B Runtime panic: null pointer dereference

C Compilation error: use of moved value 'a'

D Prints 1

💡 Hint

Consider what happens when you assign a to b without cloning.

Assigning a to b moves the Rc pointer, so a is no longer valid. Using a after move causes a compile error.

📝 Syntax

advanced

Which option correctly clones an Rc pointer?

Which of the following lines correctly clones an Rc pointer rc_val?

Rust

use std::rc::Rc;

fn main() {
    let rc_val = Rc::new(42);
    // Which line correctly clones rc_val?
}

A let rc_clone = rc_val.clone();

B let rc_clone = Rc::clone(&rc_val);

C let rc_clone = Rc::new(rc_val);

D let rc_clone = rc_val.copy();

💡 Hint

Remember the recommended way to clone an Rc pointer.

The recommended way is to use Rc::clone(&rc_val). Option B also compiles but is less explicit. Option B tries to create a new Rc from an Rc which is invalid. Option B uses a method that does not exist.

🚀 Application

expert

How many strong references exist after this code?

After running this Rust code, how many strong references to the value exist?

Rust

use std::rc::Rc;

fn main() {
    let x = Rc::new(100);
    let y = Rc::clone(&x);
    {
        let z = Rc::clone(&y);
        println!("Inside block: {}", Rc::strong_count(&x));
    }
    println!("Outside block: {}", Rc::strong_count(&x));
}

A Inside block: 1, Outside block: 1

B Inside block: 2, Outside block: 1

C Inside block: 3, Outside block: 3

D Inside block: 3, Outside block: 2

💡 Hint

Count how many Rc pointers exist inside and outside the inner block.

Inside the block, x, y, and z all point to the value, so count is 3. After the block, z is dropped, so count is 2.