Lição 12: Propriedade dos Sistemas

Narrativa

Piloto, hoje você aprende sobre o sistema de propriedade do Rust. Cada dado no seu mecha tem um único proprietário — o componente que o controla. Quando você transfere propriedade de um sistema para outro, o original perde o controle. Isso garante que ninguém tente acessar dados que já foram transferidos para outro sistema.

Conceito

Ownership (Propriedade) é o mecanismo do Rust para gerenciar memória:

• Cada valor tem um único dono (owner)
• Quando o dono sai do escopo, o valor é dropped
• Transferir propriedade move o valor para outro componente
• Emprestar cria referências temporárias sem transferir ownership

// Transferência de propriedade
let dado = String::from("dados");
let novo_dono = dado;  // dado não pode mais ser usado — foi movido

// Empréstimo (usa outro valor, pois `dado` já foi movido acima)
let outro = String::from("teste");
let referencia = &outro;  // Não transfere propriedade

Requisitos

• Entrada: Valores String, &str, &mut String
• Processamento: Transferir, clonar, emprestar
• Saída: Resultados das operações de ownership

Design de Dados

pub fn transferir_propriedade(dado: String) -> String;
pub fn clonar_dado(dado: &str) -> String;
pub fn emprestar_imutavel(dado: &str) -> usize;
pub fn emprestar_mutavel(dado: &mut String) -> bool;
pub fn devolver_propriedade(dado: String) -> String;

Diagrama Conceitual

flowchart TD
    A[Dado] --> B[Propriedade]
    B --> C{Mover/Clonar}
    C -->|Mover| D[Transferência]
    C -->|Clonar| E[Cópia]
    D --> F[Owner Anterior Inválido]
    E --> G[Ambos Válidos]

Funções e Módulos

pub fn transferir_propriedade(_dado: String) -> String { todo!() }
pub fn clonar_dado(_dado: &str) -> String { todo!() }
pub fn emprestar_imutavel(_dado: &str) -> usize { todo!() }
pub fn emprestar_mutavel(_dado: &mut String) -> bool { todo!() }
pub fn devolver_propriedade(_dado: String) -> String { todo!() }

Exemplo do Conceito

fn main() {
    // Ownership
    let dado = String::from("importante");
    let outro = dado;  // Transferência
    // println!("{}", dado);  // ERRO: dado não é mais válido

    // Clone
    let texto = String::from("teste");
    let clone = texto.clone();  // Cópia independente
    println!("{} {}", texto, clone);  // Ambos válidos

    // Empréstimo
    let tamanho = texto.len();  // Referência, não transferência
}

Missão

1. Implementar transferir_propriedade: Ilustra move semantics — caller transfere ownership da String para a função, que a retorna ao caller (move-in seguido de move-out)
2. Implementar clonar_dado: Recebe &str e retorna String (clone semantics)
3. Implementar emprestar_imutavel: Recebe &str e retorna tamanho (referência)
4. Implementar emprestar_mutavel: Recebe &mut String e retorna bool (modifica). A função deve modificar a String recebida — por exemplo, adicionando um sufixo (como push_str("!") ou push('!')) — e retornar true indicando que a modificação foi realizada. O teste verifica que a String original foi de fato alterada após a chamada
5. Implementar devolver_propriedade: Ilustra retorno explícito de ownership — a função recebe uma String owned e devolve esse mesmo valor ao caller, reforçando que o caller volta a ser dono do dado

flowchart TD
    A[Testes] --> B[transferir_propriedade]
    B --> C[clonar_dado]
    C --> D[emprestar_imutavel]
    D --> E[emprestar_mutavel]
    E --> F[devolver_propriedade]

Como Executar

cargo test
cargo clippy -- -D warnings
cargo fmt --check

Dicas

• Dados movidos não podem ser usados depois
• Clone cria uma cópia profunda e independente
• & referências não transferem ownership
• &mut permite modificar sem transferir
• drop é chamado automaticamente quando owner sai do escopo