Bem-vindo ao Rust: segurança de memória sem coletor de lixo

ENTENDA A IDEIA

A ideia central

Rust é uma linguagem compilada. O compilador, rustc, transforma o código em um programa nativo. Antes disso, ele confere os tipos e o uso da memória. Um programa que viola essas regras não chega a executar.

Todo executável começa em fn main. O let dá um nome a um valor, e println! imprime uma linha. Dentro do molde, {language} insere o valor da variável no texto.

Nesta trilha, você edita e executa os programas no próprio navegador. A próxima aula mostra a instalação local, para os projetos completos. Na próxima tela, mude o nome da saudação e acrescente uma segunda linha de saída.

Exemplo Rust

fn main() {
    let language = "Rust";
    println!("Olá, {language}!");
}

EXPERIMENTE

Edite e execute

Troque "estudante" por "Ana". Depois do primeiro println!, acrescente println!("Primeiro programa em Rust.");. Execute. A saída deve ter as duas linhas, nessa ordem.

Objetivo

Troque o nome da saudação e acrescente uma segunda linha de saída.

Saída esperada

Olá, Ana!
Primeiro programa em Rust.

Rust 2021 · Edite e execute

fn main() {
    let name = "estudante";
    println!("Olá, {name}!");
}

ENTENDA A IDEIA

A ideia central

Existem duas formas tradicionais de cuidar da memória. Java, Go, Python e JavaScript usam um coletor de lixo: um processo libera, durante a execução, o que ninguém mais usa. Em C e C++, você libera a memória, e um descuido vira um bug no programa em uso.

Rust escolhe uma terceira via: o compilador acompanha quem é o dono de cada valor. No exemplo, backup passa a ser o dono do texto, e usar report depois causa o erro E0382, antes de o programa existir.

Segundo o MSRC, cerca de 70 % das vulnerabilidades que a Microsoft registra como CVE a cada ano são problemas de segurança de memória. O projeto Chromium relata cerca de 70 % entre as suas falhas de segurança de alta severidade.

Exemplo Rust

let report = String::from("relatório");
let backup = report; // a posse do texto passa para backup
println!("{report}"); // E0382: borrow of moved value: `report`

ENTENDA A IDEIA

A ideia central

A mesma análise vale para threads. Uma data race acontece quando duas threads acessam o mesmo valor ao mesmo tempo, pelo menos uma escreve e nenhuma coordena o acesso. No exemplo, a thread nova tenta alterar count, que pertence a main. O compilador recusa com E0373. Em Rust seguro, um programa com data race não compila.

O segundo princípio é o das abstrações de custo zero. Um recurso de alto nível, como o intervalo (1..=100) somado com sum(), não deve custar mais do que o laço equivalente escrito à mão. Na próxima tela, use esse recurso com outro intervalo.

Exemplo Rust

let mut count = 0;
let worker = std::thread::spawn(|| count += 1);
// E0373: closure may outlive the current function, but it borrows `count`
let total: u32 = (1..=100).sum(); // 5050, sem custo escondido

EXPERIMENTE

Edite e execute

O intervalo 1..=4 inclui o 4. Troque o fim do intervalo por 10 e atualize o texto da mensagem para 1 a 10. Execute. A soma deve ser 55.

Objetivo

Some os números de 1 a 10 com um intervalo e sum().

Saída esperada

soma de 1 a 10: 55

Rust 2021 · Edite e execute

fn main() {
    let total: u32 = (1..=4).sum();
    println!("soma de 1 a 4: {total}");
}

O compilador confere cada chamada antes de executarVídeo · 0:44 · legendas em português

CÓDIGO ANOTADO

Código anotado

Exemplo Rust

// birth_year estima o ano de nascimento a partir do ano atual e da idade.
fn birth_year(current_year: i32, age: i32) -> i32 {
    current_year - age
}

EXPERIMENTE

Edite e execute

A função espera primeiro o ano atual e depois o ano de destino. A chamada passa os dois valores na ordem invertida, e o compilador aceita, porque os dois são i32. Troque a ordem dos argumentos e execute. A saída deve mostrar 4, não -4.

Objetivo

Corrija a ordem dos argumentos para calcular quantos anos faltam até 2030.

Saída esperada

faltam 4 anos

Rust 2021 · Edite e execute

fn years_until(current_year: i32, target_year: i32) -> i32 {
    target_year - current_year
}

fn main() {
    let missing = years_until(2030, 2026);
    println!("faltam {missing} anos");
}

CÓDIGO ANOTADO

Código anotado

Aqui aparecem os dois tipos de texto mais comuns. &str é uma fatia de texto emprestada: a função lê o nome, mas o texto continua com quem chamou. String é um texto que pertence a quem o criou e pode crescer.

format! monta uma String nova a partir de um molde, como println!, mas devolve o texto em vez de imprimi-lo. Quem chama decide o que fazer com ele: imprimir, guardar ou combinar com outro texto. O ! indica uma macro, não uma função comum.

As duas macros conferem o molde durante a compilação. Um {} sem argumento correspondente, ou um {nome} sem variável com esse nome, é um erro de compilação, não uma surpresa durante a execução.

Exemplo Rust

// greeting monta a mensagem de boas-vindas; format! devolve uma String nova.
fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

EXPERIMENTE

Edite e execute

Altere o molde de format! para "[nível {level}] {name}". Na chamada, troque o nível 1 por 2. Execute. A função continua devolvendo uma String; somente main imprime.

Objetivo

Mude o molde de format! para mostrar o nível entre colchetes antes do nome, e use o nível 2.

Saída esperada

[nível 2] Bia

Rust 2021 · Edite e execute

fn badge(name: &str, level: u32) -> String {
    format!("{name} - nível {level}")
}

fn main() {
    let text = badge("Bia", 1);
    println!("{text}");
}

DESAFIO

Monte a saudação com format!

Escreva a função greeting, que recebe um nome e devolve a mensagem de boas-vindas completa:

pub fn greeting(name: &str) -> String

Entrada: qualquer &str, inclusive vazio.
Saída: a String "Olá, {name}! Bem-vindo ao Rust." com o nome interpolado.
Exemplo: greeting("Ana") devolve "Olá, Ana! Bem-vindo ao Rust."; greeting("") devolve "Olá, ! Bem-vindo ao Rust." — o molde não muda, mesmo com nome vazio.
Restrições: a pontuação e os espaços precisam ser iguais, byte a byte; os casos comparam a String inteira.

Este é o padrão do programa da aula: um molde fixo, uma interpolação e uma String nova como resultado. Execute os testes no editor: cada caso mostra o valor esperado e o valor que sua função devolveu. O stub devolve só o nome, então todos os casos falham até você escrever o molde completo.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// greeting devolve a mensagem "Olá, {name}! Bem-vindo ao Rust." com o nome
// interpolado — pontuação e espaços exatamente como no molde.
pub fn greeting(name: &str) -> String {
    // implemente:
    String::from(name)
}

Arquivos, contrato, dicas e solução

Exercício 1

Monte a saudação com format!

stub.rs

// greeting devolve a mensagem "Olá, {name}! Bem-vindo ao Rust." com o nome
// interpolado — pontuação e espaços exatamente como no molde.
pub fn greeting(name: &str) -> String {
    // implemente:
    String::from(name)
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases = [
        ("Ana", "Olá, Ana! Bem-vindo ao Rust."),
        ("dev", "Olá, dev! Bem-vindo ao Rust."),
        ("", "Olá, ! Bem-vindo ao Rust."),
        ("João da Silva", "Olá, João da Silva! Bem-vindo ao Rust."),
    ];
    for (index, (name, want)) in cases.iter().enumerate() {
        let got = greeting(name);
        let pass = got == *want;
        print_result(index + 1, pass, &format!("{name:?}"), want, &got);
    }
}

cases.json

[
  {
    "case": 1,
    "input": "\"Ana\"",
    "want": "Olá, Ana! Bem-vindo ao Rust."
  },
  {
    "case": 2,
    "input": "\"dev\"",
    "want": "Olá, dev! Bem-vindo ao Rust."
  },
  {
    "case": 3,
    "input": "\"\"",
    "want": "Olá, ! Bem-vindo ao Rust."
  },
  {
    "case": 4,
    "input": "\"João da Silva\"",
    "want": "Olá, João da Silva! Bem-vindo ao Rust."
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`"Ana"`	`Olá, Ana! Bem-vindo ao Rust.`
2	`"dev"`	`Olá, dev! Bem-vindo ao Rust.`
3	`""`	`Olá, ! Bem-vindo ao Rust.`
4	`"João da Silva"`	`Olá, João da Silva! Bem-vindo ao Rust.`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-01-bem-vindo-ao-rust-exercicio-1
cd imersao-01-bem-vindo-ao-rust-exercicio-1
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-01-bem-vindo-ao-rust-exercicio-1
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

A mensagem é sempre a mesma frase com o nome no meio; a macro format! monta uma String nova a partir de um molde com chaves.
format!("Olá, {name}! Bem-vindo ao Rust.") interpola a variável direto no molde — confira a pontuação exata, os casos comparam byte a byte.

Revelar solução

solution.rs

// greeting devolve a mensagem "Olá, {name}! Bem-vindo ao Rust." com o nome
// interpolado — pontuação e espaços exatamente como no molde.
pub fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

format! devolve uma String alocada com o texto interpolado; a armadilha é errar a pontuação exata ou tentar concatenar &str com +, que exige uma String à esquerda e confunde quem está começando.

Uma linha resolve, e é a linha idiomática:

pub fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

format! confere o molde durante a compilação: um {nome} com uma variável que não existe é recusado antes de o programa executar. O custo é uma alocação para a String resultante, proporcional ao tamanho do texto final: O(n) no comprimento da mensagem.

A alternativa de outras linguagens é concatenar: "Olá, ".to_string() + name + "! Bem-vindo ao Rust.". Ela funciona, mas exige converter o primeiro pedaço para String, porque o operador + precisa de uma String à esquerda e consome esse valor. Para montar texto a partir de partes, format! é mais legível, e o formato da mensagem fica visível em um único molde. Cada + também pode precisar de uma nova alocação quando o texto cresce.

O caso de borda é o nome vazio: o molde continua válido e a saída é "Olá, ! Bem-vindo ao Rust.". Um if para esse caso inventaria um requisito que o contrato não pede. Leia o contrato antes de acrescentar caminhos: cada condição extra é um comportamento que alguém precisa testar e manter.

Se o teste falhar, compare a linha esperada com a linha devolvida, caractere a caractere. Os erros mais comuns são um espaço depois da vírgula, a exclamação no lugar errado e o ponto final esquecido.

CÓDIGO ANOTADO

Código anotado

O main junta as duas funções. O compilador infere os tipos: name é &str; current_year e age são i32, por causa da chamada de birth_year. Uma anotação explícita só é necessária quando o contexto não determina o tipo.

O programa completo imprime duas linhas:

Olá, dev! Bem-vindo ao Rust.
Você nasceu por volta de 1996

Os valores de current_year e age estão fixos no código. Em um programa real, eles viriam de uma entrada ou do relógio do sistema, e os tipos continuariam os mesmos.

Repare no que não aparece: nenhuma liberação de memória e nenhum teste de valor nulo. Essas três variáveis também são imutáveis. Sem a palavra-chave mut, uma segunda atribuição é um erro de compilação. A próxima tela mostra a mensagem real.

Exemplo Rust

fn main() {
    let name = "dev";
    let current_year = 2026;
    let age = 30;
    println!("{}", greeting(name));
    println!("Você nasceu por volta de {}", birth_year(current_year, age));
}

ENTENDA A IDEIA

A ideia central

error[E0384]: cannot assign twice to immutable variable `age`
  --> src/main.rs:15:5
   |
14 |     let age = 30;
   |         --- first assignment to `age`
15 |     age = age + 1;
   |     ^^^^^^^^^^^^^ cannot assign twice to immutable variable
   |
help: consider making this binding mutable
   |
14 |     let mut age = 30;
   |         +++

Esta é a resposta do rustc a age = age + 1; logo depois de let age = 30;. A mensagem mostra onde a variável nasceu, onde a segunda atribuição falhou e uma correção possível. A imutabilidade é o padrão; a aula de variáveis e tipos explora mut.

Essa verificação tem custos reais. O compilador trabalha muito, e projetos grandes compilam mais devagar do que em Go. Nas primeiras semanas, o borrow checker também recusa programas que parecem corretos. Na maioria das vezes, ele aponta um defeito real. Esta trilha mostra a mensagem do rustc em cada erro e explica o que ela protege.

Muitas vezes você nem precisa de mut: um novo valor com outro nome deixa o cálculo claro e mantém os valores anteriores intactos.

EXPERIMENTE

Edite e execute

O total ainda é igual ao subtotal. Na linha de total, some o frete: let total = subtotal + 500;. Não acrescente mut e não altere subtotal. Execute para ver os dois valores.

Objetivo

Calcule o total com um frete de 500 centavos em um novo valor, sem mut e sem reatribuir o subtotal.

Saída esperada

subtotal: 1200 centavos
total: 1700 centavos

Rust 2021 · Edite e execute

fn main() {
    let subtotal = 1200;
    let total = subtotal;
    println!("subtotal: {subtotal} centavos");
    println!("total: {total} centavos");
}

DESAFIO

Calcule e formate a linha de estoque

Escreva a função inventory_line, que monta a linha de um relatório de estoque e calcula o total em centavos:

pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String

Entrada: o nome do item, a quantidade e o preço unitário em centavos.
Saída: a String "{quantity}x {item} = {total} centavos", em que total é quantity * unit_cents.
Exemplo: inventory_line("parafuso", 3, 150) devolve "3x parafuso = 450 centavos"; inventory_line("rebite", 0, 99) devolve "0x rebite = 0 centavos".
Restrições: a função calcula o total; quem chama fornece somente a quantidade e o preço unitário. Os valores de teste cabem em u32 sem estouro.

Aqui você combina duas ideias da aula: um cálculo com inteiros e um molde de formatação. O stub monta só uma parte da linha e ignora o preço; os testes mostram a diferença em cada caso. u32 é o inteiro de 32 bits sem sinal: quantidades e preços não podem ser negativos. Escolher um tipo que proíbe valores inválidos é um hábito que o compilador recompensa.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// inventory_line monta "{quantity}x {item} = {total} centavos", onde total
// é quantity * unit_cents, calculado dentro da função.
pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    // implemente:
    let _ = unit_cents;
    format!("{quantity}x {item}")
}

Arquivos, contrato, dicas e solução

Exercício 2

Calcule e formate a linha de estoque

stub.rs

// inventory_line monta "{quantity}x {item} = {total} centavos", onde total
// é quantity * unit_cents, calculado dentro da função.
pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    // implemente:
    let _ = unit_cents;
    format!("{quantity}x {item}")
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(&str, u32, u32, &str); 4] = [
        ("parafuso", 3, 150, "3x parafuso = 450 centavos"),
        ("rebite", 0, 99, "0x rebite = 0 centavos"),
        ("porca", 1, 75, "1x porca = 75 centavos"),
        ("arruela", 12, 40, "12x arruela = 480 centavos"),
    ];
    for (index, (item, quantity, unit_cents, want)) in cases.iter().enumerate() {
        let got = inventory_line(item, *quantity, *unit_cents);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &format!("({item:?}, {quantity}, {unit_cents})"),
            want,
            &got,
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "(\"parafuso\", 3, 150)",
    "want": "3x parafuso = 450 centavos"
  },
  {
    "case": 2,
    "input": "(\"rebite\", 0, 99)",
    "want": "0x rebite = 0 centavos"
  },
  {
    "case": 3,
    "input": "(\"porca\", 1, 75)",
    "want": "1x porca = 75 centavos"
  },
  {
    "case": 4,
    "input": "(\"arruela\", 12, 40)",
    "want": "12x arruela = 480 centavos"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`("parafuso", 3, 150)`	`3x parafuso = 450 centavos`
2	`("rebite", 0, 99)`	`0x rebite = 0 centavos`
3	`("porca", 1, 75)`	`1x porca = 75 centavos`
4	`("arruela", 12, 40)`	`12x arruela = 480 centavos`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-01-bem-vindo-ao-rust-exercicio-2
cd imersao-01-bem-vindo-ao-rust-exercicio-2
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-01-bem-vindo-ao-rust-exercicio-2
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Primeiro calcule o total em uma variável (quantity * unit_cents); depois monte a frase com format! usando as três partes.
O molde é "{quantity}x {item} = {total} centavos" — repare que o total é o produto, não o preço unitário, e que zero unidades resulta em total zero.

Revelar solução

solution.rs

// inventory_line monta "{quantity}x {item} = {total} centavos", onde total
// é quantity * unit_cents, calculado dentro da função.
pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    let total = quantity * unit_cents;
    format!("{quantity}x {item} = {total} centavos")
}

Separar o cálculo da formatação deixa cada linha com uma responsabilidade; a armadilha é interpolar a expressão errada (unit_cents em vez do produto) ou esquecer que 0 * qualquer coisa precisa continuar produzindo uma linha válida.

Calcule primeiro e formate depois:

pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    let total = quantity * unit_cents;
    format!("{quantity}x {item} = {total} centavos")
}

Separar o cálculo da formatação deixa cada linha com uma responsabilidade. A linha do format! só descreve a forma da saída, e a linha do total mostra o cálculo. O custo é O(n) no tamanho do texto final, com uma alocação.

Duas armadilhas aparecem em soluções reais. A primeira é interpolar unit_cents em vez do produto; o caso ("parafuso", 3, 150) detecta o erro, porque 450 é diferente de 150. A segunda é tratar a quantidade zero como caso especial. O molde é fixo, e 0 * 99 já produz a linha correta.

Se o produto ultrapassar o limite de u32, um build de desenvolvimento encerra o programa com panic, em vez de dar a volta em silêncio, como em C. Os casos deste exercício ficam longe do limite. A aula de variáveis e tipos trata de overflow e dos inteiros maiores.

Repare também nos tipos da assinatura. Com u32, uma quantidade negativa não chega à função: o chamador não consegue passar -3. Em uma linguagem sem essa verificação, a mesma função precisaria testar o sinal de cada argumento durante a execução. Aqui, o tipo faz essa validação antes de o programa existir.

O nome inventory_line e os parâmetros em inglês seguem a convenção da trilha: identificadores em inglês, textos e comentários em português.

ENTENDA A IDEIA

A ideia central

Em Python, o interpretador gerencia a memória com contagem de referências e um coletor de ciclos. Você não decide quem libera o quê, e o programa paga esse trabalho durante a execução. Rust faz essa contabilidade na compilação: o custo é pago uma vez, na sua máquina, e não em cada execução no servidor.

A segunda diferença aparece na primeira função. Em Python, um tipo errado aparece quando a linha executa. As anotações de tipo existem, mas o interpretador não as confere; uma ferramenta separada, como o mypy, faz essa análise. Em Rust, a assinatura fn birth_year(current_year: i32, age: i32) -> i32 é conferida em cada chamada. Passar 30.5 ali causa E0308 e impede a geração do programa.

Exemplo Rust

fn birth_year(current_year: i32, age: i32) -> i32 {
    current_year - age
}
// birth_year(2026, 30.5) não compila: E0308

ENTENDA A IDEIA

A ideia central

Declare cada variável sem mut e acrescente a palavra-chave somente quando o design exige uma mudança. A imutabilidade padrão transforma cada let em documentação: quem lê let total = ... sabe que esse valor não muda até o fim do escopo.

O capítulo 3.1 do The Rust Book apresenta essa regra e o erro E0384 que a protege. Em código Rust idiomático, mut é raro, visível e intencional.

O compilador também avisa no sentido contrário. Um mut que nenhuma linha usa produz o aviso unused_mut (“variable does not need to be mutable”). Remova a palavra-chave e deixe o let dizer a verdade sobre o valor.

Exemplo Rust

let subtotal = 1200;           // não muda depois
let total = subtotal + 500;    // novo valor, nome novo
let mut attempts = 0;          // mut: a mudança é intencional
attempts += 1;

RESUMO DA AULA

O que você leva desta aula

Rust confere tipos e o uso da memória na compilação; um programa que viola as regras não é gerado.
Sem coletor de lixo, o compilador confere quem é o dono de cada valor (E0382).
A assinatura de uma função é um contrato de tipos; a ordem dos argumentos continua sendo sua responsabilidade.
A última expressão de um bloco, sem ponto e vírgula, é o valor devolvido.
println! imprime e format! devolve uma String; as duas conferem o molde na compilação.
let é imutável por padrão (E0384); prefira um novo valor a mut.
Na próxima aula: rustup, cargo e o primeiro projeto local.

+195 XPpossíveis nesta aula

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

A ideia central

Edite e execute

Objetivo

Saída esperada

Código anotado

Edite e execute

Objetivo

Saída esperada

Código anotado

Edite e execute

Objetivo

Saída esperada

Monte a saudação com format!

Casos e valores esperados

Execute com o Cargo local

Código anotado

A ideia central

Edite e execute

Objetivo

Saída esperada

Calcule e formate a linha de estoque

Casos e valores esperados

Execute com o Cargo local

A ideia central

A ideia central

O que você leva desta aula

Você transformou esta ideia em prática.