Ownership is Rust's core memory management system, enforcing strict rules at compile time to ensure safety without a garbage collector. It prevents memory leaks and data races through a combination of ownership rules, move semantics, and borrowing.

Ownership in Rust

Each value has a single owner (variable).
When the owner goes out of scope, the value is dropped (Drop trait called).
Ownership can be transferred (moved), making the original variable invalid.

Key Rules

Move Semantics

Assigning a heap-allocated value (e.g., String) to another variable transfers ownership, invalidating the original.

Example:

let s1 = String::from("hello");
let s2 = s1; // Ownership moved to s2
// println!("{}", s1); // Compile error: value borrowed after move

Copy vs. Move

Types with known size (i32, bool) implement Copy and are cloned automatically.
Heap-allocated types (String, Vec) do not implement Copy and are moved.

Function Calls

Passing a value to a function moves or copies it, following the same rules.

Example:

fn take_ownership(s: String) { /* ... */ }

let s = String::from("hello");
take_ownership(s); // Ownership moved into the function
// println!("{}", s); // Error: s is invalid

How Ownership Prevents Memory Leaks

Automatic Cleanup: When the owner goes out of scope, Rust calls drop to free memory (no manual free() needed).
No Double Frees: Since only one owner exists, the value is dropped exactly once.

How Ownership Prevents Data Races

Borrowing Rules:
- Immutable borrows (&T): Multiple allowed, but no mutable borrows can coexist.
- Mutable borrows (&mut T): Only one allowed, and no other borrows can exist.
Compile-Time Enforcement: The compiler rejects code that could lead to data races.

Example: Data Race Prevention:

let mut data = vec![1, 2, 3];

let r1 = &data; // Immutable borrow OK
let r2 = &data; // Another immutable borrow OK
// let r3 = &mut data; // ERROR: Cannot borrow as mutable while immutable borrows exist

println!("{:?}, {:?}", r1, r2);

Key Takeaways

✅ Ownership ensures:

No dangling pointers (via lifetimes).
No memory leaks (via Drop).
No data races (via borrowing rules).

Rust’s ownership model guarantees memory safety and concurrency safety at compile time, delivering performance and reliability.

#data-races

Filter by Topic

How does ownership prevent memory leaks and data races?