Você está aqui: Rust ::: Fundamentos da Linguagem ::: Tipos de Dados

Tipos de dados da linguagem Rust

Quantidade de visualizações: 315 vezes

Como ocorre na maioria das linguagens de programação, a linguagem Rust dá suporte a quatro tipos de dados primários: inteiro, real, boolean e caractere.

Os TIPOS INTEIROS podem armazenar apenas valores numéricos sem a parte decimal, ou seja, sem valores após a vírgula. Veja a relação a seguir:

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

Note que o tipo com sinal reserva o primeiro bit para sinalizar se o valor é positivo ou negativo. No caso dos tipos sem sinais os valores são sempre positivos. Em geral usamos os tipos sem sinal justamente para ganharmos um bit a mais. Assim, se o tipo i8 pode guardar valores da faixa -128 a 127, o tipo u8 vai de 0 a 255.

Veja um trecho de código no qual declaramos duas variáveis, um do tipo i8 e uma do tipo u8:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// esta é a função principal do programa Rust
fn main() {
  // vamos criar duas variáveis do tipo inteiro
  let mut a:i8 = -5;
  let mut b:u8 = 200;
  
  // vamos provocar erros aqui
  a = 200;
  b = -30;
}

A linha que atribui o valor 200 à variável a vai gerar o seguinte erro:

= note: `#[deny(overflowing_literals)]` on by default
= note: the literal `200` does not fit into the type `i8` whose range is `-128..=127`
= help: consider using the type `u8` instead

De fato, a mensagem de erro está correta, pois o valor máximo positivo para o tipo i8 é 127.

Já a atribuição do valor -30 à variável b provocará o erro:

= note: unsigned values cannot be negated

Mais uma vez a mensagem de erro está correta, uma vez que os tipos sem sinal só podem guardar valores positivos.

A linguagem Rust possui suporte a dois TIPOS REAIS, ou seja, ponto-flutuante ou com casas decimais. Veja:

Tamanho        Tipo
---------------------
32 bits        f32
64 bits        f64

Aqui a letra "f" indica ponto-flutuante e o tamanho indica a quantidade de bits necessários para armazenar o valor.

O tipo BOOLEAN é representado na linguagem Rust pela palavra-chave bool e pode guardar apenas os valores true ou false. O valor padrão é false. Veja o trecho de código a seguir:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// esta é a função principal do programa Rust
fn main() {
  // vamos criar uma variável do tipo boolean
  let continuar:bool = true;
}

O tipo CARACTERE é representado pelo tipo char, que pode representar letras, números e símbolos. Valores atribuídos à variáveis do tipo char devem ser expressos entre aspas simples. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// esta é a função principal do programa Rust
fn main() {
  // vamos criar uma variável do tipo char
  let letra:char = 'm';
  println!("A letra é: {}", letra);
}

Link para compartilhar na Internet ou com seus amigos:

Rust ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como somar os elementos de um array em Rust

Quantidade de visualizações: 515 vezes

Nesta dica mostrarei como podemos somar os valores de um vetor na linguagem Rust. Para isso nós vamos usar um laço for e percorrer os itens do array um de cada vez. Note também o uso da função len() para retornar o tamanho do array.

Veja o código Rust completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// esta é a função principal do programa Rust
fn main() {
  // vamos criar um array com 6 elementos
  let valores:[i32;6] = [5, 2, 3, 7, 4, 1];
  // para guardar a soma
  let mut soma:i32 = 0;
  
  // vamos mostrar o conteúdo do array
  println!("Os elementos do array são: {:?}", valores);
 
  // agora vamos somar os elementos do array
  for i in 0..valores.len() {
    soma = soma + valores[i];
  }  
  
  // e mostramos o resultado
  println!("A soma dos elementos é: {}", soma);
}

Ao executarmos este código Rust nós teremos o seguinte resultado:

Os elementos do array são: [5, 2, 3, 7, 4, 1]
A soma dos elementos é: 22

Rust ::: Dicas & Truques ::: Strings e Caracteres

Como testar se uma string é um valor numérico em Rust usando a função is_numeric()

Quantidade de visualizações: 548 vezes

Nesta dica mostrarei como podemos verificar se uma string possui um valor numérico válido, ou seja, é composta apenas pelos dígitos de 0 a 9. Note que criei uma função validar_string_numerica() que recebe a string e retorna um valor bool, indicando se a string é um valor númerico válido ou não.

Note também o uso do método is_numeric() do tipo char para testar os caracteres individuais da string.

Veja o código Rust completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// função principal do programa Rust
fn main() {
  // vamos declarar uma string
  let numero = "3a2221";
  
  // vamos testar se a string é numérica
  if validar_string_numerica(numero.to_string()){
    println!("A string {} é numérica", numero);  
  }
  else{
    println!("A string {} não é numérica", numero);  
  }
}

// função quer permite verificar se uma string
// possui um valor numérico válido
fn validar_string_numerica(str: String) -> bool {
  // vamos varrer os caracteres da string
  for c in str.chars() {
    // o caractere atual não é numérico?
    if !c.is_numeric() {
      return false;
    }
  }
  
  // se chegou até aqui, a string é numérica
  return true;
}

Rust ::: Fundamentos da Linguagem ::: Compilador rustc

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc

Quantidade de visualizações: 557 vezes

Então você já fez a instalação do Rust, testou o seu funcionamento disparando "rustc --version" em uma janela de terminal e agora quer começar a aprender mais sobre a linguagem? Que tal começar escrevendo o famoso "Hello, World!" ("Olá, Mundo!")?

Nesta dica mostrarei como essa tarefa é fácil, principalmente se optarmos pelo uso da ferramenta rustc. Lembre-se, no entanto, que rustc é usado diretamente quando estamos escrevendo aplicações simples, provas de conceito, protótipos e coisas assim. Para aplicações mais complexas, é sempre recomendado o uso do Cargo, que é um sistema de build e gerenciador de pacotes do Rust.

Então vamos começar. Abra o seu editor de códigos favorito (tal como o Notepad++) e digite a seguinte listagem:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

fn main() {
  println!("Hello, world! Aqui é Rust na veia.");
}

Salve este arquivo como "estudos.rs" no diretório de sua preferência. Aqui eu optei por salvá-lo em um diretório chamado "C:\estudos_rust".

Agora vamos compilar nosso programa Rust. Abra uma janela de terminal e navegue até o diretório que você salvou o arquivo "estudos.rs" e dispare o comando abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

C:\Users\Osmar>cd c:\estudos_rust
c:\estudos_rust>rustc estudos.rs

Se tudo correr bem, você verá a criação de um arquivo "estudos.exe". Para executá-lo pela linha de comando nós só precisamos disparar:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

c:\estudos_rust>estudos
Hello, world! Aqui é Rust na veia.

Simples, né? No entanto, se dermos duplo-clique em cima do executável gerado, ele abre e fecha automaticamente. Não seria bom exibir uma mensagem do tipo "Pressione uma tecla para fechar..."? Basta modificar seu código para a versão abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// importamos a biblioteca io
use std::io;
use std::io::Write;

fn main() {
  println!("Hello, world! Aqui é Rust na veia.");
  
  // procedimento para pausar o programa
  let mut resposta = String::new();
  print!("\nPressione Enter para sair...");
  io::stdout().flush().unwrap();
  io::stdin().read_line(&mut resposta)
    .expect("Erro ao ler a entrada do usuário");
}

Sim, eu sei que agora nós adicionamos código demais para alcançar um detalhe tão simples. Mas, à medida que a linguagem Rust evolui, talvez os desenvolvedores resolvam simplificar esta parte. Compile o programa novamente e experimente abrir o executável com duplo-clique. Você verá que agora o programa fica aguardando o pressionamento da tecla Enter para fechar.

Veja mais Dicas e truques de Rust

Como remover espaços no início e fim de uma string em Rust usando o método trim() da estrutura String

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc

Como testar se uma substring está contida em uma string em Rust usando a função find()

Como testar se um valor está contido em um HashSet do Rust usando a função contains()

Como retornar parte de uma string em Rust usando o método get() da estrutura String

Como inverter o conteúdo de uma string em Rust usando um laço loop e um vetor de chars

Como inverter uma string em Rust usando os métodos chars(), rev() e collect()

Como criar um HashSet em Rust

Como encontrar o maior valor em um array em Rust

Como acessar os caracteres individuais de uma string em Rust usando as funções chars() e nth()

Dicas e truques de outras linguagens

Java - Java Collections - Como usar a interface Set em seus códigos Java

Dart - Exercício Resolvido de Dart - Escreva um programa Dart que usa o laço for para desenhar um padrão de diamante de estrelas

Delphi - Como usar a propriedade Eof para verificar se estamos no último registro do TClientDataSet do Delphi

PHP - Exercícios Resolvidos de PHP - Como calcular salário líquido em PHP - Calculando o salário líquido de um professor

Java - Java Threads - Como interromper a execução de uma thread em suas aplicações Java

C++ - Como somar os elementos da diagonal principal de uma matriz em C++

JavaScript - Como calcular a quantidade de dias restantes para uma determinada data em JavaScript

Java - Como converter de hexadecimal para decimal usando o método parseInt() da classe Integer da linguagem Java

Java - Exercícios Resolvidos de Java - Como converter de decimal para binário usando os operadores de bits em Java

PHP - PHP para iniciantes - Como usar o laço while em PHP

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e Fornecedores

Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais

Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby

Você está aqui: Rust ::: Fundamentos da Linguagem ::: Tipos de Dados

Tipos de dados da linguagem Rust

Rust ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como somar os elementos de um array em Rust

Rust ::: Dicas & Truques ::: Strings e Caracteres

Como testar se uma string é um valor numérico em Rust usando a função is_numeric()

Rust ::: Fundamentos da Linguagem ::: Compilador rustc

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc

Questões de Concurso para Engenharia Civil

Exercícios Resolvidos

Bancos de Dados

Questões de Concurso

Frameworks

Projetos e Códigos Fonte

Especializações

Calculadoras

Ferramentas

Todas as Linguagens, Frameworks, Biliotecas e Bancos de Dados

Compre pelo WhatsApp: +55 (062) 98553-6711

E-Book 650 Dicas e Truques de Python - Com comentários em Português

PDF COM 1.200 PÁGINAS

Apenas R$ 32,90