Lição 13: Apontadores de Combate

Narrativa

Piloto, durante o combate você precisa apontar sensores para dados específicos sem copiar tudo. Os apontadores do Rust — referências e slices — são como miras calibradas: permitem ler ou modificar dados sem tomar posse deles. Uma referência imutável é como um scanner de longo alcance; uma mutável é como um braço mecânico que ajusta o alvo. Domine os apontadores e seu mecha opera com precisão cirúrgica.

Conceito

Referências e Slices são mecanismos do Rust para acessar dados sem ownership:

• &T — referência imutável: permite ler sem modificar
• &mut T — referência mutável: permite modificar sem ownership
• &[T] — slice: visão parcial de uma coleção
• &str — slice de string: visão parcial de texto
• Regra: múltiplas &T OU uma &mut T, nunca ambos ao mesmo tempo

let dado = String::from("combate");
let referencia: &str = &dado[0..3];  // "com" — slice sem copiar
let mut energia = 100;
let mut_ref = &mut energia;  // permite modificar
*mut_ref += 10;  // energia agora é 110

Requisitos

• Entrada: &str, &mut String, &[i32], &mut [i32]
• Processamento: Criar referências, slices, fatiar strings
• Saída: Dados apontados, confirmações de modificação

Design de Dados

pub fn criar_referencia(dado: &str) -> &str;
pub fn modificar_referencia(dado: &mut String) -> bool;
pub fn criar_slice(dados: &[i32]) -> &[i32];
pub fn modificar_slice(dados: &mut [i32]) -> usize;
pub fn fatiar_string(texto: &str, inicio: usize, fim: usize) -> &str;

Diagrama Conceitual

flowchart TD
    A[Dados Originais] --> B{Tipo de Apontador}
    B -->|&T| C[Referência Imutável]
    B -->|&mut T| D[Referência Mutável]
    B -->|&T| E[Slice]
    C --> F[Leitura sem posse]
    D --> G[Modificação sem posse]
    E --> H[Visão parcial]

Funções e Módulos

pub fn criar_referencia(_dado: &str) -> &str { todo!() }
pub fn modificar_referencia(_dado: &mut String) -> bool { todo!() }
pub fn criar_slice(_dados: &[i32]) -> &[i32] { todo!() }
pub fn modificar_slice(_dados: &mut [i32]) -> usize { todo!() }
pub fn fatiar_string(_texto: &str, _inicio: usize, _fim: usize) -> &str { todo!() }

Exemplo do Conceito

fn main() {
    // Referência imutável
    let texto = String::from("mecha");
    let ref_texto: &str = &texto;
    println!("Referência: {}", ref_texto);

    // Referência mutável
    let mut energia = String::from("50");
    let ref_mut = &mut energia;
    ref_mut.push_str(" unidades");
    println!("Modificado: {}", ref_mut);

    // Slice de array
    let dados = [10, 20, 30, 40, 50];
    let slice = &dados[1..4];
    println!("Slice: {:?}", slice);  // [20, 30, 40]

    // Slice de string
    let msg = "combate iniciado";
    let fatia = &msg[0..7];
    println!("Fatia: {}", fatia);  // "combate"
}

Missão

1. Implementar criar_referencia: Recebe &str e retorna a mesma referência
2. Implementar modificar_referencia: Recebe &mut String, modifica e retorna true
3. Implementar criar_slice: Recebe &[i32] e retorna o slice completo
4. Implementar modificar_slice: Recebe &mut [i32], modifica os valores e retorna o tamanho
5. Implementar fatiar_string: Recebe &str, inicio e fim, retorna a fatia

flowchart TD
    A[Testes] --> B[criar_referencia]
    B --> C[modificar_referencia]
    C --> D[criar_slice]
    D --> E[modificar_slice]
    E --> F[fatiar_string]

Como Executar

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

Dicas

• Referências não transferem ownership — o original permanece válido
• Só pode haver UMA referência mutável ou várias imutáveis, nunca ambas
• Slices são visões: não copiam dados, apenas apontam
• Cuidado com índices ao fatiar strings UTF-8
• O borrow checker garante segurança em tempo de compilação