Literais e operadores

Literal: são dados constantes escritos diretamente no código, cujo valor é visível à primeira vista, sendo a forma mais básica de representação de dados em um programa.

Seu valor é fixo e imutável, gravado diretamente no código e não pode ser alterado durante a execução. Não requer cálculos nem interpretação de variáveis; literalmente significa “valor escrito literalmente”.

Exemplo: os números 13 e 3.14 abaixo são literais, também chamados de valores literais em outras linguagens.

fn main() {
    println!("{}", 13);
    println!("{}", 3.14);
}Code language: JavaScript (javascript)

Para facilitar o aprendizado, a equipe oficial disponibiliza um editor Rust online. Não é preciso instalar um ambiente local para praticar a sintaxe básica do Rust, clique no link abaixo

Rust Playground

Literais

O Rust suporta literais dos tipos: inteiro, ponto flutuante, caractere, string, booleano, unidade (unit).

• Inteiro: 11
• Caractere: 'a' (aspas simples)
• String: "abc" (aspas duplas)
• Booleano: true / false
• Tipo unidade: ()

Diversas bases para inteiros

As bases são diferenciadas por um prefixo, válido apenas para inteiros:

• Hexadecimal: começa com 0x, ex: 0x1F
• Octal: começa com 0o, ex: 0o77
• Binário: começa com 0b, ex: 0b1010

Separador numérico

Dentro dos literais numéricos é possível inserir um underline _ para melhorar a legibilidade, não altera o valor real do número:

• Inteiro: 1_000 = 1000
• Ponto flutuante: 0.000_001 = 0.000001

Notação científica

Números de ponto flutuante aceitam a notação científica com E, o tipo padrão é f64:

• 1e6 = 1000000
• 7.6e-4 = 0,00076

Sufixos de tipo dos literais (fundamental)

No Rust é obrigatório declarar o tipo do literal, os sufixos mais utilizados são:

• u32: inteiro sem sinal de 32 bits (apenas valores não negativos)
• i32: inteiro com sinal de 32 bits (aceita números positivos e negativos)

Aviso: não é possível misturar operações com inteiros com e sem sinal, isso causará erro imediatamente.

Exemplo de código:

fn main() {
    // 1. Literal de inteiro comum
    println!("Inteiro: {}", 13);
    // Inteiros binário, octal, hexadecimal
    println!("Binário: {}", 0b1010);
    println!("Octal: {}", 0o77);
    println!("Hexadecimal: {}", 0x2A);
    // Inteiro com separador (melhora legibilidade)
    println!("Inteiro com underline: {}", 1_000_000);
    // Inteiro com sufixo de tipo
    println!("Inteiro u32 sem sinal: {}", 100u32);
    println!("Inteiro i32 com sinal: {}", -50i32);

    // 2. Literal de ponto flutuante
    println!("Ponto flutuante: {}", 3.14);
    // Ponto flutuante com underline
    println!("Ponto flutuante com underline: {}", 0.000_001);
    // Ponto flutuante em notação científica
    println!("Notação científica: {}", 1e6);
    println!("Notação científica negativa: {}", 7.6e-4);

    // 3. Literal de string (aspas duplas)
    println!("String: {}", "hello world");

    // 4. Literal de caractere (aspas simples, apenas um caractere)
    println!("Caractere: {}", 'a');
    println!("Caractere chinês: {}", '中');

    // 5. Literal booleano
    println!("Booleano true: {}", true);
    println!("Booleano false: {}", false);

    // 6. Literal de unidade () (tipo unidade do Rust)
    println!("Tipo unidade: {:?}", ());
}Code language: JavaScript (javascript)

Operadores

As regras e precedência dos operadores do Rust são semelhantes às linguagens da família C.

1. Operadores aritméticos

Operações básicas como soma e subtração, usados com sufixos de tipo de inteiros:

• Soma: +
• Subtração: -

2. Operadores lógicos booleanos (curto-circuito)

Só funcionam com valores booleanos true/false:

• E lógico &&: resultado true apenas se ambos os lados forem true
• Ou lógico ||: resultado true se pelo menos um dos lados for true
• Não lógico !: inverte o valor booleano

Expressão	Resultado da operação
true && true	true
true && false	false
false && true	false
false && false	false
true || true	true
true || false	true
false || true	true
false || false	false
!true	false
!false	true

3. Operadores bit a bit (manipulação de bits binários)

Usados principalmente em inteiros, o exemplo utiliza {:04b} para imprimir um número binário de 4 dígitos formatado:

1. E bit a bit &: bit resultante é 1 apenas se os dois bits da mesma posição forem 1
2. Ou bit a bit |: bit resultante é 1 se pelo menos um bit da mesma posição for 1
3. Ou exclusivo bit a bit ^: bit resultante é 1 se os bits da mesma posição forem diferentes, senão 0
4. Deslocamento à esquerda <<: move todos os bits binários para a esquerda (equivalente a ×2ⁿ)
5. Deslocamento à direita >>: move todos os bits binários para a direita (equivalente a ÷2ⁿ)

  0 0 1 1
& 0 1 0 1
-----------
  0 0 0 1  

  0 0 1 1
| 0 1 0 1
-----------
  0 1 1 1

  0 0 1 1
^ 0 1 0 1
-----------
  0 1 1 0

Deslocamento à esquerda <<
Binário: 00000001
Deslocar 5 bits → 00100000, resultado = 32

Deslocamento à direita >>
0x80 binário: 10000000
Deslocar 2 bits → 00100000 (hexadecimal 0x20), resultado = 32

fn main() {
    // ========== Operadores aritméticos ==========
    // Soma de inteiro: u32 inteiro sem sinal de 32 bits
    // Resultado: 1 + 2 = 3
    println!("1 + 2 = {}", 1u32 + 2);

    // Subtração de inteiro: i32 inteiro com sinal de 32 bits, aceita negativos
    // Se trocar para 1u32 ocorre erro, inteiro sem sinal não representa números negativos
    // Resultado: 1 - 2 = -1
    println!("1 - 2 = {}", 1i32 - 2);

    // ========== Literais de ponto flutuante - notação científica ==========
    // Resultado: 1e4 vale 10000, -2.5e-3 vale -0,0025
    println!("1e4 vale {}, -2.5e-3 vale {}", 1e4, -2.5e-3);

    // ========== Operadores lógicos booleanos (curto-circuito) ==========
    // E lógico &&: resultado true apenas se os dois lados forem true
    // Resultado: true E false = false
    println!("true E false = {}", true && false);

    // Ou lógico ||: resultado true se um dos lados for true
    // Resultado: true Ou false = true
    println!("true Ou false = {}", true || false);

    // Não lógico !: inverte valor booleano
    // Resultado: Não true = false
    println!("Não true = {}", !true);

    // ========== Operadores bit a bit (manipulação de bits binários) ==========
    // {:04b} imprime sempre 4 dígitos binários, preenchendo com 0 à esquerda se faltar dígitos
    // E bit a bit &: bit resultado é 1 só se ambos os bits correspondentes forem 1
    // Resultado: 0011 E bit a bit 0101 = 0001
    println!("0011 E bit a bit 0101 = {:04b}", 0b0011u32 & 0b0101);

    // Ou bit a bit |: bit resultado é 1 se qualquer bit correspondente for 1
    // Resultado: 0011 Ou bit a bit 0101 = 0111
    println!("0011 Ou bit a bit 0101 = {:04b}", 0b0011u32 | 0b0101);

    // Ou exclusivo bit a bit ^: bit resultado é 1 se bits correspondentes forem diferentes
    // Resultado: 0011 Ou exclusivo bit a bit 0101 = 0110
    println!("0011 Ou exclusivo bit a bit 0101 = {:04b}", 0b0011u32 ^ 0b0101);

    // Deslocamento à esquerda <<: mover todos os bits 5 posições para a esquerda
    // Resultado: 1 deslocado 5 bits à esquerda = 32
    println!("1 deslocado 5 bits à esquerda = {}", 1u32 << 5);

    // Deslocamento à direita >>: mover todos os bits 2 posições para a direita, {:x} exibe hexadecimal
    // Resultado: 0x80 deslocado 2 bits à direita = 0x20
    println!("0x80 deslocado 2 bits à direita = 0x{:x}", 0x80u32 >> 2);

    // ========== Separador numérico _ ==========
    // O underline só melhora legibilidade, não altera o valor do número
    // Resultado: Um milhão se escreve: 1000000
    println!("Um milhão se escreve: {}", 1_000_000u32);
}Code language: JavaScript (javascript)

---

III. Observações complementares sobre execução do código

1. Substituir 1i32 por 1u32 e executar a subtração 1u32 - 2 gera erro: inteiros sem sinal não conseguem representar valores negativos.
2. {:04b}: sintaxe de formatação, b significa binário, 04 completa com zeros à esquerda se houver menos de 4 dígitos.
3. Para números grandes recomenda-se usar underline como separador (ex: 1_000_000u32), deixa o código mais fácil de ler.