Rc<T>, the Reference Counted Smart Pointer

Rust's ownership system ensures memory safety at compile time by enforcing strict rules: a value can have only one owning variable at a time, or multiple immutable references, or one mutable reference. While this is great for safety, there are scenarios where multiple parts of a program genuinely need to "own" the same piece of data, and that data should only be deallocated once all owners are done with it. This is where `Rc<T>`, the *Reference Counted* smart pointer, comes in.

`Rc<T>` enables multiple ownership of data. It keeps track of the number of references to a value on the heap. When there are zero references, the value is dropped. This allows for shared ownership where data can be accessed by multiple parts of your program without violating Rust's ownership rules.

How `Rc<T>` works:
1. Creation: When you create an `Rc<T>` using `Rc::new(value)`, a new reference counter is initialized to `1`, and the `value` is moved to the heap, managed by the `Rc`.
2. Cloning References: To create another "owner" or reference to the same data, you call `Rc::clone(&rc_instance)` (or simply `rc_instance.clone()`). This operation is very cheap: it doesn't perform a deep copy of the data. Instead, it only increments the internal reference count and returns a new `Rc<T>` instance that points to the *same* data on the heap.
3. Dropping References: When an `Rc<T>` instance goes out of scope, its `Drop` implementation runs, which decrements the reference count.
4. Data Deallocation: When the reference count reaches `0`, it means there are no more `Rc<T>` instances pointing to that data. At this point, the `Drop` implementation for the data itself is called, deallocating the memory on the heap.

Key Characteristics and Use Cases:
* Multiple Ownership: `Rc<T>` is explicitly designed for scenarios where data needs to have multiple owners.
* Immutable Data (by default): By default, the data inside an `Rc<T>` is immutable. If you need mutable access to data shared via `Rc`, you can combine it with `RefCell<T>` (i.e., `Rc<RefCell<T>>`), which provides *interior mutability* by enforcing borrowing rules at runtime.
* Single-threaded Only: `Rc<T>` is not thread-safe. Its reference count operations are not atomic, meaning they can lead to data races in multi-threaded environments. For multi-threaded shared ownership, you should use `Arc<T>` (Atomic Reference Counted), which provides thread-safe reference counting.
* Heap Allocation: The data managed by `Rc<T>` is always allocated on the heap.
* Common Use Cases: Graph data structures where multiple nodes might point to the same child, or tree structures where child nodes might need references to their parents or other shared resources. Any scenario requiring shared, non-mutable access to data across different parts of a single-threaded application.

use std::rc::Rc;

// Define a simple struct that we want to share ownership of
struct Gadget {
    id: u32,
    name: String,
}

// Implement Drop trait to see when the Gadget is actually deallocated
impl Drop for Gadget {
    fn drop(&mut self) {
        println!("Gadget {{ id: {}, name: \"{}\" }} is being dropped!", self.id, self.name);
    }
}

fn main() {
    // Create an Rc<Gadget>. The strong count starts at 1.
    let gadget1 = Rc::new(Gadget { id: 1, name: String::from("Smartwatch") });
    println!("Strong count after gadget1 creation: {}", Rc::strong_count(&gadget1));

    // Create another reference (owner) to the same Gadget data using Rc::clone().
    // This increments the strong count to 2.
    let gadget2 = Rc::clone(&gadget1);
    println!("Strong count after gadget2 cloned: {}", Rc::strong_count(&gadget1));

    // Access data through any of the Rc instances (all point to the same data)
    println!("Gadget 1 name: {}", gadget1.name);
    println!("Gadget 2 ID: {}", gadget2.id);

    // Create a block to demonstrate how strong count decreases when an Rc instance goes out of scope.
    {
        let gadget3 = gadget1.clone(); // Shorthand for Rc::clone(&gadget1)
        println!("Strong count inside block after gadget3 cloned: {}", Rc::strong_count(&gadget1));
        println!("Gadget 3 name: {}", gadget3.name);
    } // gadget3 goes out of scope here. Its Drop implementation runs, decrementing the strong count.
    println!("Strong count after gadget3 went out of scope: {}", Rc::strong_count(&gadget1));

    // We can explicitly drop an Rc instance early
    drop(gadget2); // gadget2 is explicitly dropped. Strong count decreases.
    println!("Strong count after gadget2 dropped: {}", Rc::strong_count(&gadget1));

    // When gadget1 goes out of scope at the end of `main`,
    // its `Drop` implementation will run, decrementing the strong count to 0.
    // At that point, the underlying `Gadget` data will be deallocated,
    // and the `Gadget::drop` method will be called.
    println!("End of main function. gadget1 will be dropped next.");
} // gadget1 goes out of scope here, strong count becomes 0, and the Gadget data is dropped.