References — Borrowing Without Owning

The ownership track ended on a frustration: to let a function read your data, you had to give it away and get it back. References fix that. A reference lets you use a value without owning it — borrow it, look, and let it go automatically.

The & operator

&s creates a reference to s without taking ownership. Pass &s to a function and the function borrows the value: it can read it, but ownership stays with the caller. When the reference goes out of scope, nothing is dropped — you only borrowed it.

Borrowing in function signatures

A parameter of type &String (or better, &str) says 'I want to read this, not own it.' The caller keeps the value after the call returns. This is the default you'll reach for constantly: take a reference unless you genuinely need ownership.

Borrow by default; take ownership only when you must. Most functions only need to read or temporarily use data. A reference says exactly that, and it leaves the caller's value intact — no moves, no returning-just-to-give-it-back.

References are not the dangerous kind of pointer

A Rust reference is guaranteed to point at valid data for as long as it exists — the compiler proves it. There's no null reference, no dangling reference, no 'is this still alive?' A reference is a promise the borrow checker enforces, not a raw address you have to babysit.

Code

Borrow to read, keep ownership·rust

fn length(s: &String) -> usize {
    s.len() // read through the reference
} // s goes out of scope, but it's only a reference — nothing dropped

fn main() {
    let name = String::from("Ferris");
    let len = length(&name);   // lend a reference
    // name is STILL valid here — we only borrowed it
    println!("{name} is {len} chars");
}

Exercise

Rewrite the awkward loudest function from the Ownership track to take &[String] (a borrowed slice) instead of Vec<String>, so it no longer needs to return the vec. Confirm the caller can still use its vector after the call.

Hint

When the function only reads the data, borrow it with &. The caller keeps ownership, so there's nothing to return — the move-and-give-back dance disappears.

References — Borrowing Without Owning

The & operator

Borrowing in function signatures

References are not the dangerous kind of pointer

Code

External links

Exercise

Progress

Comments 0