Ownership — Rust Memory Safety

6.0 What This Teaches

• The three ownership rules
• Move semantics - what happens when you assign or pass a value
• Clone for an explicit deep copy
• Copy types that duplicate automatically
• Shared references (&T) for read-only borrowing
• Mutable references (&mut T) for exclusive borrowing
• How scope controls when memory is freed

6.1 The Three Ownership Rules

• Every value has exactly one owner.
• When the owner goes out of scope, the value is dropped (memory freed).
• There can only be one owner at a time.

6.2 Move Semantics

let a = String::from("hello");
let b = a;            // ownership moves from a to b
// println!("{a}");  // compile error: value moved
println!("{b}");      // fine

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

let u = String::from("goodbye");
take_ownership(u);
// println!("{u}");  // compile error: u was moved into the function

6.3 Clone - Explicit Deep Copy

let c = String::from("world");
let d = c.clone();
println!("c = {c}, d = {d}");  // both usable

6.4 Copy Types

let x = 42;
let y = x;           // x is copied, not moved
println!("x = {x}, y = {y}");  // both valid

6.5 Shared References - Borrowing Read-Only

fn print_len(s: &String) {
    println!("length = {}", s.len());
}

let s = String::from("Rust");
print_len(&s);               // lend s to the function
println!("still have s: {s}");  // s is still ours

let r1 = &s;
let r2 = &s;
println!("r1 = {r1}, r2 = {r2}");  // fine - both just read

6.6 Mutable References - Borrowing for Mutation

fn append_bang(s: &mut String) {
    s.push('!');
}

let mut t = String::from("hello");
append_bang(&mut t);
println!("{t}");   // hello!

• At most one &mut reference at a time.
• No & references while a &mut reference is active.

let mut s = String::from("hi");
let r1 = &s;
let r2 = &mut s;   // compile error: cannot borrow as mutable because it is also borrowed as immutable

6.7 Scope Controls Lifetime

{
    let scoped = String::from("temporary");
    println!("{scoped}");
}   // scoped is dropped here; heap memory freed immediately
println!("scoped is gone");

6.8 Example - All Together

// Ownership - demonstrates move semantics, cloning, Copy types, and borrowing in Rust.

fn print_len(s: &String) {
    println!("length = {}", s.len());
}

fn append_bang(s: &mut String) {
    s.push('!');
}

fn take_ownership(s: String) {
    println!("taken: {s}");
}

fn main() {
    // move
    let a = String::from("hello");
    let b = a;
    println!("{b}");

    // clone
    let c = String::from("world");
    let d = c.clone();
    println!("c = {c}, d = {d}");

    // Copy type
    let x = 42;
    let y = x;
    println!("x = {x}, y = {y}");

    // shared borrow
    let s = String::from("Rust");
    print_len(&s);
    println!("still have s: {s}");

    // mutable borrow
    let mut t = String::from("hello");
    append_bang(&mut t);
    println!("{t}");

    // move into function
    let u = String::from("goodbye");
    take_ownership(u);

    // scope drop
    {
        let scoped = String::from("temporary");
        println!("{scoped}");
    }
    println!("scoped is gone");
}

hello
c = world, d = world
x = 42, y = 42
length = 4
still have s: Rust
hello!
taken: goodbye
temporary
scoped is gone

6.9 Exercise

6.10 Common Mistakes

let a = String::from("hi");
let b = a;
println!("{a}");  // error: value borrowed here after move

let mut s = String::from("hi");
let r = &s;
s.push('!');       // error: cannot borrow `s` as mutable because it is also borrowed as immutable
println!("{r}");

let s = String::from("hi");
let r = &mut s;   // error: cannot borrow `s` as mutable, as it is not declared as mutable

6.11 Key Terms