12.11.2024

Aula 004: Sintaxe Básica do Rust e Controle de Fluxo

Nesta aula, vamos cobrir a sintaxe básica da linguagem de programação Rust. Também exploraremos estruturas de controle de fluxo, como condicionais e laços. Ao final desta aula, você deve ter uma compreensão sólida de como escrever programas simples em Rust com esses conceitos fundamentais.

Sintaxe Básica

A sintaxe do Rust foi projetada para ser clara e concisa. Vamos começar examinando a estrutura de um programa simples em Rust.

fn main() {
    println!("Olá, mundo!");
}

Explicação

• fn main(): Aqui, fn indica que estamos definindo uma função. main é uma função especial que serve como o ponto de entrada do programa.
• println!: Esta é uma macro que imprime texto no console. O ponto de exclamação (!) indica que se trata de uma macro, e não de uma função comum.
• "Olá, mundo!": Esta é uma string literal que será impressa no console quando o programa for executado.

Variáveis e Tipos de Dados

Em Rust, as variáveis são imutáveis por padrão. Você pode declarar uma variável mutável usando a palavra-chave mut.

fn main() {
    let x = 5; // variável imutável
    let mut y = 10; // variável mutável

    println!("x: {}, y: {}", x, y);

    y += 5; // modificando a variável mutável
    println!("y atualizado: {}", y);
}

Tipos de Dados

Rust possui um sistema de tipos estáticos e forte. Os tipos de dados comuns incluem:

• Tipos escalares: inteiros, números de ponto flutuante, booleanos e caracteres.
• Tipos compostos: tuplas e arrays.

Exemplo de Tipos de Dados

fn main() {
    let inteiro: i32 = 42;
    let ponto_flutuante: f64 = 3.14;
    let booleano: bool = true;
    let caractere: char = 'A';

    let tupla: (i32, f64, char) = (inteiro, ponto_flutuante, caractere);
    let array: [i32; 3] = [1, 2, 3];

    println!("Tupla: {:?}, Array: {:?}", tupla, array);
}

Controle de Fluxo

O controle de fluxo é essencial para escrever programas que podem tomar decisões e repetir tarefas. Rust fornece várias construções para esse propósito, incluindo declarações if, laços e expressões match.

1. Expressão if

fn main() {
    let numero = 10;

    if numero < 5 {
        println!("Número é menor que 5");
    } else if numero == 10 {
        println!("Número é igual a 10");
    } else {
        println!("Número é maior que 5 e não é igual a 10");
    }
}

2. Laçamentos com loop, while e for

• loop: Isso cria um laço infinito até ser explicitamente interrompido.

fn main() {
    let mut contagem = 0;

    loop {
        contagem += 1;
        if contagem == 5 {
            break; // sair do laço
        }
    }

    println!("Contagem atingida: {}", contagem);
}

• while: Laço enquanto uma condição for verdadeira.

fn main() {
    let mut contagem = 0;

    while contagem < 5 {
        contagem += 1;
    }

    println!("Contagem atingida: {}", contagem);
}

• for: Itera sobre um intervalo ou coleção.

fn main() {
    for numero in 1..6 { // intervalo de 1 a 5
        println!("Número: {}", numero);
    }

    let array = [10, 20, 30];

    for elemento in &array {
        println!("Elemento: {}", elemento);
    }
}

3. Expressão match

A expressão match permite a correspondência de padrões, que pode ser uma ferramenta muito poderosa em Rust.

fn main() {
    let numero = 2;

    match numero {
        1 => println!("Um"),
        2 => println!("Dois"),
        3 => println!("Três"),
        _ => println!("Não é um, dois ou três"), // correspondência curinga
    }
}

Conclusão

Nesta aula, você aprendeu sobre a sintaxe básica do Rust, como declarar variáveis, os diferentes tipos de dados disponíveis e as construções de controle de fluxo, incluindo condicionais, laços e correspondência de padrões. Esses são conceitos fundamentais que são amplamente utilizados na programação em Rust. Pratique escrevendo seus próprios programas em Rust para solidificar sua compreensão!

Navigation