Ownership

1// Stack data: size known at compile time2let x: i32 = 5;      // stored entirely on the stack3let y: bool = true;  // stored entirely on the stack4let arr: [i32; 3] = [1, 2, 3]; // stored on the stack56// Heap data: size not known at compile time, or can grow7let s = String::from("hello"); // metadata on stack, content on heap8let v = vec![1, 2, 3];        // metadata on stack, elements on heap

1fn main() {2    // s is not valid here — not yet declared34    {5        let s = String::from("hello"); // s is valid from this point67        println!("{s}");    // do stuff with s8    }9    // The scope is now over. Rust calls drop(s) automatically.10    // s is no longer valid — the heap memory is freed.1112    // println!("{s}"); // ERROR: use of possibly-uninitialized `s`1314    // This same pattern applies to any type that owns heap resources:15    {16        let v = vec![1, 2, 3];17        println!("{v:?}");18    } // v is dropped here — Vec frees its heap memory19}

1fn main() {2    // String literal: immutable, hardcoded in the binary, type is &str3    let s1: &str = "hello";45    // String: mutable, heap-allocated, growable, type is String6    let mut s2 = String::from("hello");7    s2.push_str(", world!"); // appends to the String8    s2.push('!');            // appends a single character910    println!("{s1}");  // hello11    println!("{s2}");  // hello, world!!1213    // String has three parts stored on the stack:14    // 1. ptr — pointer to the heap memory holding the content15    // 2. len — current length in bytes16    // 3. capacity — total bytes allocated on the heap17    println!("len={}, capacity={}", s2.len(), s2.capacity());18} // s2 goes out of scope; drop is called; heap memory is freed19  // s1 has no heap memory to free

1fn main() {2    let s1 = String::from("hello");3    let s2 = s1; // s1 is MOVED to s2 — s1 is now invalid45    // println!("{s1}"); // ERROR: borrow of moved value: `s1`6    println!("{s2}"); // OK — s2 is the new owner78    // Why not a "shallow copy"?9    // Rust invalidates s1 to prevent BOTH s1 and s2 from trying10    // to free the same heap memory when they go out of scope.1112    // Stack-only types (Copy types) behave differently:

1fn main() {2    let s1 = String::from("hello");3    let s2 = s1.clone(); // deep copy — duplicates heap data45    println!("s1={s1}, s2={s2}"); // Both valid — s1 was not moved6}

1fn main() {2    // These types all implement Copy:3    let a: i32  = 5;    let b = a;  // copied4    let c: f64  = 3.14; let d = c;  // copied5    let e: bool = true; let f = e;  // copied6    let g: char = 'z';  let h = g;  // copied78    // Tuples implement Copy only if all fields implement Copy:9    let t1: (i32, f64) = (1, 2.0);10    let t2 = t1; // copied — both i32 and f64 are Copy1112    // Fixed-size arrays of Copy types also implement Copy:

1fn main() {2    let s = String::from("hello");34    takes_ownership(s);       // s's value moves into the function5    // println!("{s}");       // ERROR: s was moved — no longer valid here67    let x = 5;8    makes_copy(x);            // i32 is Copy — x is still valid9    println!("{x}");          // OK10}1112fn takes_ownership(some_string: String) {13    println!("{some_string}");14} // some_string goes out of scope; drop is called; heap memory freed1516fn makes_copy(some_integer: i32) {17    println!("{some_integer}");18} // some_integer goes out of scope — nothing special happens (no heap)

1fn main() {2    // gives_ownership transfers its return value to s13    let s1 = gives_ownership();4    println!("{s1}");56    let s2 = String::from("hello");78    // s2 is moved into takes_and_gives_back9    // which also returns a value, moved into s310    let s3 = takes_and_gives_back(s2);11    // println!("{s2}"); // ERROR: s2 was moved12    println!("{s3}");