2859 words
14 minutes
Understanding Rust Ownership and Borrowing - The Complete Guide
Understanding Rust Ownership and Borrowing: The Complete Guide
Rust’s ownership system is what makes it unique among programming languages. It enables memory safety without garbage collection and prevents common bugs like null pointer dereferences, buffer overflows, and memory leaks. In this comprehensive guide, we’ll explore ownership, borrowing, and lifetimes with practical examples.
Table of Contents
Why Ownership Matters
Traditional languages handle memory in one of two ways:
- Manual memory management (C/C++): Fast but prone to bugs like memory leaks and use-after-free
- Garbage collection (Java/Python): Safe but with runtime overhead and unpredictable pauses
Rust chooses a third path: ownership. The compiler tracks how memory is used and ensures it’s cleaned up automatically without runtime overhead.
Memory Safety Without Garbage Collection
fn main() { // Traditional C-style memory management (conceptual) // char* ptr = malloc(10); // Allocate // strcpy(ptr, "hello"); // Use // free(ptr); // Free - must remember to do this! // strcpy(ptr, "world"); // BUG: Use after free!
// Rust's approach let data = String::from("hello"); // Allocate println!("{}", data); // Use // No explicit free needed - Rust handles this automatically} // data is automatically freed hereThe Three Rules of Ownership
Rust’s ownership system is governed by three fundamental rules:
- Each value in Rust has a single owner
- There can only be one owner at a time
- When the owner goes out of scope, the value is dropped
Let’s explore each rule with examples.
Rule 1: Each Value Has an Owner
fn main() { let s = String::from("hello"); // 's' owns the String value let x = 42; // 'x' owns the integer value
// The variables 's' and 'x' are the owners of their respective values println!("{}, {}", s, x);} // Both s and x go out of scope, their values are droppedRule 2: Only One Owner at a Time
fn main() { let s1 = String::from("hello"); let s2 = s1; // Ownership moves from s1 to s2
// println!("{}", s1); // ERROR: s1 no longer owns the value println!("{}", s2); // OK: s2 owns the value}This is different from languages with garbage collection where both variables would point to the same object.
Rule 3: Values Are Dropped When Owner Goes Out of Scope
fn main() { { let s = String::from("hello"); // s comes into scope println!("{}", s); } // s goes out of scope and is dropped
// println!("{}", s); // ERROR: s is no longer in scope}Understanding Move Semantics
When you assign a value to another variable or pass it to a function, Rust moves the value by default for types that don’t implement the Copy trait.
Types That Move vs Copy
fn main() { // Copy types (stored on stack, cheap to copy) let x = 5; let y = x; // x is copied, both x and y are valid println!("{}, {}", x, y); // OK
// Move types (heap allocated, expensive to copy) let s1 = String::from("hello"); let s2 = s1; // s1 is moved to s2 // println!("{}", s1); // ERROR: s1 is no longer valid println!("{}", s2); // OK}Function Calls and Ownership
fn take_ownership(s: String) { println!("{}", s);} // s goes out of scope and is dropped
fn makes_copy(x: i32) { println!("{}", x);} // x goes out of scope, but since i32 is Copy, nothing special happens
fn main() { let s = String::from("hello"); take_ownership(s); // s is moved into the function // println!("{}", s); // ERROR: s is no longer valid
let x = 5; makes_copy(x); // x is copied into the function println!("{}", x); // OK: x is still valid}Returning Values and Ownership
fn gives_ownership() -> String { let s = String::from("hello"); s // Return value transfers ownership to caller}
fn takes_and_gives_back(s: String) -> String { s // Return the same String to transfer ownership back}
fn main() { let s1 = gives_ownership(); // Function transfers ownership to s1
let s2 = String::from("world"); let s3 = takes_and_gives_back(s2); // s2 is moved in, return value moves to s3
println!("{}, {}", s1, s3); // s2 is no longer valid, but s1 and s3 are}References and Borrowing
Moving values around all the time would be tedious. Rust provides references that let you refer to a value without taking ownership of it.
Immutable References
fn calculate_length(s: &String) -> usize { s.len()} // s goes out of scope, but doesn't drop the String because it doesn't own it
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); // Pass reference to s1 println!("The length of '{}' is {}.", s1, len); // s1 is still valid}Rules of References
- You can have either one mutable reference OR any number of immutable references
- References must always be valid
Multiple Immutable References
fn main() { let s = String::from("hello");
let r1 = &s; // No problem let r2 = &s; // No problem let r3 = &s; // No problem
println!("{}, {}, {}", r1, r2, r3); // All references are valid}Reference Scope and Lifetime
fn main() { let s = String::from("hello");
let r1 = &s; let r2 = &s; println!("{} and {}", r1, r2); // r1 and r2 are no longer used after this point
let r3 = &s; // This is fine because r1 and r2 are no longer active println!("{}", r3);}Mutable References
To modify a borrowed value, you need a mutable reference.
Creating Mutable References
fn change(s: &mut String) { s.push_str(", world");}
fn main() { let mut s = String::from("hello"); change(&mut s); println!("{}", s); // Prints "hello, world"}Restriction: One Mutable Reference
fn main() { let mut s = String::from("hello");
let r1 = &mut s; // let r2 = &mut s; // ERROR: Cannot have two mutable references
println!("{}", r1);}Cannot Mix Mutable and Immutable References
fn main() { let mut s = String::from("hello");
let r1 = &s; // No problem let r2 = &s; // No problem // let r3 = &mut s; // ERROR: Cannot have mutable reference while immutable refs exist
println!("{} and {}", r1, r2);}Non-Lexical Lifetimes
Modern Rust is smart about reference lifetimes:
fn main() { let mut s = String::from("hello");
let r1 = &s; let r2 = &s; println!("{} and {}", r1, r2); // r1 and r2 are last used here
let r3 = &mut s; // This is fine because r1 and r2 are no longer used println!("{}", r3);}The Slice Type
Slices are references to contiguous sequences of elements in a collection.
String Slices
fn first_word(s: &String) -> &str { let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } }
&s[..]}
fn main() { let s = String::from("hello world"); let word = first_word(&s); println!("First word: {}", word);
// String literals are slices let s = "Hello, world!"; // Type is &str let word = first_word(&s.to_string());}Array Slices
fn main() { let a = [1, 2, 3, 4, 5]; let slice = &a[1..3]; // Type is &[i32]
for item in slice { println!("{}", item); }
// Different ways to create slices let full_slice = &a[..]; // All elements let from_start = &a[..3]; // First 3 elements let to_end = &a[2..]; // From index 2 to end}Practical Example: Safe String Processing
fn find_word_boundaries(text: &str) -> Vec<(usize, usize)> { let mut boundaries = Vec::new(); let mut start = 0; let mut in_word = false;
for (i, ch) in text.char_indices() { if ch.is_whitespace() { if in_word { boundaries.push((start, i)); in_word = false; } } else if !in_word { start = i; in_word = true; } }
if in_word { boundaries.push((start, text.len())); }
boundaries}
fn extract_words(text: &str) -> Vec<&str> { find_word_boundaries(text) .iter() .map(|(start, end)| &text[*start..*end]) .collect()}
fn main() { let text = "Hello, Rust world!"; let words = extract_words(text);
for word in words { println!("Word: '{}'", word); }}Lifetimes Explained
Lifetimes ensure that references are valid for as long as they’re used.
Lifetime Annotations
// This function takes two string slices and returns the longer onefn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y }}
fn main() { let string1 = String::from("abcd"); let string2 = "xyz";
let result = longest(string1.as_str(), string2); println!("The longest string is {}", result);}Lifetime Elision Rules
Rust can infer lifetimes in many cases:
// The compiler can infer lifetimes herefn first_word(s: &str) -> &str { let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } }
&s[..]}
// This is equivalent to:fn first_word_explicit<'a>(s: &'a str) -> &'a str { // Same implementation let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } }
&s[..]}Structs with References
struct ImportantExcerpt<'a> { part: &'a str,}
impl<'a> ImportantExcerpt<'a> { fn level(&self) -> i32 { 3 }
fn announce_and_return_part(&self, announcement: &str) -> &str { println!("Attention please: {}", announcement); self.part }}
fn main() { let novel = String::from("Call me Ishmael. Some years ago..."); let first_sentence = novel.split('.').next().expect("Could not find a '.'"); let i = ImportantExcerpt { part: first_sentence, };
println!("Important part: {}", i.part);}Smart Pointers
When ownership rules are too restrictive, Rust provides smart pointers.
Box for Heap Allocation
fn main() { let b = Box::new(5); println!("b = {}", b);
// Useful for recursive data structures #[derive(Debug)] enum List { Cons(i32, Box<List>), Nil, }
use List::{Cons, Nil};
let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil)))))); println!("{:?}", list);}Rc for Multiple Ownership
use std::rc::Rc;
#[derive(Debug)]enum List { Cons(i32, Rc<List>), Nil,}
use List::{Cons, Nil};
fn main() { let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); println!("Reference count after creating a: {}", Rc::strong_count(&a));
let b = Cons(3, Rc::clone(&a)); println!("Reference count after creating b: {}", Rc::strong_count(&a));
{ let c = Cons(4, Rc::clone(&a)); println!("Reference count after creating c: {}", Rc::strong_count(&a)); }
println!("Reference count after c goes out of scope: {}", Rc::strong_count(&a));}RefCell for Interior Mutability
use std::cell::RefCell;use std::rc::Rc;
#[derive(Debug)]struct Node { value: i32, children: RefCell<Vec<Rc<Node>>>,}
impl Node { fn new(value: i32) -> Rc<Node> { Rc::new(Node { value, children: RefCell::new(Vec::new()), }) }
fn add_child(self: &Rc<Self>, child: Rc<Node>) { self.children.borrow_mut().push(child); }}
fn main() { let root = Node::new(1); let child1 = Node::new(2); let child2 = Node::new(3);
root.add_child(child1); root.add_child(child2);
println!("Root has {} children", root.children.borrow().len());}Common Patterns and Solutions
Pattern 1: Returning References from Functions
// Problem: Can't return a reference to a local value// fn bad_function() -> &str {// let s = String::from("hello");// &s // ERROR: returns reference to local variable// }
// Solution 1: Return owned valuefn good_function1() -> String { String::from("hello")}
// Solution 2: Take input by reference and return slicefn good_function2(input: &str) -> &str { &input[..5]}
// Solution 3: Use static lifetimefn good_function3() -> &'static str { "hello"}
fn main() { let s1 = good_function1(); let input = String::from("hello world"); let s2 = good_function2(&input); let s3 = good_function3();
println!("{}, {}, {}", s1, s2, s3);}Pattern 2: Builder Pattern with Ownership
struct Config { host: String, port: u16, ssl: bool, timeout: u32,}
struct ConfigBuilder { host: Option<String>, port: Option<u16>, ssl: Option<bool>, timeout: Option<u32>,}
impl ConfigBuilder { fn new() -> Self { Self { host: None, port: None, ssl: None, timeout: None, } }
fn host(mut self, host: &str) -> Self { self.host = Some(host.to_string()); self }
fn port(mut self, port: u16) -> Self { self.port = Some(port); self }
fn ssl(mut self, ssl: bool) -> Self { self.ssl = Some(ssl); self }
fn timeout(mut self, timeout: u32) -> Self { self.timeout = Some(timeout); self }
fn build(self) -> Result<Config, String> { Ok(Config { host: self.host.unwrap_or_else(|| "localhost".to_string()), port: self.port.unwrap_or(8080), ssl: self.ssl.unwrap_or(false), timeout: self.timeout.unwrap_or(30), }) }}
fn main() { let config = ConfigBuilder::new() .host("example.com") .port(443) .ssl(true) .timeout(60) .build() .expect("Failed to build config");
println!("Config: {}:{}, SSL: {}, Timeout: {}", config.host, config.port, config.ssl, config.timeout);}Pattern 3: Working with Collections
fn process_strings(strings: &mut Vec<String>) { // Remove empty strings strings.retain(|s| !s.is_empty());
// Convert to uppercase for s in strings.iter_mut() { *s = s.to_uppercase(); }}
fn find_longest_string(strings: &[String]) -> Option<&String> { strings.iter().max_by_key(|s| s.len())}
fn group_by_length(strings: &[String]) -> std::collections::HashMap<usize, Vec<&String>> { let mut groups = std::collections::HashMap::new();
for string in strings { groups.entry(string.len()).or_insert_with(Vec::new).push(string); }
groups}
fn main() { let mut strings = vec![ String::from("hello"), String::from(""), String::from("world"), String::from("rust"), String::from("programming"), ];
println!("Original: {:?}", strings);
process_strings(&mut strings); println!("After processing: {:?}", strings);
if let Some(longest) = find_longest_string(&strings) { println!("Longest string: {}", longest); }
let groups = group_by_length(&strings); for (length, strings) in groups { println!("Length {}: {:?}", length, strings); }}Advanced Ownership Concepts
Cow (Clone on Write)
use std::borrow::Cow;
fn process_text(text: Cow<str>) -> Cow<str> { if text.contains("bad_word") { // Only clone if we need to modify Cow::Owned(text.replace("bad_word", "***")) } else { // Return the original (potentially borrowed) text text }}
fn main() { let text1 = "This is clean text"; let result1 = process_text(Cow::Borrowed(text1)); println!("Result 1: {}", result1); // No allocation needed
let text2 = "This contains bad_word in it"; let result2 = process_text(Cow::Borrowed(text2)); println!("Result 2: {}", result2); // Allocation only when needed}Custom Drop Implementation
struct CustomResource { name: String, data: Vec<u8>,}
impl CustomResource { fn new(name: &str, size: usize) -> Self { println!("Allocating resource: {}", name); Self { name: name.to_string(), data: vec![0; size], } }}
impl Drop for CustomResource { fn drop(&mut self) { println!("Cleaning up resource: {}", self.name); // Custom cleanup logic here }}
fn main() { { let resource1 = CustomResource::new("Resource A", 1000); let resource2 = CustomResource::new("Resource B", 2000);
println!("Resources created"); } // Both resources are automatically dropped here
println!("Resources cleaned up");}RAII Pattern
use std::fs::File;use std::io::{self, Write};
struct FileLogger { file: File,}
impl FileLogger { fn new(path: &str) -> io::Result<Self> { let file = File::create(path)?; println!("Log file opened: {}", path); Ok(FileLogger { file }) }
fn log(&mut self, message: &str) -> io::Result<()> { writeln!(self.file, "{}", message)?; self.file.flush() }}
impl Drop for FileLogger { fn drop(&mut self) { println!("Log file closed"); }}
fn main() -> io::Result<()> { { let mut logger = FileLogger::new("app.log")?; logger.log("Application started")?; logger.log("Processing data...")?; logger.log("Application finished")?; } // File is automatically closed when logger goes out of scope
println!("Logger cleaned up"); Ok(())}Common Ownership Mistakes and Solutions
Mistake 1: Fighting the Borrow Checker
// Wrong: Trying to modify while borrowing// fn wrong_approach() {// let mut data = vec![1, 2, 3, 4, 5];// for item in &data {// if *item > 3 {// data.push(*item * 2); // ERROR: Can't modify while borrowing// }// }// }
// Right: Collect items to modify firstfn right_approach() { let mut data = vec![1, 2, 3, 4, 5]; let items_to_add: Vec<i32> = data .iter() .filter(|&&item| item > 3) .map(|&item| item * 2) .collect();
data.extend(items_to_add); println!("{:?}", data);}
fn main() { right_approach();}Mistake 2: Unnecessary Cloning
// Inefficient: Cloning unnecessarilyfn inefficient_process(data: &[String]) -> Vec<String> { data.iter() .map(|s| s.clone()) // Unnecessary clone .filter(|s| s.len() > 5) .collect()}
// Efficient: Using referencesfn efficient_process(data: &[String]) -> Vec<&str> { data.iter() .map(|s| s.as_str()) .filter(|s| s.len() > 5) .collect()}
// Or if you need owned strings, clone only when necessaryfn selective_clone(data: &[String]) -> Vec<String> { data.iter() .filter(|s| s.len() > 5) .map(|s| s.clone()) // Clone after filtering .collect()}
fn main() { let data = vec![ String::from("short"), String::from("this is a longer string"), String::from("hi"), String::from("another long string"), ];
let result1 = inefficient_process(&data); let result2 = efficient_process(&data); let result3 = selective_clone(&data);
println!("Result 1: {:?}", result1); println!("Result 2: {:?}", result2); println!("Result 3: {:?}", result3);}Debugging Ownership Issues
Using Compiler Messages
fn main() { let s1 = String::from("hello"); let s2 = s1; // println!("{}", s1); // Uncomment to see compiler error
// The compiler will tell you: // error[E0382]: borrow of moved value: `s1` // Solutions: // 1. Use s2 instead // 2. Clone s1: let s2 = s1.clone(); // 3. Borrow s1: let s2 = &s1;
println!("{}", s2);}Visualizing Ownership
fn visualize_ownership() { println!("=== Ownership Transfer ==="); let s1 = String::from("hello"); println!("s1 owns: {}", s1);
let s2 = s1; // Ownership moves here println!("s2 now owns: {}", s2); // s1 is no longer valid
println!("\n=== Borrowing ==="); let s3 = String::from("world"); let s3_ref = &s3; // Borrowing println!("s3 owns: {}", s3); println!("s3_ref borrows: {}", s3_ref); // Both s3 and s3_ref are valid}
fn main() { visualize_ownership();}Performance Considerations
When to Clone vs Borrow
use std::time::Instant;
fn process_with_cloning(data: Vec<String>) -> Vec<String> { data.into_iter() .map(|s| format!("Processed: {}", s)) .collect()}
fn process_with_borrowing(data: &[String]) -> Vec<String> { data.iter() .map(|s| format!("Processed: {}", s)) .collect()}
fn benchmark_ownership() { let data: Vec<String> = (0..100_000) .map(|i| format!("Item {}", i)) .collect();
// Benchmarking cloning approach let start = Instant::now(); let _result1 = process_with_cloning(data.clone()); let clone_duration = start.elapsed();
// Benchmarking borrowing approach let start = Instant::now(); let _result2 = process_with_borrowing(&data); let borrow_duration = start.elapsed();
println!("Cloning approach: {:?}", clone_duration); println!("Borrowing approach: {:?}", borrow_duration); println!("Speedup: {:.2}x", clone_duration.as_nanos() as f64 / borrow_duration.as_nanos() as f64);}
fn main() { benchmark_ownership();}Conclusion
Understanding ownership and borrowing is crucial for writing effective Rust code. While it may seem complex at first, these concepts enable Rust to provide memory safety without runtime overhead.
Key takeaways:
- Ownership rules prevent memory safety bugs at compile time
- References allow borrowing values without taking ownership
- Lifetimes ensure references are always valid
- Smart pointers provide flexibility when ownership rules are too restrictive
- The borrow checker is your friend - its errors guide you toward better code
Next Steps
- Practice with the Rust Book
- Explore the Rustlings exercises
- Read about advanced smart pointers
- Learn about async and ownership
Remember: The borrow checker isn’t trying to make your life difficult - it’s helping you write safer, more efficient code. Embrace it, and you’ll write better Rust programs!
Understanding Rust Ownership and Borrowing - The Complete Guide
https://mranv.pages.dev/posts/rust-ownership-borrowing-guide/