What is the memory model in Rust?

Rust's memory model is distinctive, prioritizing memory safety while maintaining performance. Rust manages memory through three core concepts: ownership, borrowing, and lifetimes, avoiding common memory errors such as dangling pointers and double frees.

Ownership

In Rust, ownership rules ensure that each value has exactly one owner at all times. This means that when ownership is transferred from one variable to another, the original variable can no longer be used, preventing double frees.

Example: When transferring a string from one variable to another, the original variable no longer owns the string. Attempting to access it will result in a compilation error, preventing potential errors.

rust
let s1 = String::from("hello");
let s2 = s1;
// println!("{}, world!", s1); // This would cause an error, as s1 no longer owns the string

Borrowing

Borrowing in Rust allows you to access data through references without taking ownership. Borrowing is divided into mutable and immutable borrowing. Immutable borrowing allows reading data but not modifying it. If you need to modify data, you must use mutable borrowing. Within the same scope, for a specific data item, only one mutable borrow or any number of immutable borrows are allowed, but not both simultaneously.

Example:

rust
let mut x = 5;
{
    let y = &mut x; // Mutable borrow
    *y += 1;
}
println!("{}", x); // Outputs 6

Lifetimes

Lifetimes are an advanced concept in Rust, ensuring that references do not outlive the data they point to, thus avoiding dangling pointers. Lifetimes are explicitly annotated in function signatures to help the compiler verify reference validity.

Example:

rust
fn borrow_with_lifetime<'a>(x: &'a i32) -> &'a i32 { // Lifetime annotation ensures that the returned reference does not outlive the input reference
    x
}

let x = 10;
let y: &i32;
{
    let z = 20;
    y = borrow_with_lifetime(&z);
    // 'z' goes out of scope here, so 'y' cannot be used outside this scope
}
// println!("{}", y); // This would cause an error, as 'y' points to 'z' which is no longer in scope

Through these mechanisms, Rust enforces memory safety while providing performance close to C/C++. This is one of the key reasons Rust is widely used for systems programming.