Ownership

🎒 Ownership in Rust: The Backpack Adventure

Imagine you have a magical backpack. This backpack can only belong to ONE person at a time. That’s Rust’s ownership!

🌟 The Big Idea

In Rust, every piece of data has one owner. Think of it like your favorite toy — only YOU can play with it right now. If you give it to a friend, now THEY own it, and you can’t use it anymore.

This simple rule makes Rust super fast and super safe. No fighting over toys. No broken toys. Everyone knows who owns what!

🧠 Memory Management Basics

What IS Memory?

Think of your computer’s memory like a giant toy shelf.

• 📦 Every toy (data) needs a spot on the shelf
• 🏷️ Each spot has an address (so we can find it)
• 🧹 When you’re done, the spot needs cleaning for new toys

The Problem: Who cleans up?

Rust uses ownership rules to know EXACTLY when to clean up. No robot needed. No forgetting. Just rules!

📚 Stack vs Heap: Two Toy Shelves

Your computer has TWO shelves for toys:

🥞 The Stack (Fast Shelf)

Like a stack of pancakes! 🥞

┌─────────────┐
│   Plate 3   │ ← Last in, first out!
├─────────────┤
│   Plate 2   │
├─────────────┤
│   Plate 1   │
└─────────────┘

• ✅ Super fast to add/remove
• ✅ Fixed size items only
• ✅ Automatically cleaned when done
• 📌 Stores: numbers, booleans, fixed arrays

Example:

let x = 5;      // On the stack!
let y = true;   // On the stack!
let z = 3.14;   // On the stack!

🗃️ The Heap (Big Storage Room)

Like a big warehouse with boxes! 📦

┌──────────────────────────┐
│  📦 Box A (at spot 101)  │
│  📦 Box B (at spot 205)  │
│  📦 Box C (at spot 342)  │
│        ...more room...   │
└──────────────────────────┘

• ✅ Can store ANY size
• ✅ Flexible and big
• ⚠️ Slower to access
• 📌 Stores: Strings, Vectors, complex data

Example:

let s = String::from("hello");
// "hello" is in the heap
// s holds the address (pointer)

Quick Comparison

🚚 Move Semantics: Passing the Toy

Here’s where the magic happens!

The Rule

When you give something to someone else, you lose it.

Story Time: 🎈

Little Rustie has a balloon (String). She gives it to her friend Ferris.

let balloon = String::from("red");
let ferris_balloon = balloon;
// balloon is GONE! Ferris owns it now.

graph TD
    A["Rustie has balloon"] --> B["Gives to Ferris"]
    B --> C["Ferris owns balloon"]
    B --> D["Rustie has NOTHING"]
    style D fill:#ff6b6b
    style C fill:#4ecdc4

Why? Because strings live on the heap. If both could use it, they might fight! Rust prevents this.

What happens if Rustie tries to use it?

let balloon = String::from("red");
let ferris_balloon = balloon;
println!("{}", balloon); // ❌ ERROR!
// "balloon" was moved!

This is called a move. The data moved to a new owner!

📋 Copy Trait: Making Photocopies

Some small, simple things can be copied instead of moved!

The Rule

Small, simple data on the stack gets copied automatically.

Story Time: 📝

Little Rustie has a sticker with the number 5. She gives Ferris a copy — but she KEEPS her sticker too!

let x = 5;
let y = x;  // Copy! Both have 5!
println!("x = {}", x); // ✅ Works!
println!("y = {}", y); // ✅ Works!

graph TD
    A["x = 5"] --> B["Copy to y"]
    B --> C["x still = 5"]
    B --> D["y = 5"]
    style C fill:#4ecdc4
    style D fill:#4ecdc4

What Types Have Copy?

Easy Rule: If it’s a simple number or boolean, it copies. If it’s big or on the heap, it moves!

🧬 Clone Trait: Making a Real Copy

What if you WANT to copy something big? Use clone!

The Rule

Clone makes a FULL copy of data — even heap data!

Story Time: 🎨

Rustie has a beautiful painting (String). She doesn’t want to give it away, but Ferris wants one too. So she paints an EXACT copy!

let painting = String::from("Starry Night");
let copy = painting.clone();
// Now BOTH have their own painting!
println!("{}", painting); // ✅ Works!
println!("{}", copy);     // ✅ Works!

graph TD
    A["Original Painting"] --> B[".clone"]
    B --> C["Original: Still there!"]
    B --> D["Copy: Brand new!"]
    style C fill:#4ecdc4
    style D fill:#667eea

Copy vs Clone

Example comparing both:

// COPY (automatic for i32)
let a = 10;
let b = a;  // Copied automatically!

// CLONE (explicit for String)
let s1 = String::from("hello");
let s2 = s1.clone();  // Must call .clone()

🎯 Putting It All Together

Let’s trace through a complete example:

fn main() {
    // Stack data - will COPY
    let age = 25;
    let age_copy = age;
    println!("Ages: {} {}", age, age_copy);
    // ✅ Both work! Integers copy.

    // Heap data - will MOVE
    let name = String::from("Rustacean");
    let moved_name = name;
    // println!("{}", name); // ❌ Would fail!
    println!("Name: {}", moved_name);
    // Only moved_name works now.

    // Heap data - use CLONE to keep both
    let greeting = String::from("Hello!");
    let greeting_copy = greeting.clone();
    println!("{} {}", greeting, greeting_copy);
    // ✅ Both work! We cloned it.
}

🌈 Summary: The Ownership Adventure

💡 Why This Matters

Rust’s ownership system gives you:

• 🚀 Speed — No garbage collector slowing things down
• 🛡️ Safety — No crashes from using deleted data
• 🧹 Clean code — Clear who owns what

You now understand how Rust thinks about memory. You’re already ahead of many programmers!

Next up: Learn how to borrow data without giving it away! 🎉