Chapter 3: Ownership - The Heart of Rust

Ownership is Rust's most distinctive feature and the foundation of its memory safety guarantees. Understanding ownership is the key to unlocking Rust's power. This chapter explains how ownership works, why it matters, and how to use it effectively.

3.1 Understanding Memory: Stack vs Heap

Before diving into ownership, you need to understand where data lives in memory. This fundamental knowledge applies to all programming languages, but Rust makes you think about it explicitly.

The Stack

The stack is a region of memory that operates like a stack of plates: last in, first out (LIFO). It's incredibly fast because:

• Adding data is just incrementing a pointer
• Removing data is just decrementing a pointer
• No searching required—data is always on top
• All data must have a known, fixed size at compile time

fn main() {
    let x = 42;        // x is pushed onto the stack
    let y = 3.14;      // y is pushed onto the stack
    let z = true;      // z is pushed onto the stack
}  // z, y, x are popped off the stack (in that order)

The Heap

The heap is for data that can grow or shrink at runtime, or whose size isn't known at compile time:

• Allocator finds an empty spot big enough
• Returns a pointer to that location
• Accessing heap data requires following a pointer
• Must be explicitly freed when no longer needed

fn main() {
    let s = String::from("hello");  // String data is on the heap
    // s variable (with pointer) is on the stack
    // The actual "hello" bytes are on the heap
}

3.2 The Three Rules of Ownership

Rust's ownership system is governed by three fundamental rules. These rules are enforced at compile time, meaning violations are caught before your code ever runs.

let s = String::from("hello");  // s owns the String
// There is exactly one variable that owns this string data

let s1 = String::from("hello");
let s2 = s1;  // Ownership MOVES from s1 to s2
// s1 is no longer valid - s2 is now the sole owner

{
    let s = String::from("hello");
    // s is valid here
}  // s goes out of scope, "drop" is called
   // Memory is automatically freed

3.3 Move Semantics

When you assign a value to another variable, ownership can move. This is fundamental to understanding Rust.

Stack Types: Copy

Simple types that live entirely on the stack are copied:

let x = 5;
let y = x;  // x is COPIED to y

println!("x = {}, y = {}", x, y);  // Both are valid!

This works because copying an integer is cheap—it's just copying a few bytes on the stack.

Heap Types: Move

For types that use heap memory, assignment moves ownership:

let s1 = String::from("hello");
let s2 = s1;  // Ownership MOVES from s1 to s2

println!("{}", s2);  // OK: s2 owns the data
// println!("{}", s1);  // ERROR: s1 is no longer valid!

3.4 Clone: Explicit Deep Copy

When you actually need a deep copy of heap data, use the clone method:

let s1 = String::from("hello");
let s2 = s1.clone();  // Deep copy - both are independent

println!("s1 = {}, s2 = {}", s1, s2);  // Both valid!

Copy vs Clone

3.5 Ownership and Functions

Passing a value to a function follows the same rules as assignment:

Moving into Functions

fn main() {
    let s = String::from("hello");
    takes_ownership(s);  // s is MOVED into the function

    // println!("{}", s);  // ERROR: s is no longer valid here

    let x = 5;
    makes_copy(x);  // x is COPIED (integers implement Copy)

    println!("{}", x);  // OK: x is still valid
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}  // some_string goes out of scope, memory is freed

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
}  // some_integer goes out of scope, nothing special happens

Returning Values

Functions can return ownership:

fn main() {
    let s1 = gives_ownership();  // Ownership moves to s1

    let s2 = String::from("hello");
    let s3 = takes_and_gives_back(s2);  // s2 moves in, result moves to s3

    // s2 is invalid here, s1 and s3 are valid
}

fn gives_ownership() -> String {
    let s = String::from("yours");
    s  // Ownership moves to the caller
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string  // Ownership moves back to the caller
}

3.6 The Drop Trait

When a value goes out of scope, Rust calls the drop function. This is where cleanup happens:

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data: {}", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    println!("CustomSmartPointer created.");
}  // c goes out of scope here, "Dropping..." is printed

3.7 Common Ownership Patterns

Pattern 1: Transfer and Use

fn process_data(data: String) -> String {
    // Process the data
    data.to_uppercase()
}

fn main() {
    let input = String::from("hello");
    let output = process_data(input);  // input moved, output received
    println!("{}", output);
}

Pattern 2: Return Multiple Values

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)  // Return both the string and its length
}

fn main() {
    let s = String::from("hello");
    let (s, len) = calculate_length(s);
    println!("'{}' has length {}", s, len);
}

3.8 Chapter Summary

3.9 Review Questions

3.10 Looking Ahead