Lição 8 de 18 · 25 min
Ownership
O coração do Rust: stack e heap, as três regras de posse, a diferença entre String e literal, move, clone e Copy, e posse em funções.
Ao terminar, você vai saber:
- Explicar com palavras simples a diferença entre stack e heap
- Enunciar as três regras de ownership
- Diferenciar String de um literal de texto
- Prever quando um valor é movido, copiado ou clonado
- Entender o que acontece com a posse ao chamar funções
Se existe uma ideia que faz do Rust o que ele é, é esta. Ownership (posse) é o conjunto de regras que o Rust usa para cuidar da memória sem coletor de lixo e sem você liberar nada na mão. Leia com calma: tudo que vem depois se apoia aqui.
Stack e heap, sem complicação
O programa guarda dados em dois lugares da memória.
A stack (pilha) é como uma pilha de pratos: você coloca em cima e tira de cima. É rápida e organizada, mas só aceita coisas com tamanho conhecido e fixo: um i32, um bool, um char, uma tupla de números. Quando a função termina, os pratos dela saem da pilha automaticamente.
A heap (monte) é como um depósito. Quando você precisa guardar algo cujo tamanho pode mudar, como um texto que o usuário digita, o programa pede um espaço no depósito e recebe o endereço desse espaço. O endereço (que tem tamanho fixo) fica na stack; o conteúdo fica na heap.
O problema clássico é: quem devolve o espaço do depósito, e quando? Esquecer de devolver desperdiça memória. Devolver duas vezes ou usar depois de devolver corrompe o programa. O ownership responde essa pergunta.
As três regras
- Cada valor no Rust tem um dono (uma variável).
- Só pode existir um dono por vez.
- Quando o dono sai de escopo, o valor é descartado e a memória é liberada.
Escopo é o trecho do código onde a variável vale, normalmente entre as chaves onde ela foi criada:
fn main() {
{
let recado = String::from("Volto já");
println!("{recado}");
} // aqui `recado` sai de escopo e a memória é liberada
// `recado` não existe mais aqui
println!("Fim");
}
Ninguém chamou “liberar”. O Rust insere isso sozinho no ponto exato em que o dono sai de escopo.
String e literal de texto
Até agora você usou texto escrito direto no código, como "Olá". Isso é um literal, do tipo &str. Ele fica embutido no próprio programa, é fixo e não pode crescer.
Para texto que muda ou que só é conhecido com o programa rodando, existe a String, que guarda o conteúdo na heap:
fn main() {
let literal = "bom dia"; // &str: fixo, embutido no programa
let mut texto = String::from("bom dia"); // String: na heap, pode crescer
texto.push_str(", Brasil");
println!("{literal} | {texto}");
}
A String é dona do seu conteúdo. É com ela que as regras de posse ficam visíveis.
Move: a posse muda de mão
Veja este código com números:
fn main() {
let a = 10;
let b = a;
println!("a = {a}, b = {b}");
}
Funciona, sem surpresa. Agora o mesmo com String:
fn main() {
let original = String::from("pão de queijo");
let copia = original;
println!("{original}");
println!("{copia}");
}
error[E0382]: borrow of moved value: `original`
|
2 | let original = String::from("pão de queijo");
| -------- move occurs because `original` has type `String`,
| which does not implement the `Copy` trait
3 | let copia = original;
| -------- value moved here
4 |
5 | println!("{original}");
| ^^^^^^^^^^ value borrowed here after move
O que aconteceu? A linha let copia = original; não copiou o texto. Ela copiou só o endereço e passou a posse para copia. Isso se chama move. Depois do move, original fica inválida, e o compilador proíbe usá-la.
Por que não deixar as duas valendo? Porque aí existiriam dois donos do mesmo espaço na heap. Quando os dois saíssem de escopo, a memória seria liberada duas vezes. Com o move, só existe um dono, então só existe uma liberação.
Pense na venda de um carro. Depois que você passa o documento para o comprador, o carro é dele. Você não pode mais sair dirigindo por aí, mesmo que ainda tenha uma chave reserva na gaveta.
Clone: cópia de verdade
Se você quer mesmo duas strings independentes, peça uma cópia completa com .clone():
fn main() {
let original = String::from("pão de queijo");
let copia = original.clone();
println!("original: {original}");
println!("cópia: {copia}");
}
Agora existem dois textos na heap, cada um com seu dono. O clone é explícito de propósito: copiar dados da heap custa tempo e memória, e o Rust quer que você veja esse custo no código. Quando bater o olho num .clone(), saiba que ali tem trabalho acontecendo.
Copy: tipos que se copiam sozinhos
E por que o exemplo com números funcionou? Porque i32 vive inteiro na stack, tem tamanho fixo e copiar é baratíssimo. Tipos assim implementam Copy: na atribuição, o valor é duplicado, e as duas variáveis continuam valendo.
São Copy:
- todos os inteiros (
i32,u8,usize…) e os floats (f64,f32); boolechar;- tuplas e arrays formados só por tipos
Copy, como(i32, f64)ou[u8; 4]; - o literal
&str, porque copiar uma referência não copia o texto.
Não são Copy: String, Vec e qualquer coisa que guarde dados na heap.
fn main() {
let ponto = (3, 4);
let outro_ponto = ponto; // copiado, as duas valem
println!("{ponto:?} {outro_ponto:?}");
let cidade = "Manaus";
let destino = cidade; // &str também é Copy
println!("{cidade} {destino}");
}
Ownership em funções
Passar um valor para uma função funciona igual a atribuir: tipos Copy são copiados, os outros são movidos para dentro da função.
fn main() {
let nome = String::from("Beatriz");
let ano = 2026;
mostrar_nome(nome); // `nome` foi movido para a função
mostrar_ano(ano); // `ano` foi copiado
println!("Ano ainda vale: {ano}");
// println!("{nome}"); // não compila: `nome` foi movido
}
fn mostrar_nome(texto: String) {
println!("Nome: {texto}");
} // aqui `texto` sai de escopo e a String é liberada
fn mostrar_ano(numero: i32) {
println!("Ano: {numero}");
}
A função mostrar_nome virou dona da String. Quando ela termina, a String é liberada. Por isso nome não pode ser usada depois.
Devolvendo a posse
Uma função também pode devolver um valor, e com ele a posse:
fn main() {
let saudacao = criar_saudacao();
let saudacao = adicionar_exclamacao(saudacao);
println!("{saudacao}");
}
fn criar_saudacao() -> String {
String::from("Bem-vinda") // a posse sai daqui para quem chamou
}
fn adicionar_exclamacao(mut texto: String) -> String {
texto.push('!');
texto // devolve a posse
}
Funciona, mas imagine fazer isso toda vez: passar o valor, receber de volta, passar de novo. Cansativo. E se a função só quer olhar o texto, sem ficar com ele? Para isso existem as referências, o assunto da próxima lição. Elas deixam você emprestar um valor sem passar a posse.
Resumo
- Stack guarda dados de tamanho fixo; heap guarda dados que podem crescer.
- Cada valor tem um único dono e é liberado quando o dono sai de escopo.
&strliteral é fixo;Stringé dona do texto na heap.- Atribuir ou passar uma
Stringpara função faz um move: a variável antiga deixa de valer. .clone()faz uma cópia completa e explícita.- Tipos
Copy(números,bool,char, tuplas deles) são copiados automaticamente.
Desafio
O programa abaixo não compila. Descubra por quê e corrija de duas formas diferentes: uma usando clone e outra fazendo a função devolver a posse.
fn main() {
let lista = String::from("arroz, feijão, ovo");
contar_letras(lista);
println!("Lista: {lista}");
}
fn contar_letras(texto: String) {
println!("A lista tem {} caracteres.", texto.chars().count());
}
Ver uma resposta
O erro é que lista foi movida para contar_letras e depois usada no println!.
Primeira forma, com clone:
fn main() {
let lista = String::from("arroz, feijão, ovo");
contar_letras(lista.clone()); // a função recebe uma cópia
println!("Lista: {lista}");
}
fn contar_letras(texto: String) {
println!("A lista tem {} caracteres.", texto.chars().count());
}
Segunda forma, devolvendo a posse:
fn main() {
let lista = String::from("arroz, feijão, ovo");
let lista = contar_letras(lista); // recebe a posse de volta
println!("Lista: {lista}");
}
fn contar_letras(texto: String) -> String {
println!("A lista tem {} caracteres.", texto.chars().count());
texto
}
As duas funcionam, mas nenhuma é a ideal. Na próxima lição você vai ver o jeito idiomático: emprestar com &.