Pular para o conteúdo
Rust em Português

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

  1. Cada valor no Rust tem um dono (uma variável).
  2. Só pode existir um dono por vez.
  3. 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);
  • bool e char;
  • 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.
  • &str literal é fixo; String é dona do texto na heap.
  • Atribuir ou passar uma String para 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 &.

Salvo só neste navegador.