# Regras de Propriedade [[Rust language|Rust]] tem as seguintes regras de propriedade: - Cada valor em [[Rust language|Rust]] tem um _proprietário_. - Pode haver apenas um proprietário por vez. - Quando o proprietário sai do escopo, o valor será descartado. ## Propriedade e Funções Passar um valor para uma função funciona de forma semelhante à atribuição: - Passar um valor alocado na heap (como `String`) move a propriedade para a função. - Passar um valor alocado na stack (como `i32`, que é `Copy`) copia o valor, e a variável original permanece válida. ```rust fn main() { let s = String::from("hello"); // s comes into scope takes_ownership(s); // s's value moves into the function... // ... and so s is no longer valid here. // println!("After takes_ownership: {}", s); // This would be a compile-time error. let x = 5; // x comes into scope makes_copy(x); // x would move into the function, // but i32 is Copy, so it's okay to still // use x afterward. println!("After makes_copy: {}", x); // x is still valid. } // Here, x goes out of scope. Then s would go out of scope, but because its // value was moved, nothing special happens for s. fn takes_ownership(some_string: String) { // some_string comes into scope println!("Inside takes_ownership: {}", some_string); } // Here, some_string goes out of scope and `drop` is called. The backing // memory is freed. fn makes_copy(some_integer: i32) { // some_integer comes into scope println!("Inside makes_copy: {}", some_integer); } // Here, some_integer goes out of scope. Nothing special happens. ``` ## Retornando Valores e Escopo Retornar valores de funções também transfere a propriedade. ```rust fn main() { let s1 = gives_ownership(); // gives_ownership moves its return // value into s1. let s2 = String::from("hello"); // s2 comes into scope. let s3 = takes_and_gives_back(s2); // s2 is moved into takes_and_gives_back, // which also moves its return value into s3. // println!("s2 after takes_and_gives_back: {}", s2); // s2 is no longer valid here. println!("s1 = {}, s3 = {}", s1, s3); } // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing // happens. s1 goes out of scope and is dropped. fn gives_ownership() -> String { // gives_ownership will move its // return value into the function // that calls it. let some_string = String::from("yours"); // some_string comes into scope. some_string // some_string is returned and // moves out to the calling function. } // This function takes a String and returns one. fn takes_and_gives_back(a_string: String) -> String { // a_string comes into scope. a_string // a_string is returned and moves out to the calling function. } ``` A propriedade é uma parte fundamental do que torna Rust único. Embora possa parecer um pouco restritiva no início, ela fornece fortes garantias de segurança de memória em tempo de compilação, eliminando muitos bugs comuns encontrados em outras linguagens sem a sobrecarga de um coletor de lixo. Compreender a propriedade é crucial para escrever código Rust eficaz e seguro. Mais tarde, você aprenderá sobre empréstimo e tempos de vida, que fornecem mais flexibilidade, mantendo essas garantias de segurança. **:: Referência ::** [O que é Propriedade? - A Linguagem de Programação Rust](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html)