Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Tipos de dados

Todo valor em Rust é de um certo tipo de dado, que diz ao Rust que tipo de dado está sendo especificado para que ele saiba como trabalhar com esse dado. Vamos ver dois subconjuntos de tipos de dados: escalares e compostos.

Tenha em mente que Rust é uma linguagem de tipagem estática, o que significa que ele precisa conhecer os tipos de todas as variáveis em tempo de compilação. O compilador geralmente consegue inferir o tipo que queremos usar com base no valor e em como o usamos. Em casos em que muitos tipos são possíveis, como quando convertemos uma String para um tipo numérico usando parse na seção “Comparando o palpite com o número secreto” do Capítulo 2, precisamos adicionar uma anotação de tipo, assim:

#![allow(unused)]
fn main() {
let guess: u32 = "42".parse().expect("Not a number!");
}

Se não adicionarmos a anotação de tipo : u32 mostrada no código anterior, o Rust vai exibir o seguinte erro, que significa que o compilador precisa de mais informações nossas para saber qual tipo queremos usar:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^        ----- type must be known at this point
  |
  = note: cannot satisfy `<_ as FromStr>::Err == _`
  = note: the type must also implement `FromStr`
note: required by a bound in `core::str::<impl str>::parse`
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/str/mod.rs:2782:4
help: consider giving `guess` an explicit type
  |
2 |     let guess: /* Type */ = "42".parse().expect("Not a number!");
  |              ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error

Você vai ver anotações de tipo diferentes para outros tipos de dados.

Tipos escalares

Um tipo escalar representa um único valor. Rust tem quatro tipos escalares principais: inteiros, números de ponto flutuante, booleanos e caracteres. Você deve reconhecê-los de outras linguagens de programação. Vamos ver como eles funcionam em Rust.

Tipos inteiros

Um inteiro é um número sem componente fracionário. Usamos um tipo inteiro no Capítulo 2, o tipo u32. Essa declaração de tipo indica que o valor associado a ele deve ser um inteiro sem sinal (tipos inteiros com sinal começam com i em vez de u) que ocupa 32 bits de espaço. A Tabela 3-1 mostra os tipos inteiros embutidos em Rust. Podemos usar qualquer uma dessas variantes para declarar o tipo de um valor inteiro.

Tabela 3-1: Tipos inteiros em Rust

TamanhoCom sinalSem sinal
8 bitsi8u8
16 bitsi16u16
32 bitsi32u32
64 bitsi64u64
128 bitsi128u128
Depende da arquiteturaisizeusize

Cada variante pode ser com sinal ou sem sinal e tem um tamanho explícito. Com sinal e sem sinal indicam se o número pode ser negativo — em outras palavras, se o número precisa ter um sinal junto (com sinal) ou se ele será sempre positivo e pode, portanto, ser representado sem sinal (sem sinal). É como escrever números no papel: quando o sinal importa, um número é mostrado com um sinal de mais ou de menos; já quando é seguro presumir que o número é positivo, ele é mostrado sem sinal. Números com sinal são armazenados usando a representação em complemento de dois.

Cada variante com sinal pode armazenar números de −(2n − 1) até 2n − 1 − 1, inclusive, onde n é o número de bits que a variante usa. Assim, um i8 pode armazenar números de −(27) até 27 − 1, que dá −128 a 127. Variantes sem sinal podem armazenar números de 0 até 2n − 1, então um u8 pode armazenar números de 0 até 28 − 1, que dá 0 a 255.

Além disso, os tipos isize e usize dependem da arquitetura do computador em que seu programa está rodando: 64 bits se você estiver em uma arquitetura de 64 bits e 32 bits se estiver em uma de 32 bits.

Você pode escrever literais inteiros em qualquer uma das formas mostradas na Tabela 3-2. Observe que literais numéricos que podem ser de vários tipos numéricos aceitam um sufixo de tipo, como 57u8, para indicar o tipo. Literais numéricos também podem usar _ como separador visual para facilitar a leitura, como 1_000, que terá o mesmo valor que se você tivesse escrito 1000.

Tabela 3-2: Literais inteiros em Rust

Literais numéricosExemplo
Decimal98_222
Hexadecimal0xff
Octal0o77
Binário0b1111_0000
Byte (somente u8)b'A'

Então, como saber qual tipo de inteiro usar? Se você não tiver certeza, os padrões do Rust geralmente são bons pontos de partida: tipos inteiros usam i32 por padrão. A principal situação em que você usaria isize ou usize é ao indexar algum tipo de coleção.

Estouro de inteiro

Suponha que você tenha uma variável do tipo u8, que pode guardar valores entre 0 e 255. Se você tentar mudar a variável para um valor fora dessa faixa, como 256, ocorrerá um estouro de inteiro (integer overflow), que pode resultar em um de dois comportamentos. Quando você compila em modo de depuração, o Rust inclui verificações de estouro de inteiro que fazem seu programa entrar em panic em tempo de execução se esse comportamento acontecer. O Rust usa o termo panicking quando um programa termina com um erro; vamos discutir panics com mais profundidade na seção “Erros irrecuperáveis com panic!” do Capítulo 9.

Quando você compila em modo de release com a flag --release, o Rust não inclui verificações de estouro de inteiro que causem panics. Em vez disso, se ocorrer estouro, o Rust realiza wrapping em complemento de dois. Em resumo, valores maiores que o valor máximo que o tipo pode guardar “dão a volta” até o valor mínimo que o tipo pode guardar. No caso de um u8, o valor 256 vira 0, o valor 257 vira 1, e assim por diante. O programa não entra em panic, mas a variável terá um valor que provavelmente não é o que você esperava. Depender do comportamento de wrapping do estouro de inteiro é considerado um erro.

Para tratar explicitamente a possibilidade de estouro, você pode usar estas famílias de métodos fornecidas pela biblioteca padrão para tipos numéricos primitivos:

  • Dar a volta (wrapping) em todos os modos de compilação com os métodos wrapping_*, como wrapping_add.
  • Retornar o valor None se houver estouro com os métodos checked_*.
  • Retornar o valor e um booleano indicando se houve estouro com os métodos overflowing_*.
  • Saturar nos valores mínimo ou máximo do tipo com os métodos saturating_*.

Tipos de ponto flutuante

Rust também tem dois tipos primitivos para números de ponto flutuante, que são números com casas decimais. Os tipos de ponto flutuante do Rust são f32 e f64, que têm 32 bits e 64 bits de tamanho, respectivamente. O tipo padrão é f64 porque, em CPUs modernas, ele tem praticamente a mesma velocidade de f32, mas é capaz de mais precisão. Todos os tipos de ponto flutuante são com sinal.

Aqui está um exemplo que mostra números de ponto flutuante em ação:

Nome do arquivo: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Números de ponto flutuante são representados de acordo com o padrão IEEE-754.

Operações numéricas

Rust oferece suporte às operações matemáticas básicas que você espera para todos os tipos numéricos: adição, subtração, multiplicação, divisão e resto. A divisão de inteiros trunca em direção ao zero, até o inteiro mais próximo. O código a seguir mostra como você usaria cada operação numérica em uma instrução let:

Nome do arquivo: src/main.rs

fn main() {
    // addition
    let sum = 5 + 10;

    // subtraction
    let difference = 95.5 - 4.3;

    // multiplication
    let product = 4 * 30;

    // division
    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // Results in -1

    // remainder
    let remainder = 43 % 5;
}

Cada expressão nessas instruções usa um operador matemático e é avaliada para um único valor, que então é associado a uma variável. O Apêndice B contém uma lista de todos os operadores que Rust oferece.

O tipo booleano

Como na maioria das outras linguagens de programação, um tipo booleano em Rust tem dois valores possíveis: true e false. Booleanos têm um byte de tamanho. O tipo booleano em Rust é especificado usando bool. Por exemplo:

Nome do arquivo: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

A principal forma de usar valores booleanos é por meio de condicionais, como uma expressão if. Vamos ver como expressões if funcionam em Rust na seção “Controle de fluxo”.

O tipo caractere

O tipo char do Rust é o tipo alfabético mais primitivo da linguagem. Aqui estão alguns exemplos de declaração de valores char:

Nome do arquivo: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

Observe que especificamos literais char com aspas simples, diferentemente de literais de string, que usam aspas duplas. O tipo char do Rust tem 4 bytes de tamanho e representa um valor escalar Unicode, o que significa que ele pode representar muito mais do que apenas ASCII. Letras acentuadas; caracteres chineses, japoneses e coreanos; emojis; e espaços de largura zero são todos valores char válidos em Rust. Valores escalares Unicode vão de U+0000 até U+D7FF e de U+E000 até U+10FFFF, inclusive. No entanto, “caractere” não é realmente um conceito no Unicode, então a sua intuição sobre o que é um “caractere” pode não bater com o que é um char em Rust. Vamos discutir esse tema em detalhes na seção “Armazenando texto codificado em UTF-8 com strings” do Capítulo 8.

Tipos compostos

Tipos compostos podem agrupar vários valores em um só tipo. Rust tem dois tipos compostos primitivos: tuplas e arrays.

O tipo tupla

Uma tupla é uma forma geral de agrupar vários valores de tipos variados em um único tipo composto. Tuplas têm tamanho fixo: depois de declaradas, não podem crescer nem diminuir.

Criamos uma tupla escrevendo uma lista de valores separados por vírgula entre parênteses. Cada posição na tupla tem um tipo, e os tipos dos diferentes valores na tupla não precisam ser iguais. Adicionamos anotações de tipo opcionais neste exemplo:

Nome do arquivo: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

A variável tup está associada à tupla inteira, porque uma tupla é considerada um único elemento composto. Para obter os valores individuais de uma tupla, podemos usar pattern matching para desestruturar o valor da tupla, assim:

Nome do arquivo: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

Este programa primeiro cria uma tupla e a associa à variável tup. Depois, usa um padrão com let para pegar tup e transformá-la em três variáveis separadas, x, y e z. Isso é chamado de desestruturação porque quebra a tupla única em três partes. Por fim, o programa imprime o valor de y, que é 6.4.

Também podemos acessar um elemento de tupla diretamente usando um ponto (.) seguido do índice do valor que queremos acessar. Por exemplo:

Nome do arquivo: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

Este programa cria a tupla x e depois acessa cada elemento da tupla usando seus respectivos índices. Como na maioria das linguagens de programação, o primeiro índice em uma tupla é 0.

A tupla sem nenhum valor tem um nome especial, unit (unidade). Esse valor e o seu tipo correspondente são escritos ambos como () e representam um valor vazio ou um tipo de retorno vazio. Expressões retornam implicitamente o valor unit se não retornarem nenhum outro valor.

O tipo array

Outra forma de ter uma coleção de vários valores é com um array. Diferentemente de uma tupla, todo elemento de um array precisa ter o mesmo tipo. Diferentemente de arrays em algumas outras linguagens, arrays em Rust têm tamanho fixo.

Escrevemos os valores de um array como uma lista separada por vírgulas entre colchetes:

Nome do arquivo: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

Arrays são úteis quando você quer que seus dados sejam alocados na stack, como os outros tipos que vimos até aqui, em vez de na heap (vamos discutir mais sobre stack e heap no Capítulo 4), ou quando você quer garantir que sempre terá um número fixo de elementos. Um array, porém, não é tão flexível quanto o tipo vetor. Um vetor é um tipo de coleção semelhante, fornecido pela biblioteca padrão, que pode crescer ou diminuir de tamanho porque seu conteúdo fica na heap. Se você não tiver certeza se deve usar um array ou um vetor, as chances são de que você deva usar um vetor. O Capítulo 8 discute vetores em mais detalhes.

No entanto, arrays são mais úteis quando você sabe que o número de elementos não precisará mudar. Por exemplo, se você estivesse usando os nomes dos meses em um programa, provavelmente usaria um array em vez de um vetor, porque sabe que ele sempre terá 12 elementos:

#![allow(unused)]
fn main() {
let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
}

Você escreve o tipo de um array usando colchetes com o tipo de cada elemento, um ponto e vírgula e depois o número de elementos do array, assim:

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

Aqui, i32 é o tipo de cada elemento. Depois do ponto e vírgula, o número 5 indica que o array contém cinco elementos.

Você também pode inicializar um array para conter o mesmo valor em cada elemento, especificando o valor inicial, seguido de um ponto e vírgula e, depois, o tamanho do array entre colchetes, como mostrado aqui:

#![allow(unused)]
fn main() {
let a = [3; 5];
}

O array chamado a vai conter 5 elementos, todos inicialmente definidos com o valor 3. Isso é o mesmo que escrever let a = [3, 3, 3, 3, 3];, mas de forma mais concisa.

Acesso a elementos de array

Um array é um único bloco de memória de tamanho conhecido e fixo que pode ser alocado na stack. Você pode acessar elementos de um array usando indexação, assim:

Nome do arquivo: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

Neste exemplo, a variável chamada first vai receber o valor 1, porque esse é o valor no índice [0] do array. A variável chamada second vai receber o valor 2 do índice [1] do array.

Acesso inválido a elementos de array

Vamos ver o que acontece se você tentar acessar um elemento de array além do fim dele. Suponha que você rode este código, parecido com o jogo de adivinhação do Capítulo 2, para obter um índice de array do usuário:

Nome do arquivo: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Please enter an array index.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("Failed to read line");

    let index: usize = index
        .trim()
        .parse()
        .expect("Index entered was not a number");

    let element = a[index];

    println!("The value of the element at index {index} is: {element}");
}

Este código compila com sucesso. Se você rodar este código com cargo run e digitar 0, 1, 2, 3 ou 4, o programa vai imprimir o valor correspondente naquele índice do array. Se, em vez disso, você digitar um número além do fim do array, como 10, verá uma saída como esta:

thread 'main' panicked at src/main.rs:19:19:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

O programa resultou em um erro de execução no ponto em que um valor inválido foi usado na operação de indexação. O programa terminou com uma mensagem de erro e não executou a instrução println! final. Quando você tenta acessar um elemento usando indexação, o Rust verifica se o índice especificado é menor que o tamanho do array. Se o índice for maior ou igual ao tamanho, o Rust entra em panic. Essa verificação precisa acontecer em tempo de execução, especialmente neste caso, porque o compilador não tem como saber qual valor um usuário vai digitar quando rodar o código depois.

Este é um exemplo dos princípios de segurança de memória do Rust em ação. Em muitas linguagens de baixo nível, esse tipo de verificação não é feita e, ao fornecer um índice incorreto, memória inválida pode ser acessada. O Rust protege você contra esse tipo de erro encerrando imediatamente, em vez de permitir o acesso à memória e continuar. O Capítulo 9 discute mais sobre o tratamento de erros do Rust e como você pode escrever código legível e seguro que não entra em panic nem permite acesso a memória inválida.