Empréstimos & Referências

Empréstimos permitem que o código use dados sem assumir a propriedade. Referências compartilhadas (&T) permitem leitores concorrentes. Referências mutáveis (&mut T) concedem acesso exclusivo de escrita.

Receita

fn push_char(s: &mut String, c: char) {
    s.push(c);
}
 
fn display(s: &str) {
    println!("{s}");
}
 
fn main() {
    let mut msg = String::from("hi");
    display(&msg);
    push_char(&mut msg, '!');
    display(&msg);
}

Quando usar isso: APIs principalmente de leitura com &T, construtores e mutação com &mut T, evitando transferência de propriedade.

Exemplo de Trabalho

fn split_at_mut<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) {
    slice.split_at_mut(mid)
}
 
fn main() {
    let mut data = vec![1, 2, 3, 4];
    let (left, right) = split_at_mut(&mut data, 2);
    left[0] = 10;
    right[0] = 40;
    println!("{:?}", data);
}

O que isso demonstra:

• &mut exclusivo para mutação
• split_at_mut cria com segurança duas fatias &mut não sobrepostas
• O empréstimo termina quando left/right saem do escopo
• &str/&[T] seguem as mesmas regras

Mergulho Profundo

Regras de Alias

1. Qualquer número de &T ou exatamente um &mut T
2. Referências devem sempre ser válidas (não pendentes)
3. O escopo da referência termina no último uso (NLL) - veja página dedicada

Reemprestar

let mut s = String::from("a");
let r1 = &mut s;
let r2 = &*r1; // Reempresta compartilhado enquanto o empréstimo mutável está ativo em um subconjunto
println!("{r2}");

Coerção &

&String -> &str, &Vec<T> -> &[T] via Deref.

Armadilhas

• Dois &mut para a mesma variável - Erro de compilação. Correção: Dividir escopos, split_at_mut, ou mutabilidade interior.
• Leitura enquanto &mut está ativo - Proibido. Correção: Terminar o empréstimo mutável antes da leitura compartilhada.
• Retornar & para dados locais - Referência pendente. Correção: Retornar valor de propriedade ou vincular o tempo de vida à entrada.
• Empréstimo mutável entre chamadas de função que detêm &mut - Estende o empréstimo. Correção: Limitar o escopo do empréstimo com blocos.
• Iterar com coleção &mut enquanto adiciona elementos - Invalidação do iterador. Correção: Coletar índices primeiro ou usar drain.

Alternativas

FAQs

Relacionado

• O Verificador de Empréstimos - raciocínio do compilador
• Tempos de Vida Explicados - por que 'a existe
• Tempos de Vida Não Lexicais e Reemprestos - comportamento moderno
• Referências e Fatias - noções básicas de fatias

Versões da Pilha: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.