12.11.2024

Lição: 003: Entendendo Variáveis e Tipos de Dados em Rust

Nesta aula, vamos explorar variáveis e tipos de dados em Rust. Entender como trabalhar com variáveis e tipos de dados é fundamental ao programar em Rust, especialmente ao desenvolver contratos inteligentes na blockchain Solana.

Variáveis em Rust

Em Rust, uma variável é uma ligação a um valor. Por padrão, as variáveis são imutáveis, o que significa que, uma vez que um valor é vinculado a um nome de variável, ele não pode ser alterado. Você pode criar variáveis mutáveis usando a palavra-chave mut.

Exemplo de Variáveis Imutáveis

fn main() {
    let x = 5;
    println!("O valor de x é: {}", x);
    // x = 6; // Essa linha causaria um erro de compilação porque x é imutável
}

Exemplo de Variáveis Mutáveis

fn main() {
    let mut y = 5;
    println!("O valor de y é: {}", y);
    y = 6; // Isso é permitido porque y é mutável
    println!("O novo valor de y é: {}", y);
}

Tipos de Dados em Rust

Rust é uma linguagem de tipagem estática, o que significa que o tipo de uma variável é conhecido durante a compilação. Ao criar uma variável, você pode especificar seu tipo ou deixar que Rust o infira.

Tipos Escalares

Rust possui quatro tipos escalares principais: inteiros, números de ponto flutuante, booleanos e caracteres.

1. Inteiros: Representam números inteiros e podem ser com sinal (permitindo valores negativos) ou sem sinal (apenas valores positivos).

   • Exemplo: i32, u32, i64, u64

2. Números de Ponto Flutuante: Representam números com parte fracionária.

   • Exemplo: f32, f64

3. Booleanos: Representam um valor de verdade, podendo ser true ou false.

4. Caracteres: Representam um único caractere e são denotados usando aspas simples.

   • Exemplo: 'A'

Exemplo de Tipos Escalares

fn main() {
    let inteiro: i32 = 10;
    let flutuante: f64 = 3.14;
    let booleano: bool = true;
    let caractere: char = 'R';

    println!("Inteiro: {}", inteiro);
    println!("Flutuante: {}", flutuante);
    println!("Booleano: {}", booleano);
    println!("Caractere: {}", caractere);
}

Tipos Compostos

Rust também suporta tipos compostos, que podem agrupar múltiplos valores juntos. Os dois principais tipos compostos são tuplas e arrays.

1. Tuplas: Uma coleção de tamanho fixo com tipos diferentes.

   • Exemplo: (i32, f64, char)

2. Arrays: Uma coleção de elementos do mesmo tipo com um comprimento fixo.

   • Exemplo: [i32; 5] (um array de cinco inteiros)

Exemplo de Tuplas e Arrays

fn main() {
    // Tupla
    let tup: (i32, f64, char) = (10, 3.14, 'R');
    let (x, y, z) = tup; // Desestruturação da tupla
    println!("Valores da tupla: x = {}, y = {}, z = {}", x, y, z);

    // Array
    let arr: [i32; 4] = [1, 2, 3, 4];
    for valor in arr.iter() {
        println!("Valor do array: {}", valor);
    }
}

Inferência de Tipos

Rust permite que o compilador inferira o tipo de uma variável com base em seu valor. Você não precisa sempre anotar os tipos explicitamente.

fn main() {
    let a = 10; // Rust infere que a é do tipo i32
    let b = 3.14; // Rust infere que b é do tipo f64

    println!("a: {}, b: {}", a, b);
}

Conclusão

Nesta aula, cobrimos os fundamentos das variáveis e tipos de dados em Rust. Aprendemos sobre variáveis imutáveis e mutáveis, exploramos tipos escalares e compostos, e discutimos a inferência de tipos. Esses conceitos são cruciais para construir aplicações eficazes em Rust e contratos inteligentes na Solana.

Sinta-se à vontade para experimentar os exemplos fornecidos e usá-los como referência em seus futuros projetos em Rust!

Navigation