Introduction to Ownership in Rust

Ownership is Rust's most unique and defining feature. It enables Rust to make memory safety guarantees without needing a garbage collector. Understanding ownership is crucial for writing effective Rust code, as it affects how you design your programs and manage resources.

Key Concepts

• Each value has an owner: Every value in Rust has a single variable that's its "owner"
• Only one owner at a time: A value can only have one owner at any given time
• Owner goes out of scope: When the owner goes out of scope, the value is dropped (freed from memory)

These three rules form the foundation of Rust's memory safety guarantees.

1. Basic Ownership Rules

Stack and Heap

fn main() { // Stack-allocated types (Copy types) let x = 5; // i32 stored on stack let y = true; // bool stored on stack let z = 3.14; // f64 stored on stack let arr = [1, 2, 3]; // array stored on stack // Heap-allocated types (Owned types) let s1 = String::from("hello"); // String data stored on heap let v1 = vec![1, 2, 3]; // Vec data stored on heap let b1 = Box::new(42); // Box points to heap // Size of types on stack println!("Size of i32: {} bytes", std::mem::size_of::<i32>()); println!("Size of String: {} bytes", std::mem::size_of::<String>()); println!("Size of Vec<i32>: {} bytes", std::mem::size_of::<Vec<i32>>()); }

Owner Goes Out of Scope

fn main() { { // s is not valid here, it's not yet declared let s = String::from("hello"); // s is valid from this point forward println!("{}", s); // s is valid here } // scope is now over, s is no longer valid // println!("{}", s); // Error: s not found in this scope // Multiple scopes let x = 5; // x is valid from here { let y = 10; // y is valid from here println!("x = {}, y = {}", x, y); // Both valid } // y goes out of scope println!("x = {}", x); // x still valid // println!("y = {}", y); // Error: y not found }

Ownership Transfer (Move)

fn main() { // Move semantics for heap-allocated types let s1 = String::from("hello"); let s2 = s1; // s1 is MOVED to s2 // println!("{}", s1); // Error: s1 no longer valid println!("{}", s2); // OK: s2 owns the string // For stack-allocated types, copy happens instead of move let x = 5; let y = x; // x is COPIED to y println!("x = {}, y = {}", x, y); // Both valid // Move in functions let s = String::from("hello"); take_ownership(s); // s is moved into the function // println!("{}", s); // Error: s no longer valid let x = 5; make_copy(x); // x is copied, so still valid println!("x = {}", x); // OK } fn take_ownership(some_string: String) { println!("{}", some_string); } // some_string goes out of scope and is dropped fn make_copy(some_integer: i32) { println!("{}", some_integer); } // some_integer goes out of scope, but nothing special happens

Return Values and Scope

fn main() { let s1 = gives_ownership(); // gets ownership from function println!("s1 = {}", s1); let s2 = String::from("hello"); let s3 = takes_and_gives_back(s2); // s2 moved, s3 gets ownership // println!("{}", s2); // Error: s2 moved println!("s3 = {}", s3); // Returning multiple values with tuple let s4 = String::from("hello"); let (s5, len) = calculate_length(s4); // s4 moved, returns tuple println!("'{}' length = {}", s5, len); } fn gives_ownership() -> String { let some_string = String::from("yours"); // some_string created some_string // returned, ownership moves out } fn takes_and_gives_back(a_string: String) -> String { a_string // returned, ownership moves out } fn calculate_length(s: String) -> (String, usize) { let length = s.len(); (s, length) // returns tuple with string and length }

2. References and Borrowing

Immutable References

fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); // Pass reference println!("Length of '{}' is {}", s1, len); // s1 still valid // Multiple immutable references let s = String::from("hello"); let r1 = &s; let r2 = &s; println!("{}, {}", r1, r2); // OK: multiple immutable refs // References are immutable by default let s = String::from("hello"); let r = &s; // r.push_str(" world"); // Error: cannot mutate through immutable ref } fn calculate_length(s: &String) -> usize { // s is reference to String s.len() } // s goes out of scope, but doesn't drop what it refers to

Mutable References

fn main() { let mut s = String::from("hello"); change(&mut s); // Pass mutable reference println!("{}", s); // "hello, world" // Only one mutable reference allowed at a time let mut s = String::from("hello"); let r1 = &mut s; // let r2 = &mut s; // Error: cannot borrow as mutable more than once println!("{}", r1); // Can't mix mutable and immutable references let mut s = String::from("hello"); let r1 = &s; // immutable borrow let r2 = &s; // immutable borrow - OK // let r3 = &mut s; // Error: cannot borrow as mutable because also borrowed as immutable println!("{}, {}", r1, r2); // References go out of scope at the end of their last usage let mut s = String::from("hello"); let r1 = &s; let r2 = &s; println!("{}, {}", r1, r2); // r1 and r2 no longer used after this let r3 = &mut s; // OK: previous references no longer used println!("{}", r3); } fn change(some_string: &mut String) { some_string.push_str(", world"); }

Dangling References

fn main() { // This function would create a dangling reference // let reference_to_nothing = dangle(); // Error // This works because string is returned directly let s = no_dangle(); println!("{}", s); } // This function tries to return a reference to a value that will be dropped // fn dangle() -> &String { // let s = String::from("hello"); // &s // s will be dropped when function ends // } // Error: returns reference to local variable // Correct version returns the String directly (ownership moved) fn no_dangle() -> String { let s = String::from("hello"); s // Ownership moves out, nothing is dropped }

Rules of References

fn main() { // Rule 1: At any time, you can have either one mutable reference or any number of immutable references let mut s = String::from("hello"); // Many immutable references allowed let r1 = &s; let r2 = &s; println!("{} and {}", r1, r2); // r1 and r2 go out of scope here // Now one mutable reference allowed let r3 = &mut s; println!("{}", r3); // Rule 2: References must always be valid let reference; { let s = String::from("hello"); // reference = &s; // Error: s doesn't live long enough } // s dropped // println!("{}", reference); // This works because string literal has 'static lifetime let s = "hello"; let reference = &s; println!("{}", reference); }

3. The Slice Type

String Slices

fn main() { let s = String::from("hello world"); // Slices are references to parts of a String let hello = &s[0..5]; // "hello" let world = &s[6..11]; // "world" let whole = &s[..]; // "hello world" println!("hello: '{}'", hello); println!("world: '{}'", world); // Shorthand syntax let slice1 = &s[0..2]; // "he" let slice2 = &s[..2]; // "he" - same as above let slice3 = &s[3..]; // "lo world" // Slices are references, so they respect borrowing rules let mut s = String::from("hello"); let slice = &s[0..2]; // s.push_str(" world"); // Error: cannot borrow as mutable while immutable borrowed println!("{}", slice); // slice still valid } 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[..] // Return whole string if no space found } fn first_word_better(s: &str) -> &str { let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } } &s[..] } fn main() { let mut s = String::from("hello world"); let word = first_word(&s); // word gets reference to part of s // s.clear(); // Error: cannot clear while borrowed println!("first word: {}", word); // More flexible with &str let word = first_word_better(&s[..]); // Works with String slice let word = first_word_better("hello world"); // Works with string literal // String literals are slices let s = "Hello, world!"; // s: &str }

Array Slices

fn main() { let arr = [1, 2, 3, 4, 5]; // Array slices let slice = &arr[1..3]; // [2, 3] println!("{:?}", slice); // Function that works with any slice fn sum_slice(slice: &[i32]) -> i32 { let mut sum = 0; for &item in slice { sum += item; } sum } println!("Sum: {}", sum_slice(&arr)); println!("Sum: {}", sum_slice(&arr[2..4])); // Mutable array slices let mut arr = [1, 2, 3, 4, 5]; let slice = &mut arr[1..4]; for item in slice { *item *= 2; } println!("Modified array: {:?}", arr); // [1, 4, 6, 8, 5] }

4. Ownership and Functions

Function Parameters and Returns

fn main() { let s = String::from("hello"); // Ownership moves into function takes_ownership(s); // println!("{}", s); // Error: s moved let x = 5; // x is copied (implements Copy) makes_copy(x); println!("x = {}", x); // OK // Getting ownership back let s1 = String::from("hello"); let s2 = takes_and_returns(s1); // println!("{}", s1); // Error: s1 moved println!("{}", s2); // OK // Multiple values let s3 = String::from("hello"); let (s4, len) = calculate_length_with_owner(s3); println!("'{}' length = {}", s4, len); } fn takes_ownership(some_string: String) { println!("{}", some_string); } // some_string dropped fn makes_copy(some_integer: i32) { println!("{}", some_integer); } // some_integer goes out of scope, nothing special fn takes_and_returns(some_string: String) -> String { println!("Processing: {}", some_string); some_string // returned, ownership moves out } fn calculate_length_with_owner(s: String) -> (String, usize) { let length = s.len(); (s, length) }

References in Functions

fn main() { let s1 = String::from("hello"); let len = calculate_length_ref(&s1); println!("'{}' length = {}", s1, len); // s1 still valid let mut s2 = String::from("hello"); change(&mut s2); println!("{}", s2); // Multiple parameters with references let s3 = String::from("long string is long"); let s4 = String::from("xyz"); let result = longest(&s3, &s4); println!("Longest: {}", result); } fn calculate_length_ref(s: &String) -> usize { s.len() } fn change(s: &mut String) { s.push_str(", world"); } // Function with multiple references - needs lifetime parameter fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }

5. Ownership with Structs

Structs Containing Owned Data

#[derive(Debug)] struct User { username: String, // Owned String email: String, // Owned String sign_in_count: u64, active: bool, } #[derive(Debug)] struct File { name: String, data: Vec<u8>, } impl File { fn new(name: &str) -> Self { File { name: String::from(name), data: Vec::new(), } } fn write(&mut self, data: &[u8]) { self.data.extend_from_slice(data); } fn read(&self) -> &[u8] { &self.data } } fn main() { // Ownership of struct fields let user1 = User { email: String::from("[email protected]"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; // Moving a struct moves all fields let user2 = user1; // user1 moved to user2 // println!("{:?}", user1); // Error: user1 moved // Creating a new user with some moved fields let user3 = User { email: String::from("[email protected]"), ..user2 // user2 partially moved }; // println!("{:?}", user2); // Error: user2 partially moved // Working with File let mut file = File::new("data.txt"); file.write(b"Hello, world!"); println!("File: {:?}", file); // Borrowing struct fields let data = file.read(); println!("Data: {:?}", data); }

Structs with References

// Struct can hold references, but needs lifetime annotation #[derive(Debug)] struct Book<'a> { title: &'a str, // Reference to string slice author: &'a str, // Reference to string slice year: u32, } #[derive(Debug)] struct Excerpt<'a> { content: &'a str, book: Book<'a>, } fn main() { let title = String::from("The Rust Programming Language"); let author = String::from("Steve Klabnik"); let book = Book { title: &title, // Borrow from title author: &author, // Borrow from author year: 2019, }; println!("Book: {:?}", book); { let excerpt_content = String::from("Some excerpt from the book..."); let excerpt = Excerpt { content: &excerpt_content, book: book, // book is moved here }; println!("Excerpt: {:?}", excerpt); // excerpt_content goes out of scope here } // excerpt dropped, but book also dropped because it was moved // println!("{:?}", book); // Error: book moved }

6. Ownership with Enums

Enums with Owned Data

#[derive(Debug)] enum Message { Quit, Move { x: i32, y: i32 }, Write(String), // Owns a String ChangeColor(i32, i32, i32), } #[derive(Debug)] enum IpAddr { V4(String), // Owns the address string V6(String), // Owns the address string } #[derive(Debug)] enum WebEvent { PageLoad, KeyPress(char), Click { x: i64, y: i64 }, } fn main() { // Ownership moves when enum variants are created let msg1 = Message::Write(String::from("hello")); // Matching consumes ownership unless we use references match msg1 { Message::Write(text) => println!("Message: {}", text), _ => (), } // text dropped here // println!("{:?}", msg1); // Error: msg1 moved // Borrowing in match let msg2 = Message::Write(String::from("world")); match &msg2 { // Borrow msg2 Message::Write(text) => println!("Borrowed: {}", text), _ => (), } println!("Still have: {:?}", msg2); // OK // Vec of enums with owned data let messages = vec![ Message::Write(String::from("first")), Message::Write(String::from("second")), Message::Quit, ]; for msg in &messages { // Borrow to avoid moving if let Message::Write(text) = msg { println!("Text: {}", text); } } println!("Still have messages: {:?}", messages); }

Option and Result Ownership

fn main() { // Option with owned data let s = String::from("hello"); let opt = Some(s); // println!("{}", s); // Error: s moved into opt // Taking ownership from Option let mut opt = Some(String::from("hello")); if let Some(value) = opt { println!("Got: {}", value); // value owns the string } // value dropped // println!("{:?}", opt); // opt is None now? Actually opt was moved // Better: take ownership without moving let mut opt = Some(String::from("hello")); if let Some(ref value) = opt { println!("Borrowed: {}", value); // value is &String } println!("Still have: {:?}", opt); // OK // Result with owned data let result: Result<String, std::io::Error> = Ok(String::from("success")); match &result { Ok(s) => println!("Success: {}", s), Err(e) => println!("Error: {}", e), } println!("Result still: {:?}", result); // OK // Map transforms ownership let result = Ok::<_, std::io::Error>(String::from("hello")); let len = result.map(|s| s.len()); // s moved, returns Result<usize, Error> // println!("{:?}", result); // Error: result moved println!("Length: {:?}", len); }

7. Ownership with Collections

Vectors and Ownership

fn main() { // Vector owns its elements let mut v = Vec::new(); let s1 = String::from("hello"); let s2 = String::from("world"); v.push(s1); // s1 moved into vector v.push(s2); // s2 moved into vector // println!("{}, {}", s1, s2); // Error: both moved println!("Vector: {:?}", v); // Accessing elements - borrowing let v = vec![String::from("hello"), String::from("world")]; let first = &v[0]; // Borrows from vector println!("First: {}", first); println!("Vector still: {:?}", v); // OK // Removing elements returns ownership let mut v = vec![String::from("hello"), String::from("world")]; let removed = v.remove(0); // Ownership moves to removed println!("Removed: {}", removed); println!("Remaining: {:?}", v); // Iterating - by value consumes let v = vec![1, 2, 3]; for i in v { // v consumed println!("{}", i); } // println!("{:?}", v); // Error: v moved // Iterating - by reference doesn't consume let v = vec![1, 2, 3]; for i in &v { println!("{}", i); } println!("Still have: {:?}", v); // OK }

HashMap and Ownership

use std::collections::HashMap; fn main() { let mut scores = HashMap::new(); // Inserting takes ownership of keys and values let team_name = String::from("Blue"); let team_score = 10; scores.insert(team_name, team_score); // team_name moved // println!("{}", team_name); // Error: moved println!("Score still exists: {}", team_score); // i32 is Copy // Getting values - returns reference let score = scores.get("Blue"); // Returns Option<&i32> if let Some(&s) = score { println!("Score: {}", s); } // Entry API let mut map = HashMap::new(); map.insert(String::from("key1"), String::from("value1")); // or_insert returns mutable reference to value let value = map.entry(String::from("key1")).or_insert(String::from("default")); println!("Value: {}", value); // "value1" // value is &mut String value.push_str(" modified"); println!("Map: {:?}", map); // "key1": "value1 modified" }

8. Ownership with Custom Types

Implementing Drop

struct CustomResource { name: String, data: Vec<u8>, } impl CustomResource { fn new(name: &str) -> Self { println!("Creating resource: {}", name); CustomResource { name: String::from(name), data: vec![0; 1024], } } fn use_resource(&self) { println!("Using resource: {}", self.name); } } impl Drop for CustomResource { fn drop(&mut self) { println!("Dropping resource: {}", self.name); // Clean up any resources here self.data.clear(); } } fn main() { { let resource = CustomResource::new("temporary"); resource.use_resource(); } // resource dropped here - Drop called automatically println!("After scope"); // Early drop with std::mem::drop let resource = CustomResource::new("early"); resource.use_resource(); drop(resource); // Explicitly drop early // resource.use_resource(); // Error: resource dropped // Resources dropped in reverse order of creation let a = CustomResource::new("A"); let b = CustomResource::new("B"); let c = CustomResource::new("C"); // Dropped: C, B, A }

Copy and Clone Traits

#[derive(Debug, Clone)] struct Person { name: String, // Not Copy (String doesn't implement Copy) age: u32, // Copy } #[derive(Debug, Clone, Copy)] struct Point { x: i32, y: i32, } fn main() { // Copy types (stack-only) let x = 5; let y = x; // Copy println!("x = {}, y = {}", x, y); // Both valid let p1 = Point { x: 10, y: 20 }; let p2 = p1; // Copy (because Point implements Copy) println!("p1 = {:?}, p2 = {:?}", p1, p2); // Both valid // Clone types (heap data) let s1 = String::from("hello"); let s2 = s1.clone(); // Explicit clone needed println!("s1 = {}, s2 = {}", s1, s2); // Both valid let person1 = Person { name: String::from("Alice"), age: 30, }; let person2 = person1.clone(); // Clone, not copy println!("person1 = {:?}", person1); println!("person2 = {:?}", person2); // Clone is explicit let v1 = vec![1, 2, 3]; let v2 = v1.clone(); println!("v1 = {:?}, v2 = {:?}", v1, v2); }

9. Advanced Ownership Patterns

Reference Counting with Rc

use std::rc::Rc; #[derive(Debug)] enum List { Cons(i32, Rc<List>), Nil, } use List::{Cons, Nil}; #[derive(Debug)] struct GraphNode { value: i32, edges: Vec<Rc<GraphNode>>, // Multiple nodes can share ownership } fn main() { // Rc allows multiple owners let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); println!("Reference count after a: {}", Rc::strong_count(&a)); let b = Cons(3, Rc::clone(&a)); // Increase reference count println!("Reference count after b: {}", Rc::strong_count(&a)); { let c = Cons(4, Rc::clone(&a)); println!("Reference count after c: {}", Rc::strong_count(&a)); } // c goes out of scope, reference count decreases println!("Reference count after c: {}", Rc::strong_count(&a)); // Graph with shared ownership let node1 = Rc::new(GraphNode { value: 1, edges: vec![], }); let node2 = Rc::new(GraphNode { value: 2, edges: vec![Rc::clone(&node1)], }); let node3 = Rc::new(GraphNode { value: 3, edges: vec![Rc::clone(&node1), Rc::clone(&node2)], }); println!("Node1 reference count: {}", Rc::strong_count(&node1)); println!("Node2 reference count: {}", Rc::strong_count(&node2)); println!("Node3 reference count: {}", Rc::strong_count(&node3)); }

Interior Mutability with RefCell

use std::cell::RefCell; use std::rc::Rc; #[derive(Debug)] struct MockMessenger { sent_messages: RefCell<Vec<String>>, } impl MockMessenger { fn new() -> Self { MockMessenger { sent_messages: RefCell::new(vec![]), } } fn send(&self, message: &str) { // Even though self is immutable, we can modify through RefCell self.sent_messages.borrow_mut().push(String::from(message)); } fn message_count(&self) -> usize { self.sent_messages.borrow().len() } } // Combining Rc and RefCell for shared mutable ownership #[derive(Debug)] struct SharedData { value: RefCell<i32>, } fn main() { let messenger = MockMessenger::new(); messenger.send("Hello"); messenger.send("World"); println!("Messages sent: {}", messenger.message_count()); println!("Messages: {:?}", messenger.sent_messages.borrow()); // Rc<RefCell<T>> pattern let shared = Rc::new(SharedData { value: RefCell::new(42), }); let shared1 = Rc::clone(&shared); let shared2 = Rc::clone(&shared); // Modify through one reference *shared.value.borrow_mut() += 10; // See change through another reference println!("Value from shared1: {}", shared1.value.borrow()); println!("Value from shared2: {}", shared2.value.borrow()); // Borrowing rules are enforced at runtime with RefCell let borrow1 = shared.value.borrow(); // let borrow2 = shared.value.borrow_mut(); // This would panic at runtime println!("Borrowed: {}", borrow1); }

Reference Cycles and Weak

use std::rc::{Rc, Weak}; use std::cell::RefCell; #[derive(Debug)] struct Node { value: i32, parent: RefCell<Weak<Node>>, // Weak reference to avoid cycles children: RefCell<Vec<Rc<Node>>>, } fn main() { let leaf = Rc::new(Node { value: 3, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]), }); println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch); println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); // Strong and weak counts println!("branch strong = {}, weak = {}", Rc::strong_count(&branch), Rc::weak_count(&branch)); println!("leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf)); // Upgrade weak to strong temporarily if let Some(parent) = leaf.parent.borrow().upgrade() { println!("leaf's parent = {}", parent.value); } }

10. Common Ownership Patterns

Builder Pattern

#[derive(Debug, Clone)] struct Pizza { name: String, size: String, toppings: Vec<String>, } struct PizzaBuilder { name: String, size: String, toppings: Vec<String>, } impl PizzaBuilder { fn new(name: &str) -> Self { PizzaBuilder { name: name.to_string(), size: "medium".to_string(), toppings: Vec::new(), } } fn size(mut self, size: &str) -> Self { self.size = size.to_string(); self } fn add_topping(mut self, topping: &str) -> Self { self.toppings.push(topping.to_string()); self } fn build(self) -> Pizza { Pizza { name: self.name, size: self.size, toppings: self.toppings, } } } fn main() { let pizza = PizzaBuilder::new("Margherita") .size("large") .add_topping("cheese") .add_topping("tomato") .add_topping("basil") .build(); println!("Pizza: {:?}", pizza); // Pizza owns all its data let Pizza { name, size, toppings } = pizza; println!("Name: {}, Size: {}, Toppings: {:?}", name, size, toppings); }

RAII Pattern

use std::fs::File; use std::io::Write; struct LogFile { file: File, path: String, } impl LogFile { fn new(path: &str) -> std::io::Result<Self> { let file = File::create(path)?; Ok(LogFile { file, path: path.to_string(), }) } fn write_log(&mut self, message: &str) -> std::io::Result<()> { writeln!(self.file, "{}", message) } } impl Drop for LogFile { fn drop(&mut self) { println!("Closing log file: {}", self.path); // File automatically closed when dropped } } struct Mutex<T> { data: T, locked: bool, } impl<T> Mutex<T> { fn new(data: T) -> Self { Mutex { data, locked: false } } fn lock(&mut self) -> MutexGuard<T> { self.locked = true; MutexGuard { mutex: self } } } struct MutexGuard<'a, T> { mutex: &'a mut Mutex<T>, } impl<'a, T> Drop for MutexGuard<'a, T> { fn drop(&mut self) { self.mutex.locked = false; println!("Mutex unlocked"); } } impl<'a, T> std::ops::Deref for MutexGuard<'a, T> { type Target = T; fn deref(&self) -> &T { &self.mutex.data } } impl<'a, T> std::ops::DerefMut for MutexGuard<'a, T> { fn deref_mut(&mut self) -> &mut T { &mut self.mutex.data } } fn main() { // File automatically closed when log goes out of scope { let mut log = LogFile::new("app.log").unwrap(); log.write_log("Application started").unwrap(); log.write_log("Processing data").unwrap(); } // log dropped here // Mutex guard releases lock when dropped let mut mutex = Mutex::new(42); { let mut guard = mutex.lock(); *guard += 10; println!("Value: {}", *guard); } // guard dropped, mutex unlocked println!("Mutex locked: {}", mutex.locked); }

Ownership in Threads

use std::thread; fn main() { let data = vec![1, 2, 3, 4, 5]; // Move ownership to thread let handle = thread::spawn(move || { println!("Data from thread: {:?}", data); data.len() }); // println!("{:?}", data); // Error: data moved let length = handle.join().unwrap(); println!("Thread returned length: {}", length); // Multiple threads with scoped threads let mut data = vec![1, 2, 3, 4, 5]; // Use scoped threads for borrowing thread::scope(|s| { for i in &mut data { s.spawn(move || { *i += 1; println!("Increment: {}", i); }); } }); // All threads complete, data available again println!("Data after threads: {:?}", data); }

11. Common Ownership Questions

When to Use What?

fn main() { // Use owned types (String, Vec<T>) when: // - You need to store data long-term // - Data comes from external source // - You need to modify data let owned_string = String::from("hello"); let owned_vec = vec![1, 2, 3]; // Use references (&str, &[T]) when: // - You're just reading data // - You don't need to store data // - Data comes from an existing owner let borrowed_string: &str = &owned_string; let borrowed_slice: &[i32] = &owned_vec; // Use Rc when: // - Multiple parts of code need to own data // - Data is read-only after creation use std::rc::Rc; let shared = Rc::new(vec![1, 2, 3]); let shared1 = Rc::clone(&shared); let shared2 = Rc::clone(&shared); // Use RefCell when: // - Need interior mutability // - Can guarantee borrowing rules at runtime use std::cell::RefCell; let mutable = RefCell::new(42); *mutable.borrow_mut() += 1; // Use Rc<RefCell<T>> when: // - Need multiple owners with mutability let shared_mutable = Rc::new(RefCell::new(42)); let sm1 = Rc::clone(&shared_mutable); let sm2 = Rc::clone(&shared_mutable); *sm1.borrow_mut() += 10; println!("Value: {}", sm2.borrow()); }

Debugging Ownership Issues

// Common ownership errors and solutions fn main() { // Error 1: Use after move let s = String::from("hello"); let t = s; // println!("{}", s); // Error: value used after move // Solution: Use clone if you need both let s = String::from("hello"); let t = s.clone(); println!("s = {}, t = {}", s, t); // OK // Error 2: Cannot move out of reference let s = String::from("hello"); let r = &s; // let t = *r; // Error: cannot move out of &String // Solution: Clone or use reference let t = r.clone(); println!("r = {}, t = {}", r, t); // OK // Error 3: Cannot borrow as mutable more than once let mut s = String::from("hello"); let r1 = &mut s; // let r2 = &mut s; // Error: second mutable borrow println!("{}", r1); // Solution: Use scopes let mut s = String::from("hello"); { let r1 = &mut s; println!("{}", r1); } let r2 = &mut s; println!("{}", r2); // Error 4: Cannot modify while borrowed let mut s = String::from("hello"); let r = &s; // s.push_str(" world"); // Error: cannot modify while borrowed println!("{}", r); // Solution: Finish using reference first let mut s = String::from("hello"); { let r = &s; println!("{}", r); } s.push_str(" world"); println!("{}", s); }

Conclusion

Ownership is the cornerstone of Rust's memory safety guarantees:

Key Takeaways

1. Each value has a single owner at any given time
2. When owner goes out of scope, value is dropped
3. Ownership can be transferred (moved) to other variables
4. References allow borrowing without taking ownership
5. Rules prevent data races and dangling references
6. Lifetimes ensure references are valid

Ownership Rules Summary

Operation	Stack Types (Copy)	Heap Types (Move)
Assignment	Copy	Move
Pass to function	Copy	Move
Return from function	Copy	Move
Store in struct	Copy	Move

Reference Rules Summary

• Either: One mutable reference
• Or: Any number of immutable references
• But not both: Can't mix mutable and immutable
• References must always be valid (no dangling)

Best Practices

1. Use references (borrowing) whenever possible instead of taking ownership
2. Clone only when necessary - it's expensive
3. Use Rc for shared ownership of immutable data
4. Use RefCell for interior mutability when you need to modify through shared references
5. Design APIs with clear ownership semantics
6. Leverage the type system to encode ownership at compile time

Ownership is what makes Rust unique - it provides memory safety without garbage collection, enables fearless concurrency, and gives you fine-grained control over resources. While it may seem challenging at first, mastering ownership is key to becoming proficient in Rust.