Rust: Introdução ao Rust e configuração do ambiente de…

Rust é uma linguagem que permite que qualquer pessoa desenvolva softwares confiáveis e eficientes — ela não possui coleta de lixo, mas garante a segurança da memória.

Este tutorial é destinado a desenvolvedores que tenham conhecimentos básicos de pelo menos uma linguagem de programação. Seja qual for sua formação — C/C++, Java, Python ou JavaScript —, o sistema de propriedade e as abstrações de custo zero do Rust irão redefinir sua compreensão do conceito de “segurança”. O Rust foi eleito a “linguagem de programação mais amada” na Pesquisa com Desenvolvedores do Stack Overflow por vários anos consecutivos.

1. O que você vai aprender

• O que é o Rust? Sua filosofia central de design
• Diferenças entre Rust e C/C++/Go, e seus casos de uso adequados
• Instale o Rust no Windows, macOS ou Linux usando o rustup
• Criar, compilar e executar projetos com o Cargo
• Escreva e execute seu primeiro programa em Rust
• O ecossistema do Rust (crates.io e a biblioteca padrão)

2. A história de um programador de sistemas

(1) Agonia: O pesadelo da linguagem C

Tom é engenheiro de sistemas embarcados. Um dia, recebeu uma tarefa urgente:

“Reduzir o uso de memória deste serviço web de 300 MB para menos de 50 MB, garantindo que ele nunca trave.”

Ele desenvolveu o programa em C e descobriu que:

• O gerenciamento manual da memória resulta em mais de 30 ocorrências de malloc e free no código; se você corrigir uma, pode acabar esquecendo outra.
• Ponteiro nulo fazia com que o serviço online travasse duas vezes por semana, e eu era acordado no meio da noite para consertar o problema
• Estouro de buffer — a equipe de segurança ligou para avisar: “Há risco de um ataque remoto”.
• Escrever testes? Em C, você precisa montar sua própria estrutura de testes, e leva dois dias para colocar a integração contínua (CI) em funcionamento.

O que ele acabou escolhendo? Ele mudou para o Rust.

(2) A solução em Rust

Para a mesma tarefa, Tom escreveu o seguinte em Rust:

fn main() {
    let msg = String::from("Hello, secure world!");
// Compiler Guarantees: msg memory is automatically released when it goes out of scope.
// Not necessary malloc, nor free
    println!("{}", msg);
}

Tempo total: Compilação bem-sucedida = Seguro. O compilador do Rust detecta erros de memória durante a compilação. Sem Valgrind, sem Sanitizer — se compilar, é seguro.

Essa é a beleza do Rust: eliminar erros de memória em tempo de compilação, sem nenhuma sobrecarga em tempo de execução. Sua filosofia de design é que “a segurança não é alcançada por meio do cuidado do desenvolvedor, mas é garantida pelo compilador”.

3. O que é o Rust?

Rust é uma linguagem de programação de nível de sistema criada em 2015 pelo pesquisador da Mozilla Graydon Hoare, originalmente projetada para o mecanismo do navegador Firefox.

(1) Os três princípios fundamentais do Rust

graph LR
    A[Rust Three Major Commitments] --> B[Zero-Cost Abstraction]
    A --> C[Memory Safety]
    A --> D[Concurrency-Safe]
    B --> E[Expressiveness of High-Level Languages<br>Assembly-Level Performance]
    C --> F[Ownership + Borrow<br>Eliminating Memory Errors at Compile Time]
    D --> G[Send+Sync trait<br>Data race detected at compile time]

graph LR
    A[Rust Three Major Commitments] --> B[Zero-Cost Abstraction]
    A --> C[Memory Safety]
    A --> D[Concurrency-Safe]
    B --> E[Expressiveness of High-Level Languages<br>Assembly-Level Performance]
    C --> F[Ownership + Borrow<br>Eliminating Memory Errors at Compile Time]
    D --> G[Send+Sync trait<br>Data race detected at compile time]

(2) Rust x C/C++ x Go

4. Instalar o Rust

(1) Instale usando o rustup

A maneira recomendada de instalar o Rust é por meio do rustup, uma ferramenta de gerenciamento de versões do Rust.

# Run in the terminal (Windows requires Visual Studio C++ Build Tools to be installed first)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Após a instalação, verifique a versão:

rustc --version   # Output: rustc 1.86.0 (05f9846f8 2025-03-31)
cargo --version   # Output: cargo 1.86.0 (version number)

(2) Observações especiais para o Windows

Os usuários do Windows devem primeiro instalar as Ferramentas de Compilação do Visual Studio (ou o Visual Studio 2019 ou versão posterior) e selecionar a carga de trabalho “Desenvolvimento para desktop com C++”. O Rust depende do vinculador MSVC.

(3) Atualização e desinstalação

rustup update    # Update to the latest version
rustup self uninstall  # Uninstall (for cache retention, use uninstall rather than directly deleting the directory)

5. Seu primeiro programa em Rust

▶ Exemplo 1: Hello World (Dificuldade ⭐)

// ============================================
// First Rust Program: Print Hello World
// ============================================

fn main() {
    println!("Hello, world!");
}

Resultado:

Hello, world!

fn main() é o ponto de entrada de todo programa em Rust. println! é uma macro (veja !) usada para exibir texto no terminal.

▶ Exemplo 2: Criando um projeto com o Cargo (Dificuldade ⭐)

# Create a New Project
cargo new hello_cargo
cd hello_cargo

cargo new irá gerar a seguinte estrutura:

hello_cargo/
├── Cargo.toml    # Project Configuration File (Dependencies, Metadata)
├── src/
│   └── main.rs   # Source Code Entry Point

Cargo.toml Conteúdo:

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

Compilar e executar:

cargo build       # Compilation (generates target/debug/ directory)
cargo run         # Compilation + Run

Resultado:

Hello, world!

O Cargo é o gerenciador de pacotes e o sistema de compilação do Rust. cargo build Gera uma compilação de depuração; cargo run compila e executa com um único comando; cargo check realiza apenas uma verificação de sintaxe, sem gerar um binário (mais rápido).

▶ Exemplo 3: Calculadora simples (Dificuldade ⭐⭐)

// ============================================
// A Simple Addition Calculator
// ============================================

fn main() {
    let a: i32 = 10;      // i32 is a 32-bit signed integer
    let b: i32 = 20;      // Rust type annotations use a colon
    let sum = a + b;

    println!("{} + {} = {}", a, b, sum);
}

Resultado:

10 + 20 = 30

As variáveis em Rust são imutáveis por padrão. Aqui, elas são declaradas usando let; se você precisar modificar seus valores posteriormente, deverá usar let mut. As anotações de tipo : i32 são opcionais — o compilador pode inferir o tipo a partir do contexto.

▶ Exemplo 4: Exercício abrangente — Conversão e expressão de temperatura (Dificuldade ⭐⭐)

// ============================================
// Comprehensive Example: Temperature Conversion + Simple Report Generation
// Demo Variables, Types, Basic Syntax, Such as Formatted Output
// ============================================

fn celsius_to_fahrenheit(celsius: f64) -> f64 {
    celsius * 9.0 / 5.0 + 32.0
}

fn fahrenheit_to_celsius(fahrenheit: f64) -> f64 {
    (fahrenheit - 32.0) * 5.0 / 9.0
}

fn main() {
    let cities = ["Beijing", "Shanghai", "Guangzhou"];
    let temps_c = [28.5, 31.2, 33.8];

    println!("=== City Temperature Report ===");
    println!("{:<12} {:>10} {:>10}", "City", "Celsius(°C)", "Fahrenheit(°F)");
    println!("{}", "-".repeat(34));

    let mut index = 0;
    while index < cities.len() {
        let c = temps_c[index];
        let f = celsius_to_fahrenheit(c);
        println!("{:<12} {:>10.1} {:>10.1}", cities[index], c, f);
        index += 1;
    }

    let freezing_f: f64 = 32.0;
    let freezing_c = fahrenheit_to_celsius(freezing_f);
    println!("\nFreezing Point: {:.1}°F = {:.1}°C", freezing_f, freezing_c);

    const BOILING_C: f64 = 100.0;
    let boiling_f = celsius_to_fahrenheit(BOILING_C);
    println!("Boiling Point: {:.1}°C = {:.1}°F", BOILING_C, boiling_f);
}

Resultado:

=== City Temperature Report ===
City           Celsius(°C)    Fahrenheit(°F)
----------------------------------
Beijing           28.5       83.3
Shanghai          31.2       88.2
Guangzhou         33.8       92.8

Freezing Point: 32.0°F = 0.0°C
Boiling Point: 100.0°C = 212.0°F

Este exemplo abrangente aborda definições de funções, declarações de constantes, iteração de matrizes, saída formatada e fórmulas de conversão de temperatura, oferecendo um guia completo da sintaxe básica do Rust.

▶ Exemplo 5: Jogo “Adivinhe o Número” (Dificuldade ⭐⭐)

use std::io;

fn main() {
    let secret = 42; // Hidden answer (random numbers will be used in subsequent lessons)
    println!("🎯 Guess the Number Game! Range 1-100");

    loop {
        println!("Please enter your guess:");

        let mut guess = String::new();
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read input");

        let guess: i32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("⚠️  Please enter a valid number!");
                continue;
            }
        };

        match guess.cmp(&secret) {
            std::cmp::Ordering::Less => println!("Too small! ⬆️"),
            std::cmp::Ordering::Greater => println!("Too big! ⬇️"),
            std::cmp::Ordering::Equal => {
                println!("🎉 Congratulations, you got it right! The answer is {}", secret);
                break;
            }
        }
    }
}

Este exemplo demonstra o uso básico de loop, match, da biblioteca padrão io e do tratamento de erros — trata-se do clássico projeto introdutório do tutorial oficial do Rust.

6. Uma visão geral rápida do ecossistema do Rust

O ecossistema do Rust gira em torno de três ferramentas principais:

Os pacotes de código aberto estão hospedados no crates.io (https://crates.io), que atualmente hospeda mais de 150.000 pacotes. Entre os pacotes mais comuns estão serde (serialização), clap (argumentos de linha de comando) e tokio (tempo de execução assíncrono).

❓ Perguntas Frequentes

P: O Rust é adequado para iniciantes sem experiência em programação? R: Na verdade, não. O sistema de propriedade, empréstimo e duração do Rust exige algum conhecimento prévio de programação para ser compreendido. Recomenda-se que você aprenda outra linguagem primeiro (como Python ou C) antes de passar para o Rust.

P: Como escolher entre Rust e Go? R: Depende do caso de uso. Precisa de desempenho de ponta, sistemas embarcados ou WebAssembly? Escolha Rust. Precisa de desenvolvimento rápido, microsserviços ou aplicativos nativos da nuvem? Escolha Go. As duas linguagens não são alternativas, mas sim complementares.

P: Como está o mercado de trabalho para desenvolvedores de Rust? R: A demanda está crescendo rapidamente, mas o número total de vagas ainda é baixo. A demanda por Rust é maior nas áreas de blockchain, WebAssembly, sistemas embarcados e ferramentas de infraestrutura (como Deno, Bun e Swc). Os salários costumam estar acima da média.

P: Por que preciso do Visual Studio para instalar o Rust no Windows? R: O compilador do Rust depende, em sua essência, do vinculador do MSVC. Você só precisa instalar as Ferramentas de Compilação; não é necessário instalar o pacote completo do Visual Studio. Você também pode optar pela cadeia de ferramentas GNU (rustup default stable-gnu), mas a compatibilidade é um pouco menor.

P: Qual é a diferença entre cargo check e cargo build? R: O cargo check realiza apenas verificações de sintaxe e de tipos; ele não gera arquivos binários, por isso é muito mais rápido. Durante o desenvolvimento, recomenda-se usar primeiro o cargo check para uma validação rápida e, depois de confirmar que tudo está correto, usar o cargo build.

📖 Resumo

• Rust é uma linguagem de programação de nível de sistema cujos principais diferenciais são a segurança de memória em tempo de compilação e a abstração sem custo.
• Em comparação com C/C++, o Rust gerencia a memória automaticamente; em comparação com o Go, ele não apresenta pausas do GC
• Use rustup para instalar o Rust; permite gerenciar várias versões
• Cargo é o sistema de gerenciamento de pacotes e compilação do Rust; cargo new / cargo build / cargo run são seus três principais recursos
• O sistema de propriedade do Rust é sua característica mais marcante (que será abordada em detalhes na Lição 8)
• O núcleo do ecossistema está no crates.io, onde a comunidade é ativa e continua a crescer

📝 Exercícios

1. Dificuldade ⭐: Use cargo new para criar um projeto chamado my_first_rust, modifique main.rs para imprimir seu nome e execute-o usando cargo run.
2. Dificuldade ⭐⭐: Com base no Exemplo 3, acrescente operações de subtração, multiplicação e divisão e observe os resultados dos diferentes tipos de operações (a divisão de números inteiros é truncada?).
3. Dificuldade ⭐⭐⭐: Leia a documentação oficial do Rust compartilhada por rustup doc, localize a seção “Ownership” e resuma-a em três frases com suas próprias palavras. Envie-as a um desenvolvedor de Rust que você conheça para verificar se estão corretas.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós