How does Rust handle memory allocation and deallocation?

Rust manages memory through its concepts of ownership, borrowing, and lifetimes, enabling it to prevent common memory errors such as null pointer dereferencing and memory leaks at compile time. Below, I will explain how these concepts work and provide examples.

Ownership

In Rust, every value has a variable called its owner. Only one owner can exist at a time. When the owner (variable) goes out of scope, the value is automatically dropped, releasing the memory. This mechanism ensures memory safety without requiring manual deallocation.

Example:

rust
{
    let s = String::from("hello");  // s is the owner
}  // s leaves the scope, and the memory it holds is automatically released

Borrowing

Rust allows borrowing values through references, which can be immutable or mutable. Immutable borrowing permits multiple references to read data but disallows modification. Mutable borrowing allows modification of data, but only one mutable reference can exist at a time.

Example:

rust
let s = String::from("hello");  
let r1 = &s;  // Immutable borrow
let r2 = &s;  // Immutable borrow
// let r3 = &mut s;  // Error: cannot create a mutable borrow while an immutable borrow exists
println!("{} and {}, r1, r2);

Lifetimes

Lifetimes are a tool in Rust to ensure that all borrows are valid. By annotating lifetimes, the compiler checks whether references might outlive the data they point to.

Example:

rust
fn main() {
    let r;                // Declare a reference
    {
        let x = 5;
        r = &x;           // Error: `x` does not live longer than `r`
    }
    println!("r: {}, r"); // Using `r` here would cause an error
}

Through these three core concepts, Rust provides a way to automatically manage memory without a garbage collector, effectively preventing memory leaks and other common memory errors. These features make Rust particularly suitable for systems programming and applications requiring high memory safety.