Pular para o conteúdo
Rust em Português

Lição 5 de 18 · 20 min

Tipos de dados

Inteiros, números com vírgula, bool, char, tuplas e arrays. Veja quando o Rust deduz o tipo, quando anotar e como converter com as e parse.

Ao terminar, você vai saber:

  • Escolher o tipo inteiro adequado (i32, u8, usize e outros)
  • Usar f64, bool e char
  • Agrupar valores em tuplas e arrays
  • Anotar o tipo quando o compilador não consegue deduzir
  • Converter valores com as e com parse

Todo valor no Rust tem um tipo, e o compilador precisa saber qual é antes de rodar o programa. Na maioria das vezes ele descobre sozinho, olhando o valor. Isso se chama inferência de tipo. Quando ele não consegue, você escreve o tipo depois de dois-pontos:

fn main() {
    let idade = 30; // o compilador deduz: i32
    let altura: f64 = 1.75; // tipo escrito por você
    let ativo: bool = true;

    println!("{idade} {altura} {ativo}");
}

Vamos conhecer os tipos básicos, os chamados tipos escalares (um valor só) e depois os compostos (vários valores juntos).

Inteiros

Números sem casa decimal. O nome do tipo diz duas coisas: se aceita negativo e quantos bits ocupa.

  • i = com sinal (aceita negativo): i8, i16, i32, i64, i128
  • u = sem sinal (só zero e positivos): u8, u16, u32, u64, u128

Quanto mais bits, maior o número que cabe. Alguns exemplos:

  • u8: de 0 a 255. Bom para um componente de cor ou a idade de uma pessoa.
  • i32: de cerca de menos 2 bilhões a mais 2 bilhões. É o padrão quando você não diz nada.
  • u64: até um número enorme, com 20 dígitos. Serve para contar visualizações de um vídeo viral.

Existem ainda isize e usize, cujo tamanho depende do computador (64 bits na maioria das máquinas de hoje). O usize é o tipo usado para posições e tamanhos de listas. Você vai vê-lo bastante.

fn main() {
    let temperatura: i8 = -5;
    let nota: u8 = 9;
    let habitantes_sp: u32 = 11_450_000;
    let posicao: usize = 2;

    println!("{temperatura} {nota} {habitantes_sp} {posicao}");
}

E se o número não couber? O compilador avisa:

fn main() {
    let idade: u8 = 300;
    println!("{idade}");
}
error: literal out of range for `u8`
  |
2 |     let idade: u8 = 300;
  |                     ^^^
  |
  = note: the literal `300` does not fit into the type `u8` whose range is `0..=255`

O valor 300 não cabe num u8, que vai até 255.

Números com vírgula: f32 e f64

Para números com casas decimais, use f64 (padrão) ou f32. Atenção: no código, a casa decimal é separada por ponto, como em inglês.

fn main() {
    let preco_cafe = 6.5; // f64
    let desconto: f32 = 0.1;

    let total = preco_cafe * 3.0;
    println!("Três cafés: R$ {total:.2}");
    println!("Desconto: {desconto}");
}

Um detalhe importante: o Rust não mistura tipos sozinho. preco_cafe * 3 não compila, porque 3 é inteiro e preco_cafe é f64. Por isso escrevemos 3.0.

Operações

As de sempre: +, -, *, / e % (resto da divisão). Divisão entre inteiros descarta a parte decimal:

fn main() {
    let pizza = 8;
    let pessoas = 3;

    println!("Cada um come {} pedaços", pizza / pessoas); // 2
    println!("Sobram {} pedaços", pizza % pessoas); // 2
    println!("Divisão exata: {}", 8.0 / 3.0); // 2.6666666666666665
}

Booleano: bool

Só dois valores possíveis: true ou false. Aparece muito em comparações:

fn main() {
    let idade = 17;
    let pode_votar = idade >= 16;
    let pode_dirigir = idade >= 18;

    println!("Vota? {pode_votar}. Dirige? {pode_dirigir}.");
}

Caractere: char

Um char guarda um caractere, escrito entre aspas simples. Ele aceita qualquer caractere Unicode: letras com acento, ç, letras de outros alfabetos.

fn main() {
    let letra = 'ç';
    let nota = 'A';
    let simbolo = '$';

    println!("{letra} {nota} {simbolo}");
}

Aspas simples são para char; aspas duplas são para texto. 'a' é um caractere, "a" é um texto com um caractere. Texto é assunto do módulo de ownership, onde você vai conhecer String e &str.

Tuplas

Uma tupla junta valores de tipos diferentes num pacote só, com tamanho fixo. Pense numa linha de planilha: nome, idade e cidade.

fn main() {
    let pessoa: (&str, u8, &str) = ("Rafaela", 27, "Curitiba");

    // Acessando pela posição, começando do zero
    println!("Nome: {}", pessoa.0);
    println!("Idade: {}", pessoa.1);

    // Desmontando em variáveis separadas
    let (nome, idade, cidade) = pessoa;
    println!("{nome}, {idade} anos, mora em {cidade}.");
}

A forma let (nome, idade, cidade) = pessoa; se chama desestruturação. É bem prática.

Arrays

Um array guarda vários valores do mesmo tipo, com tamanho fixo. O tipo é escrito [tipo; tamanho]:

fn main() {
    let meses: [&str; 3] = ["janeiro", "fevereiro", "março"];
    let notas = [8, 7, 10, 9];
    let zeros = [0; 5]; // cinco zeros: [0, 0, 0, 0, 0]

    println!("Primeiro mês: {}", meses[0]);
    println!("Quantidade de notas: {}", notas.len());
    println!("{zeros:?}");
}

Os índices começam em zero. E se você pedir uma posição que não existe? Se o índice for conhecido na compilação, o compilador já barra. Se só for descoberto com o programa rodando, o Rust interrompe o programa com um panic em vez de ler uma memória que não é dele. Em C, esse erro poderia ler lixo silenciosamente.

Para listas que crescem e diminuem, existe o Vec, que você vai ver mais adiante.

Convertendo entre números: as

O Rust nunca converte um tipo numérico em outro por conta própria. Você pede, com as:

fn main() {
    let itens: i32 = 7;
    let preco: f64 = 2.5;

    let total = itens as f64 * preco;
    println!("Total: {total}");

    let nota_final = 8.9_f64;
    let arredondada = nota_final as i32; // corta a parte decimal
    println!("{arredondada}"); // 8
}

Cuidado: as corta sem perguntar. Converter 8.9 para inteiro dá 8, não 9. Se quiser arredondar, use nota_final.round() as i32.

Convertendo texto em número: parse

Quando o usuário digita um número, ele chega como texto. Para converter, use parse. Como o compilador não tem como saber qual número você quer, é preciso anotar o tipo:

fn main() {
    let digitado = "42";
    let numero: i32 = digitado.parse().unwrap();

    println!("O dobro é {}", numero * 2);
}

O parse pode falhar (e se a pessoa digitar “banana”?). Por isso ele devolve um Result, que é ok ou erro. O .unwrap() diz: “se der certo, me dá o valor; se der errado, encerra o programa”. Serve para começar. No módulo de dados você aprende a tratar o erro com calma.

Sem a anotação, o compilador reclama:

fn main() {
    let numero = "42".parse().unwrap();
    println!("{numero}");
}
error[E0284]: type annotations needed
  |
2 |     let numero = "42".parse().unwrap();
  |         ^^^^^^        ----- type must be known at this point
  |
help: consider giving `numero` an explicit type
  |
2 |     let numero: /* Type */ = "42".parse().unwrap();
  |               ++++++++++++

Ele pede para você dizer o tipo. Dá para escrever let numero: i32 = ... ou "42".parse::<i32>(). As duas formas funcionam.

Resumo

  • O Rust deduz o tipo quase sempre; quando não consegue, você anota com : tipo.
  • Inteiros: i aceita negativo, u não; i32 é o padrão e usize aparece em tamanhos e posições.
  • f64 para decimais, bool para verdadeiro ou falso, char para um caractere.
  • Tuplas misturam tipos; arrays têm tipo único e tamanho fixo.
  • as converte números; parse converte texto em número.

Desafio

Você recebeu como texto o valor de uma conta de restaurante ("187.60") e o número de pessoas ("4"). Converta os dois com parse, calcule quanto cada um paga com 10% de serviço e imprima com duas casas decimais. Guarde o resultado numa tupla (pessoas, valor_por_pessoa) e imprima a tupla com {:?}.

Ver uma resposta
fn main() {
    let conta_texto = "187.60";
    let pessoas_texto = "4";

    let conta: f64 = conta_texto.parse().unwrap();
    let pessoas: u32 = pessoas_texto.parse().unwrap();

    let com_servico = conta * 1.10;
    let por_pessoa = com_servico / pessoas as f64;

    println!("Cada um paga R$ {por_pessoa:.2}");

    let resultado = (pessoas, por_pessoa);
    println!("{resultado:?}");
}
Salvo só neste navegador.