Ownership Rules & Move Semantics

In Plain English

Ownership is Rust’s signature feature that enables memory safety without a garbage collector. The three rules of ownership govern how heap allocations are tracked, transferred (moved), and automatically deallocated when an owner goes out of scope.

The Mental Model

"Ownership is like a physical library book: only one person can hold the physical book (owner) at a time. If you pass the book to a friend (move), you no longer possess it. When the last holder leaves the room, the book is returned to the shelf (drop)."

Deep Dive: How It Works

The 3 Rules of Ownership: 1) Each value has an owner. 2) There can only be one owner at a time. 3) When the owner goes out of scope, the value is dropped.

Move Semantics: Assigning a heap value (like String) to a new variable moves ownership. The original variable becomes invalid.

Stack vs Heap: Primitive scalar types implement Copy and duplicate on the stack; heap structures transfer ownership.

Syntax Blueprint

let s1 = String::from("hello"); let s2 = s1; // s1 is MOVED and invalid

Ownership of the heap buffer transfers to s2. Attempting to use s1 causes a compile-time error.

Core Rules to Remember

Single Owner: Every resource has exactly one owning variable.

Zero Memory Leaks: Drop runs automatically at closing brace } without manual free().

Explicit Clone: Use s1.clone() if you genuinely need a deep heap copy.

Common Beginner Traps & How to Fix Them

Mistake:Using a variable after it has been moved.

Why it happens: let s1 = String::from("hi"); let s2 = s1; println!("{}", s1); fails with E0382: borrow of moved value.

How to fix: Pass a reference (&s1) instead of moving ownership, or clone if an independent copy is needed.

Pro Tip: Primitive types (i32, bool, f64, char) implement Copy automatically—they are duplicated without moving!

Live Interactive Example

Hit Run Code to see it live

Move Semantics and Scope Drop

Rust 1.78 / rustc

Output Console

Click "Run Code" to view the rendered output.

How it works: Demonstrates clone keeping original valid and passing ownership to a consuming function.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Clone a heap string to retain ownership

Given let msg = String::from("ZenCompiler");
Create let backup = msg.clone();
Print "Primary: ZenCompiler | Backup: ZenCompiler".

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.

Deep Dive: How It Works

The 3 Rules of Ownership: 1) Each value has an owner. 2) There can only be one owner at a time. 3) When the owner goes out of scope, the value is dropped.

Move Semantics: Assigning a heap value (like String) to a new variable moves ownership. The original variable becomes invalid.

Stack vs Heap: Primitive scalar types implement Copy and duplicate on the stack; heap structures transfer ownership.