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.

Practice

1. What is the main purpose of using Rc in Rust?

easy

A. To automatically convert data types

B. To enable mutable access to data from multiple threads

C. To allow multiple owners to share read-only data safely in one thread

D. To create a new thread for parallel execution

Solution

1. Step 1: Understand Rc usage

   Rc stands for Reference Counted pointer, used to share ownership of data safely within a single thread.

2. Step 2: Identify the correct purpose

   Rc allows multiple owners to read the same data without mutable access or threading concerns.

3. Final Answer:

   To allow multiple owners to share read-only data safely in one thread -> Option C

4. Quick Check:

   Rc = shared read-only ownership [OK]

Hint: Rc is for shared ownership, not mutability or threads [OK]

Common Mistakes:

• Confusing Rc with Arc for multi-threading
• Thinking Rc allows mutable access
• Assuming Rc creates new threads

2. Which of the following is the correct way to create a new Rc pointer to an integer value 10?

easy

A. let x = Rc::new(10);

B. let x = Rc::clone(10);

C. let x = Rc::new(&10);

D. let x = Rc::create(10);

Solution

1. Step 1: Recall Rc creation syntax

   The correct way to create an Rc pointer is using Rc::new(value).

2. Step 2: Check each option

   let x = Rc::new(10); uses Rc::new(10) which is correct. Options B, C, and D use invalid methods or references.

3. Final Answer:

   let x = Rc::new(10); -> Option A

4. Quick Check:

   Rc::new(value) creates pointer [OK]

Hint: Use Rc::new(value) to create an Rc pointer [OK]

Common Mistakes:

• Using Rc::clone to create new Rc
• Passing reference instead of value to Rc::new
• Using non-existent Rc::create method

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

use std::rc::Rc;

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

medium

A. 1

B. 2

C. 0

D. Compilation error

Solution

1. Step 1: Understand Rc cloning effect

   Creating b as Rc::clone(&a) increases the reference count by 1.

2. Step 2: Check the strong count

   Initially, a has count 1. After cloning, count becomes 2. So, Rc::strong_count(&a) returns 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Cloning Rc increases count = 2 [OK]

Hint: Rc::clone increases count; check strong_count for owners [OK]

Common Mistakes:

• Assuming clone creates a new independent Rc
• Expecting count to remain 1 after clone
• Confusing strong_count with weak_count

4. Identify the error in the following Rust code using Rc:

use std::rc::Rc;

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

medium

A. Cannot move Rc pointer; should use Rc::clone(&x) instead

B. Rc::strong_count requires mutable reference

C. Rc::new cannot hold integers

D. No error; code runs fine

Solution

1. Step 1: Analyze ownership transfer

   Assigning y = x moves ownership of the Rc pointer, invalidating x.

2. Step 2: Identify correct way to share ownership

   To share ownership, use Rc::clone(&x) instead of move. Otherwise, x cannot be used after move.

3. Final Answer:

   Cannot move Rc pointer; should use Rc::clone(&x) instead -> Option A

4. Quick Check:

   Rc must be cloned, not moved for shared ownership [OK]

Hint: Use Rc::clone to share ownership, not assignment [OK]

Common Mistakes:

• Moving Rc instead of cloning
• Thinking Rc::strong_count needs mutable reference
• Believing Rc cannot hold primitive types

5. Given the following code, what will be printed?

use std::rc::Rc;

fn main() {
    let data = Rc::new(vec![1, 2, 3]);
    let a = Rc::clone(&data);
    let b = Rc::clone(&data);
    drop(data);
    println!("{}", Rc::strong_count(&a));
}

hard

A. 1

B. Compilation error

C. 3

D. 2

Solution

1. Step 1: Count Rc owners before drop

   Initially, data has 1 owner. Cloning twice adds two more owners, total 3.

2. Step 2: Drop original owner and check count

   Calling drop(data) removes one owner, leaving 2 owners: a and b.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Dropping one Rc reduces count by one [OK]

Hint: Dropping one Rc reduces count; clones keep count higher [OK]

Common Mistakes:

• Assuming drop removes all owners
• Forgetting clones increase count
• Expecting compilation error due to drop