Rust Understanding Ownership

Ownership is the most unique feature of Rust. It is the system Rust uses to manage memory automatically without needing a garbage collector. Understanding ownership unlocks your ability to read and write real Rust code.

The Problem Ownership Solves

Every program stores data in memory during its run. That memory must be cleaned up when the data is no longer needed. Other languages solve this in one of two ways:

  • C and C++: The programmer manually calls functions to allocate and free memory. Forgetting causes leaks. Freeing too early causes crashes.
  • Java, Python, Go: A garbage collector runs in the background and frees memory automatically. This is safe but adds pauses and overhead.

Rust uses a third approach: the compiler checks ownership rules at compile time. No background process runs. No manual calls needed. Memory is freed automatically and safely.

The Three Ownership Rules

Rule 1: Every value in Rust has exactly one owner.
Rule 2: There can only be one owner at a time.
Rule 3: When the owner goes out of scope, the value is dropped (freed).

The House Key Diagram

A value is like a house. Ownership is like having the only key.

let s = String::from("hello");
         ↑
    s is the owner — s holds the only key to this house.

When s leaves scope:
    Rust returns the key and locks the house (frees the memory).

Scope

Scope is the region of code where a variable is valid. A variable comes into scope when it is created and goes out of scope when the surrounding block ends:

fn main() {
    // s does not exist yet

    let s = String::from("hello");
    // s is valid here

    println!("{}", s);

} // s goes out of scope here. Rust drops it automatically.

Move Semantics

When you assign one variable to another for types stored on the heap (like String), ownership moves from the old variable to the new one. The old variable can no longer be used.

let s1 = String::from("hello");
let s2 = s1;    ← Ownership moves from s1 to s2

println!("{}", s1);  ← Compiler error: s1 no longer owns the value
println!("{}", s2);  ← This works fine

Why Move Instead of Copy?

If both s1 and s2 owned the same memory, Rust would try to free it twice when both go out of scope. Freeing the same memory twice is a bug called a double-free error. Rust prevents this by invalidating s1 the moment ownership moves to s2.

The Moving Truck Diagram

let s1 = String::from("hello");
  s1 → [ "hello" in memory ]

let s2 = s1;
  s1 → (empty — no longer valid)
  s2 → [ "hello" in memory ]

Only one variable owns the house at a time.

Clone — Make a Full Copy

When you do need two separate copies of the same data, use .clone(). This creates a deep copy — entirely new memory with the same value:

let s1 = String::from("hello");
let s2 = s1.clone();

println!("{}", s1);  ← Works — s1 still owns its copy
println!("{}", s2);  ← Works — s2 owns a separate copy

Clone is intentionally written out so you can see where expensive memory operations happen in your code.

Copy Types

Simple types stored entirely on the stack do not follow move semantics — they are automatically copied instead. These include integers, floats, booleans, and characters.

let x = 5;
let y = x;    ← x is copied, not moved

println!("{}", x);  ← Works fine
println!("{}", y);  ← Works fine

Stack vs Heap Diagram

Stack (simple types — automatically copied)
  x = 5
  y = 5   ← y gets its own copy, x still valid

Heap (complex types like String — ownership moves)
  s1 → memory address → "hello"
  s2 = s1 → s2 takes over the address → s1 invalidated

Ownership and Functions

Passing a value into a function works the same way as assignment. Ownership moves into the function. After the function returns, the original variable is no longer valid (for heap types).

fn take_ownership(s: String) {
    println!("{}", s);
}   // s is dropped here

fn main() {
    let my_string = String::from("hello");
    take_ownership(my_string);
    println!("{}", my_string);  ← Compiler error: ownership moved
}

Returning Ownership

A function can return a value, which transfers ownership back to the caller:

fn give_ownership() -> String {
    let s = String::from("hello");
    s   ← ownership moves to the caller
}

fn main() {
    let my_string = give_ownership();
    println!("{}", my_string);   ← Works fine
}

The Relay Race Diagram

main()                  take_ownership()
  │                            │
  my_string created            │
  │                            │
  ──── ownership passes ──────►│
  my_string gone               s alive
                               │
                               s dropped at end of function

Why This Matters in Practice

Ownership forces you to think about where data lives and who is responsible for it. This discipline eliminates entire categories of bugs — null pointer errors, use-after-free bugs, and double-free errors — at compile time. Programs that pass the Rust compiler's ownership checks are guaranteed to be memory safe.

Quick Reference

let s = String::from("x");   ← s owns the String
let s2 = s;                  ← s is moved to s2
let s2 = s.clone();          ← s and s2 both own separate copies
let x = 5; let y = x;       ← Copy (not move) for stack types
Previous lessons
Back to courses
Next lessons

Leave a Comment