Busque em todas as páginas da documentação
Propriedade é o modelo de memória central do Rust: um proprietário por valor, movimentações transferem responsabilidade e empréstimos permitem acesso temporário sob regras de tempo de compilação. Esta página apresenta as ideias antes da seção de Propriedade.
fn main() {
let s = String::from("hello");
let t = s; // move
// println!("{s}"); // erro: movido
let len = measure(&t);
println!("{t} tem o comprimento {len}");
}
fn measure(text: &String) -> usize {
text.len()
}Quando usar isto: Sempre que você passar dados entre funções, armazená-los em structs ou compartilhá-los entre threads - as regras de propriedade se aplicam em todos os lugares.
fn append(mut s: String, suffix: &str) -> String {
s.push_str(suffix);
s
}
fn print_both(first: &str, second: &str) {
println!("{first} {second}");
}
fn main() {
let greeting = String::from("Hello");
let full = append(greeting, ", Rust!");
let slice: &str = &full;
print_both(slice, "welcome.");
}O que isso demonstra:
append assume a propriedade de greeting e retorna String atualizado&str empresta dados de string sem possuí-losString é coagido para &str via Deref (coerção de deref)Copy duplicam na atribuição (i32, bool, char)String, Vec) movem na atribuiçãodrop é executado automaticamente&T, &mut T) são visualizações emprestadas com limites de tempo de vidalet a = 5;
let b = a; // Cópia - ambos válidos
let v1 = vec![1, 2];
let v2 = v1; // Movimentação - v1 inválido&T ou exatamente um &mut T por vezlet x = 42; // pilha
let s = String::from("x"); // ponteiro + capacidade + len na pilha, bytes no heapString. Correção: Clone (s.clone()) se precisar de uma duplicata, ou empreste em vez disso.fn print(s: String) força os chamadores a desistirem da string. Correção: Use &str ou &String.&mut para os mesmos dados - Erro de compilação. Correção: Reestruture escopos, use RefCell para mutabilidade interna single-threaded, ou divida campos.fn bad() -> &String não pode funcionar. Correção: Retorne valor próprio ou receba entrada por referência com tempo de vida vinculado à entrada.Cow.| Alternativa | Use Quando | Não Use Quando |
|---|---|---|
Empréstimo &T | Acesso somente leitura | O chamador deve manter a propriedade para o seu tempo de vida de retorno |
Clone | Duplicata barata necessária | Caminho crítico com dados grandes |
Rc/Arc | Propriedade compartilhada | Proprietário único e claro existe |
Cow<'a, T> | Talvez empreste, talvez possua | A propriedade é sempre clara |
Propriedade e tempos de vida liberam memória deterministicamente em tempo de compilação para a maioria do código, com custo zero de GC em tempo de execução.
Escalares, tuplas/arrays de tipos Copy, e tipos explicitamente marcados como Copy. String e Vec não são Copy.
Clone explicitamente. Não há cópia implícita para tipos não-Copy.
Um trait executado automaticamente quando um valor sai do escopo. String libera memória do heap em drop.
Passar por valor move. Passar por referência &T empresta sem mover a propriedade.
Sim. Campos são possuídos como variáveis locais. A struct é a proprietária de seus campos.
Uma visualização emprestada em dados contíguos: &[T] ou &str. Slices não possuem memória.
Movimentações são cópias de ponteiros para tipos de heap. Nenhuma contagem de referência a menos que você escolha Rc/Arc.
Dados possuídos são movidos para futures. Send/Sync vincula estado compartilhado entre tarefas (veja a seção Concorrência).
Veja a seção Propriedade começando com Noções Básicas de Propriedade.
Copy/Clone& vs &mutVersõ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+.
Revisado por Chris St. John·Última atualização: 19 de jul. de 2026