Ownership & Borrowing

Ownership is the feature that makes Rust Rust: it is how the language frees memory without a garbage collector and without you calling free. To see why it exists, you need a picture of where values live.

A String is really three stack values — a pointer to heap memory, a length and a capacity — plus the bytes on the heap. Somebody has to free those bytes exactly once. Free them too early and you get a use-after-free; twice and you get a double free; never and you leak. Ownership is the rule that says who frees them and when.

use std::mem::size_of;

fn main() {
    let n: i32 = 42;                        // all on the stack
    let mut s = String::with_capacity(16);  // pointer+len+cap on the stack, buffer on the heap
    s.push_str("hello");

    println!("i32 on the stack: {} bytes", size_of::<i32>());
    println!("String handle on the stack: {} bytes", size_of::<String>());
    println!("s: len {} capacity {}", s.len(), s.capacity());
    println!("{n} {s}");
}

i32 on the stack: 4 bytes
String handle on the stack: 24 bytes
s: len 5 capacity 16
42 hello

1. Each value in Rust has an owner — a variable (or a field, or a collection slot).
2. There can be only one owner at a time.
3. When the owner goes out of scope, the value is dropped: its destructor runs and its heap memory is freed.

Rule 3 is automatic: the compiler inserts the cleanup at the closing brace of the owner's scope. You can watch it happen by giving a type a Drop implementation that prints a line (traits are Module 07 — here it is just a hook that runs on drop).

struct Noisy(&'static str);

impl Drop for Noisy {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}

fn main() {
    let _a = Noisy("a");
    {
        let _b = Noisy("b");
        println!("inner scope ends");
    }                                   // _b dropped here
    let _c = Noisy("c");
    println!("main ends");
}                                       // _c then _a: reverse order of creation

inner scope ends
drop b
main ends
drop c
drop a

What should let s2 = s1; do when s1 is a String? Copying the heap bytes would be slow and hidden. Copying only the pointer would leave two owners, and both would free the same buffer at the end of the scope — a double free. Rust does neither: it moves ownership. The stack handle is copied to s2, and s1 is marked as no longer valid. Only s2 will free the buffer.

.clone() makes a deep copy: a new heap allocation with the same contents, and a second independent owner. It is explicit on purpose — when you see clone() you know memory is being allocated. Small stack-only types are different: they implement the Copy trait, so assignment copies the bits and the original stays valid. There is nothing to free, so two copies cannot cause a double free.

fn main() {
    // Copy types: assignment duplicates, both stay usable
    let a = 5;
    let b = a;
    let p = (1.5, true);
    let q = p;
    println!("{a} {b} {:?} {:?}", p, q);

    // Clone: an explicit deep copy of heap data
    let s1 = String::from("hello");
    let mut s2 = s1.clone();
    s2.push_str(" world");
    println!("{s1} | {s2}");
}

5 5 (1.5, true) (1.5, true)
hello | hello world

Passing a value to a function works exactly like assignment: a String moves into the parameter, an i32 is copied. When the function ends, its parameter goes out of scope and is dropped — unless the function hands it back as a return value, which moves ownership out to the caller.

fn take(s: String) {
    println!("took {s}");
}                                    // s dropped here: its heap memory is freed

fn make() -> String {
    String::from("fresh")            // ownership moves out to the caller
}

fn take_and_give_back(mut s: String) -> String {
    s.push('!');
    s                                // move it back out
}

fn main() {
    let a = String::from("one");
    take(a);                         // a moved in; a is invalid from here

    let n = 7;
    let doubled = double(n);         // i32 is Copy; n is still fine
    println!("{n} -> {doubled}");

    let b = make();
    let b = take_and_give_back(b);
    println!("{b}");
}

fn double(x: i32) -> i32 {
    x * 2
}

took one
7 -> 14
fresh!

fn shout(text: String) {
    println!("{}!", text.to_uppercase());
}

fn main() {
    let msg = String::from("ship it");
    shout(msg);
    println!("sent: {msg}");
}

error[E0382]: borrow of moved value: `msg`
 --> main.rs:8:22
  |
6 |     let msg = String::from("ship it");
  |         --- move occurs because `msg` has type `String`, which does not implement the `Copy` trait
7 |     shout(msg);
  |           --- value moved here
8 |     println!("sent: {msg}");
  |                      ^^^ value borrowed here after move
  |
note: consider changing this parameter type in function `shout` to borrow instead if owning the value isn't necessary
 --> main.rs:1:16
  |
1 | fn shout(text: String) {
  |    -----       ^^^^^^ this parameter takes ownership of the value
  |    |
  |    in this function

fn shout(text: &str) {
    println!("{}!", text.to_uppercase());
}

fn main() {
    let msg = String::from("ship it");
    shout(&msg);
    println!("sent: {msg}");
}

A reference &T lets you use a value without taking ownership of it. Creating one is called borrowing. The owner keeps the value, the borrower gets to look at it, and when the reference goes out of scope nothing is dropped — it never owned anything. References are guaranteed by the compiler to point at a valid value for as long as they exist.

fn count_vowels(text: &str) -> usize {
    text.chars().filter(|c| "aeiou".contains(*c)).count()
}

fn longest_len(words: &Vec<String>) -> usize {
    let mut best = 0;
    for w in words {                  // w is &String
        if w.len() > best {
            best = w.len();
        }
    }
    best
}

fn main() {
    let title = String::from("ownership and borrowing");
    let words = vec![String::from("move"), String::from("borrow"), String::from("slice")];

    println!("vowels: {}", count_vowels(&title));
    println!("longest: {}", longest_len(&words));
    println!("still mine: {title} / {:?}", words);   // nothing moved
}

vowels: 7
longest: 6
still mine: ownership and borrowing / ["move", "borrow", "slice"]

A plain &T is a shared (read-only) reference. To change a borrowed value you need a mutable reference, &mut T. Both sides have to agree: the owner must be let mut, and the call site must write &mut, so mutation is visible where it happens.

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

fn reset(n: &mut i32) {
    *n = 0;              // * dereferences: write to the i32 itself
}

fn main() {
    let mut s = String::from("done");
    add_bang(&mut s);
    add_bang(&mut s);
    println!("{s}");

    let mut counter = 41;
    counter += 1;
    println!("{counter}");
    reset(&mut counter);
    println!("{counter}");
}

done!!
42
0

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

fn main() {
    let mut s = String::from("done");
    add_bang(&s);
    println!("{s}");
}

error[E0596]: cannot borrow `*s` as mutable, as it is behind a `&` reference
 --> main.rs:2:5
  |
2 |     s.push('!');
  |     ^ `s` is a `&` reference, so it cannot be borrowed as mutable
  |
help: consider changing this to be a mutable reference
  |
1 | fn add_bang(s: &mut String) {
  |                 +++

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

fn main() {
    let mut s = String::from("done");
    add_bang(&mut s);
    println!("{s}");
}

This is the rule the borrow checker enforces, and the one to memorise: at any moment a value may have either one mutable reference, or any number of shared references — never both. Readers can share; a writer needs to be alone. It is exactly the rule that prevents data races, and it also prevents a quieter bug: changing a collection while someone holds a pointer into it.

fn main() {
    let mut s = String::from("hi");
    let a = &mut s;
    let b = &mut s;
    a.push('!');
    b.push('?');
    println!("{s}");
}

error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> main.rs:4:13
  |
3 |     let a = &mut s;
  |             ------ first mutable borrow occurs here
4 |     let b = &mut s;
  |             ^^^^^^ second mutable borrow occurs here
5 |     a.push('!');
  |     - first borrow later used here

fn main() {
    let mut s = String::from("hi");
    let a = &mut s;
    a.push('!');          // last use of a
    let b = &mut s;       // fine: a is finished
    b.push('?');
    println!("{s}");
}

fn main() {
    let mut scores = vec![10, 20, 30];
    let first = &scores[0];
    scores.push(40);
    println!("first = {first}");
}

error[E0502]: cannot borrow `scores` as mutable because it is also borrowed as immutable
 --> main.rs:4:5
  |
3 |     let first = &scores[0];
  |                  ------ immutable borrow occurs here
4 |     scores.push(40);
  |     ^^^^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("first = {first}");
  |                        ----- immutable borrow later used here

fn main() {
    let mut scores = vec![10, 20, 30];
    let first = scores[0];     // a copy, not a borrow
    scores.push(40);
    println!("first = {first}");
}

fn main() {
    let mut data = vec![1, 2, 3];

    let r1 = &data;
    let r2 = &data;                       // many readers: fine
    println!("{:?} {:?}", r1, r2);        // last use of r1 and r2

    let w = &mut data;                    // one writer: fine, readers are done
    w.push(4);
    println!("{:?}", w);

    println!("len {}", data.len());       // w is done, the owner can read again
}

[1, 2, 3] [1, 2, 3]
[1, 2, 3, 4]
len 4

A dangling reference points at memory that has already been freed. The classic way to create one is to return a reference to a local variable: the local is dropped when the function returns, and the caller is left holding a pointer to nothing. Rust rejects this at compile time.

fn dangle() -> &String {
    let s = String::from("temporary");
    &s
}

fn main() {
    println!("{}", dangle());
}

error[E0106]: missing lifetime specifier
 --> main.rs:1:16
  |
1 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
1 | fn dangle() -> &'static String {
  |                 +++++++
help: instead, you are more likely to want to return an owned value
  |
1 - fn dangle() -> &String {
1 + fn dangle() -> String {
  |

fn no_dangle() -> String {
    String::from("temporary")
}

fn main() {
    println!("{}", no_dangle());
}

Slices: borrowing part of a collection

A slice is a reference to a contiguous run of elements: a pointer plus a length. &str is a slice of UTF-8 text; &[T] is a slice of an array or Vec. You make one with a range: &s[0..5], &v[2..], &v[..]. Because a slice is a borrow, the borrowing rules keep it valid — you cannot clear a string while a slice of it is still in use.

fn first_word(s: &str) -> &str {
    for (i, b) in s.bytes().enumerate() {
        if b == b' ' {
            return &s[..i];
        }
    }
    s
}

fn sum(values: &[i32]) -> i32 {
    let mut total = 0;
    for v in values {
        total += v;
    }
    total
}

fn main() {
    let owned = String::from("hello brave world");
    let literal = "single";                  // string literals are already &str
    println!("{}", first_word(&owned));      // &String coerces to &str
    println!("{}", first_word(literal));
    println!("{}", &owned[6..11]);

    let nums = vec![4, 8, 15, 16, 23, 42];
    let arr = [1, 2, 3];
    println!("{} {} {}", sum(&nums), sum(&nums[1..3]), sum(&arr));
}

hello
single
brave
108 23 6

Owner

The variable responsible for a value. When it goes out of scope, the value is dropped.

Move

Transferring ownership by assignment, passing or returning. The source can no longer be used.

Copy

A trait for small stack-only types; assignment duplicates the bits and the source stays valid.

Clone

An explicit deep copy, usually a new heap allocation: .clone().

Drop

Freeing a value when its owner goes out of scope. Happens in reverse order of declaration.

Borrow

Creating a reference to a value without taking ownership.

Shared reference

&T: read-only access. Any number may exist at once.

Mutable reference

&mut T: read-write access. Only one may exist, with no shared references alongside.

Borrow checker

The compiler pass that enforces the ownership and borrowing rules.

Slice

A reference to a contiguous part of a collection: &str, &[T].

Dangling reference

A pointer to memory that has been freed. Impossible in safe Rust.