Bóson Treinamentos em Ciência e Tecnologia

Tipos de Dados em Rust

Fábio dos Reis
Tipos de Dados em Rust

Tipos de Dados em Rust

Os valores dos dados que são processados e armazenados, no Rust, são classificados em um determinado tipo de dados, de modo que o Rust saiba como lidar com cada dado em particular.

O Rust é uma linguagem de tipagem estática, o que significa que ela precisa saber os tipos de todas as variáveis em tempo de compilação.

Os tipos de dados em Rust são divididos em duas grandes categorias: Tipos Escalares e Tipos Compostos. Neste tutorial vamos nos focar nos tipos escalares em Rust, e no próximo, estudaremos os tipos compostos.

Tipos Escalares em Rust

Um tipo escalar representa um valor único. A linguagem Rust possui suporte a quatro tipos escalares primários, que são:

Vamos estudar cada tipo separadamente.

Tipo Inteiro em Rust

Se refere a números sem uma parte decimal (fracionária). Os principais tipos inteiros em Rust são:

Tabela 1.1: Tipos Inteiros em Rust

Comprimento Com Sinal Sem Sinal
8 bits i8 u8
16 bits i16 u16
32 bits i32 u32
64 bits i64 u64
128 bits i128 u128

Com sinal e sem sinal indicam se o número pode ser negativo (com ou sem sinal de negativo: -).

Cada tipo com sinal pode armazenar números de -(2n – 1) a 2n – 1 – 1 inclusive, onde n é o número de bits que o tipo em particular usa. Assim, um inteiro do tipo i8 pode armazenar números de -(27) até 27 – 1, que equivale à faixa numérica de -128 a 127.

Já tipos sem sinal podem armazenar números de 0 a 2n – 1 (ou seja, somente positivos), e assim um tipo inteiro u8 consegue armazenar números de 0 a 28 – 1, que é a faixa de 0 a 255.

O tipo inteiro padrão em Rust é o i32, que significa que se o tipo não for explicitamente declarado, será assumido um número inteiro com sinal (i), que pode representar valores positivos e negativos, ocupando um espaço de 32 bits na memória RAM.

Chamamos de Inferência de Tipo quando um tipo não é explicitamente declarado.

Exemplo:

fn main() {
  let a = 90;
  let g: u32 = 100;
  let x: i32 = -250;
  println!("Tipo Inteiro com sinal: {}", a);
  println!("Outro dado inteiro, sem sinal: {}", g);
  println!("Mais um inteiro com sinal, declarado explicitamente: {}", x);
}

Tipo de Ponto Flutuante em Rust

Tipos de ponto flutuante são aqueles que representam as casas decimais – são os números quebrados, coloquialmente.

Em Rust os tipos de ponto flutuante são f32 e f64, de tamanhos 32 e 64 bits, respectivamente. O padrão é o tipo f64, e ambos os tipos possuem sinal.

O tipo f32 é de precisão simples (“float“), e o tipo f64, de precisão dupla (“double“).

Exemplo:

fn main() {
  let b: f32 = 6.000001; // se houver mais um zero na parte decimal, o valor será exibido incorretamente
  let d: f64 = 6.0000000001; // exibe o valor normalmente
  println!("{}", b);
  println!("{}", d);
}

Tipo Booleano

Um tipo booleano é um tipo lógico, que suporta apenas dois valores possíveis: true e false (verdadeiro e falso). Este tipo possui tamanho de um byte, e é declarado com a palavra-chave bool.

São empregados comumente em estruturas de decisão e laços de repetição, onde uma condição deve ser avaliada para decidir o que o programa fará na sequência.

Exemplo:

fn main() {
  let V: bool = true;
  let F: bool = false;
  println!("{}", V);
  println!("{}", F);
}

Tipo de Caractere

O tipo padrão para armazenamento de caracteres em Rust é o tipo char. Este tipo, cujos dados são representados entre aspas simples, ocupa quatro bytes por dado e representa um valor escalar Unicode. Sendo assim, consegue representar caracteres ASCII, símbolos e caracteres especiais, caracteres em idiomas orientais (Chinês, Japonês, Coreano, etc.), emojis e muitos outros.

Exemplo:

fn main() {
  let c: char = 'Q';
  println!("{}", c);
}

Note que o tipo char é empregado para o armazenamento de um caractere único. Sendo assim, a declaração a seguir está incorreta, e irá gerar um erro ao compilarmos:

fn main() {
  let c: char = 'Morango';
  println!("{}", c);
}

Como declaramos um tipo para representar mais de um caractere então? Para isso necessitamos de um tipo para armazenamento de strings.

Strings em Rust

Uma string é uma cadeia de caracteres, que empregamos para armazenar dados comuns como nomes, palavras, códigos, descrições, etc.

Em Rust, existe um tipo string, com suporte a UTF-8.

Para criarmos um dado do tipo string, devemos representar seu valor entre aspas duplas, como no exemplo a seguir:

fn main() {
  let nome = "Fábio dos Reis";
  println!("{}", nome);
}

Neste exemplo, “Fábio dos Reis” é um literal de string e o tipo é &’static str. Um literal de string é uma fatia de string alocada de forma estática, o que significa que ela fica armazenada dentro do programa compilado, existindo enquanto o programa estiver em execução.

Em Rust, existe um outro tipo para armazenamento de Strings. Trata-se do tipo String, cujo tamanho pode crescer dinamicamente. É possível criar objetos do tipo String convertendo uma fatia de string com o método to_string().

Confuso? Não se preocupe. Teremos um tutorial especial dedicado às strings em Rust. Por enquanto, basta declarar os dados do tipo string envolvendo-os em aspas duplas ao declarar uma variável, como no exemplo a seguir:

fn main() {
 let canal = "Bóson Treinamentos em Tecnologia!";
 println!("{}", canal);
}

Nas próximas lições vamos dar uma olhada em alguns tipos compostos em Rust, além de aprender a realizar a conversão de um tipo em outro (casting de tipos).

Perguntas e Respostas comuns

O que é um Tipo de Dado em programação?
Tipo de dado é uma classificação que especifica qual tipo de valor uma variável pode armazenar, e que tipos de operações matemáticas, relacionais ou lógicas podem ser aplicadas a essa variável, sem causar erros.

Quais são os tipos escalares em Rust?
Os tipos escalares em Rust são o tipo inteiro, de ponto flutuante , booleano e de caracteres.

O que significa tipo com sinal e tipo sem sinal?
Tipo com sinal indica que o número pode ser negativo (com sinal –), e tipo sem sinal, que o número somente pode ser positivo.

Referências

Sair da versão mobile