Rust Programming - Ownership, Borrowing & Memory Safety

Rc<T> (Reference Counted) enables multiple ownership of immutable data in single-threaded scenarios. It keeps track of active references and deallocates memory when the reference count drops to zero.

Arc<T> (Atomically Reference Counted) provides thread-safe shared ownership across multiple threads using atomic operations for counting. It incurs a minor runtime overhead compared to non-thread-safe Rc<T>.

1. Each value in Rust has an owner (a variable).
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value is automatically dropped (deallocated).

When a stack variable pointing to heap memory is assigned to another variable or passed into a function, ownership is transferred ("moved"). The original variable becomes invalid, preventing double-free memory bugs.

Copy performs an implicit, low-cost bitwise copy for stack-only data types (e.g., i32, bool). Clone requires an explicit call (.clone()) to perform a deep copy of heap-allocated resources.

At any given point in a scope, you can have either:

References must always be valid and cannot outlive the underlying data.

A dangling reference points to a memory location that has already been deallocated. Rust's borrow checker prevents dangling references at compile time by ensuring all references stay within their valid lifetimes.

RAII ties resource management (memory, file handles, sockets) to an object's lifetime. When an object goes out of scope, Rust automatically invokes its Drop::drop implementation to free resources.