Ownership

Todo valor em Rust tem exatamente um dono (owner) por vez. Quando o dono sai do seu escopo (scope), o valor é descartado (drop) e sua memória é liberada automaticamente — sem coletor de lixo, sem free() manual. Essa única regra é o que permite ao Rust garantir a segurança de memória inteiramente em tempo de compilação.

Copy types vs. moves

Tipos simples como i32 implementam o trait Copy, então atribuir uma variável a outra apenas copia o valor — ambas continuam usáveis de forma independente.

fn main() {
    let x = 5;
    let y = x; // i32 is Copy, so x is still valid
    println!("x = {}, y = {}", x, y);
}

x = 5, y = 5

Um String não implementa Copy, porque é dono de dados alocados no heap. Atribuir s1 a s2 move o ownership — s1 não é mais válido depois disso, o que evita que ambas as variáveis tentem liberar a mesma memória mais tarde.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 is moved into s2

    println!("{}", s2);
}

hello

Como é um erro de move real

Isto é genuinamente o que o rustc reporta quando você tenta usar um valor depois que ele foi movido — capturado de uma execução real, não escrito para parecer plausível:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{}, world!", s1);
}

error[E0382]: borrow of moved value: `s1`
 --> main.rs:5:28
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 | 
5 |     println!("{}, world!", s1);
  |                            ^^ value borrowed here after move

error: aborting due to previous error

For more information about this error, try `rustc --explain E0382`.

Nada roda de fato — nenhum resultado, só o erro. Esse é todo o ponto: o Rust detecta um possível use-after-free em tempo de compilação, em uma linguagem sem coletor de lixo para limpar a bagunça se isso tivesse passado despercebido.

Próximo: referências e borrowing — como usar um valor sem tomar seu ownership.