Shared Ownership with Rc<T>

Snippet

Shared Ownership with Rc<T>

Rc<T> (Reference Counting) enables shared ownership of heap-allocated data in single-threaded contexts. Unlike Box<T> where ownership is unique, Rc<T> allows multiple parts of your code to own the same data. The strong_count() method returns how many Rc references point to the data. When the last Rc is dropped, the inner data is automatically deallocated. Rc<T> provides only shared (immutable) access; for mutable shared ownership, you would need RefCell<T> inside Rc<T>. This is useful for caches, configuration objects, or any data that needs to be accessed from multiple places without clear ownership.

snippet.rs
rust
use std::rc::Rc;
 
#[derive(Debug)]
struct Config {
    name: String,
    version: String,
}
 
fn main() {
    let config = Rc::new(Config {
        name: "MyApp".to_string(),
        version: "1.0.0".to_string(),
    });
 
    println!("Original ref count: {}", Rc::strong_count(&config));
 
    {
        let config_clone = Rc::clone(&config);
        println!("After clone ref count: {}", Rc::strong_count(&config_clone));
        println!("Config in scope: {:?}", config_clone);
    }
 
    println!("After scope ref count: {}", Rc::strong_count(&config));
 
    let another_clone = Rc::clone(&config);
    println!("Final ref count: {}", Rc::strong_count(&another_clone));
 
    drop(another_clone);
    println!("After drop ref count: {}", Rc::strong_count(&config));
}

Breakdown

use std::rc::Rc;

Import Rc for reference-counted smart pointer (single-threaded only)

#[derive(Debug)]

Derive Debug trait to allow printing the Config struct

struct Config {

Define a simple configuration struct to demonstrate shared ownership

let config = Rc::new(Config { ... });

Create initial Rc wrapping the Config data on the heap

Rc::strong_count(&config)

Get current reference count - should be 1 initially

let config_clone = Rc::clone(&config);

Clone creates a new Rc pointing to same data, increments ref count

strong_count returns 2

Now two Rc instances point to the same data

} // config_clone dropped here

When clone goes out of scope, ref count decrements back to 1

let another_clone = Rc::clone(&config);

Create yet another clone, ref count goes back to 2

drop(another_clone);

Explicitly drop one clone to see ref count decrease

strong_count is 1 again

Only original Rc remains, data will be freed when it drops

Previous snippet Next snippet

More Intermediate Rust exercises →

From your library

Shared Ownership with Rc<T>

Related