Ownership & Borrowing Skill
Master Rust's revolutionary memory safety system without garbage collection.
Quick Start
The Three Rules of Ownership
// Rule 1: Each value has exactly ONE owner
let s1 = String::from("hello"); // s1 owns this String
// Rule 2: Only ONE owner at a time
let s2 = s1; // Ownership MOVES to s2
// println!("{}", s1); // ERROR: s1 no longer valid
// Rule 3: Value is dropped when owner goes out of scope
{
let s3 = String::from("temporary");
} // s3 dropped here, memory freed
Borrowing Basics
fn main() {
let s = String::from("hello");
// Immutable borrow
let len = calculate_length(&s);
println!("{} has length {}", s, len);
// Mutable borrow
let mut s = String::from("hello");
change(&mut s);
println!("{}", s); // "hello, world"
}
fn calculate_length(s: &String) -> usize {
s.len()
}
fn change(s: &mut String) {
s.push_str(", world");
}
Lifetime Annotations
// Explicit lifetime annotation
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
// Struct with lifetime
struct Excerpt<'a> {
part: &'a str,
}
Common Patterns
Pattern 1: Clone When Needed
let s1 = String::from("hello");
let s2 = s1.clone(); // Deep copy
println!("{} {}", s1, s2); // Both valid
Pattern 2: Return Ownership
fn process(s: String) -> String {
// Do something with s
s // Return ownership
}
Pattern 3: Borrow for Read-Only
fn analyze(data: &Vec<i32>) -> Summary {
// Only read, don't own
Summary::from(data)
}
Error Solutions
"value borrowed after move"
// Problem
let s = String::from("hello");
let s2 = s;
println!("{}", s); // ERROR
// Solution 1: Clone
let s2 = s.clone();
// Solution 2: Borrow
let s2 = &s;
"cannot borrow as mutable"
// Problem
let s = String::from("hello");
change(&mut s); // ERROR: s is not mut
// Solution: Declare as mutable
let mut s = String::from("hello");
change(&mut s); // OK