Olá, mundo e o Cargo

Nesta aula, você aprenderá a criar seu primeiro projeto Rust usando o Cargo, o gerenciador de pacotes e build system oficial. Exploraremos a estrutura de diretórios gerada, os comandos cargo new, cargo build e cargo run, e a configuração básica do arquivo Cargo.toml.

Na aula anterior, vimos como instalar o Rust e verificamos que o compilador e o Cargo estão prontos. Agora, vamos criar nosso primeiro programa Rust usando o Cargo, que é a ferramenta padrão para gerenciar projetos Rust. Você aprenderá a estrutura de um projeto, como compilar e executar, e o básico do arquivo de configuração.

cargo new

O comando cargo new cria um novo projeto Rust com a estrutura padrão. Ele gera um diretório com o nome do projeto, contendo um arquivo Cargo.toml e um diretório src com um arquivo main.rs inicial. Vamos criar um projeto chamado hello_cargo:

cargo new hello_cargo

Isso criará a seguinte estrutura:

hello_cargo/
├── Cargo.toml
└── src/
    └── main.rs

O arquivo main.rs já vem com um programa "Olá, mundo!" padrão:

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

Estrutura do projeto

Todo projeto Cargo segue uma estrutura consistente:

Cargo.toml: arquivo de configuração do projeto (dependências, metadados).
src/: diretório onde fica o código fonte.
src/main.rs: ponto de entrada para programas executáveis.
src/lib.rs: ponto de entrada para bibliotecas (opcional).

Além disso, ao compilar, o Cargo cria o diretório target/ com os artefatos de build.

cargo run e cargo build

Para compilar e executar seu projeto, use cargo run:

cd hello_cargo
cargo run

Saída esperada:

   Compiling hello_cargo v0.1.0 (file:///caminho/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.52s
     Running `target/debug/hello_cargo`
Hello, world!

Se você quiser apenas compilar sem executar, use cargo build:

cargo build

O executável será gerado em target/debug/hello_cargo (no Linux/macOS) ou target\debug\hello_cargo.exe (no Windows).

Cargo.toml básico

O arquivo Cargo.toml gerado pelo cargo new se parece com:

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

[dependencies]

Explicação das seções:

[package]: metadados do projeto (nome, versão, edição do Rust).
name: nome do projeto.
version: versão semântica (semver).
edition: edição do Rust (2021 é a mais recente estável).
[dependencies]: lista de crates externas que o projeto usa.

Para adicionar uma dependência, edite essa seção. Por exemplo, para usar a crate rand:

[dependencies]
rand = "0.8"

Depois, execute cargo build para baixar e compilar as dependências.

Referências

Exercícios

Crie um novo projeto chamado meu_projeto usando cargo new. Qual comando você usaria?
```
cargo new meu_projeto
```
Dentro do diretório do projeto, qual comando você usaria para compilar e executar o programa?
```
cargo run
```
O arquivo Cargo.toml gerado por cargo new contém a seção [dependencies]. O que ela serve?
A seção [dependencies] lista as crates externas das quais o projeto depende. O Cargo baixa e compila essas dependências automaticamente.
Qual é a estrutura de diretórios padrão de um projeto Cargo?
A estrutura padrão é:
```
nome_do_projeto/
├── Cargo.toml
└── src/
    └── main.rs
```
Modifique o programa main.rs para imprimir "Olá, Rust!" em vez de "Hello, world!" e execute novamente. Qual comando você usaria para ver a nova saída?
Altere a linha println!("Hello, world!"); para println!("Olá, Rust!"); e execute cargo run.