How does ownership work in Rust?

07 Tem 02:01

Rust's ownership system is brutal but in the end it gives you superpowers if you understand it. At first I went crazy with those borrow checker errors that seem random, but once you grasp the concept of *move semantics*, everything clicks. For example, if you declare a `String` and assign it to another variable, ownership automatically moves: ```rust let s1 = String::from("Hello"); let s2 = s1; // s1 is no longer valid, ownership moved to s2 // println!("{}", s1); // This would error: value borrowed here after move ``` There you see the *move*: when assigned, the original variable gives up control (and "moves") to the new one. With types like `i32` that implement `Copy`, this doesn’t happen because they’re automatically copied (they’re fixed-size data on the stack). Then there are *lifetimes*, which act like labels telling the compiler how long each reference lives. For example: ```rust fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } ``` Here, `'a` ensures the returned reference **doesn’t outlive the inputs**, preventing *dangling pointers*. At first it was tough because in other languages you don’t have to think about this, but after struggling with errors like "borrowed value does not live long enough," I got the hang of it.