Introdução ao Rust

Rust é uma linguagem de programação de sistema moderna, segura e eficiente. Ela é projetada para fornecer controle próximo ao hardware sem sacrificar a segurança ou a produtividade do desenvolvedor. Neste artigo, vamos dar uma introdução ao Rust e fornecer alguns exemplos para ajudar você a começar a desenvolver com essa linguagem.

Instalando Rust

Antes de começar a escrever código em Rust, você precisa instalar o compilador e outras ferramentas necessárias. A maneira mais fácil de fazer isso é usando o gerenciador de pacotes oficial da linguagem, o Rustup.

Para instalar o Rustup, abra um terminal e execute o seguinte comando:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Depois de instalar o Rustup, você pode usar o comando rustup toolchain install stable para instalar a versão mais recente estável do Rust.

Hello, World!

A primeira coisa que todo programador deve fazer ao aprender uma nova linguagem é escrever um programa "Hello, World!". Aqui está como fazer isso em Rust:

fn main() {
    println!("Hello, World!"); // Hello, World!
}

Este programa imprime a mensagem "Hello, World!" no console. Se você já programou em C ou C++, provavelmente a sintaxe acima lhe parece familiar. A diferença mais importante aqui é que o Rust é uma linguagem mais segura do que o C e o C++, pois é menos suscetível a erros de memória e segurança.

Variáveis

Em Rust, você pode criar variáveis usando a palavra-chave let. O tipo da variável é inferido pelo compilador, mas você também pode especificá-lo manualmente.

fn main() {
    let x = 5; // x é do tipo i32
    let y: i32 = 10; // y é do tipo i32
    println!("x = {}, y = {}", x, y); // x = 5, y = 10
}

Neste exemplo, criamos duas variáveis, x e y, uma com o tipo inferido e outra com o tipo especificado manualmente como i32. Depois, imprimimos o valor das duas variáveis no console usando a macro println!.

Estruturas de dados

O Rust possui várias estruturas de dados úteis, incluindo vetores e structs. Aqui está um exemplo de como usar um vetor:

fn main() {
    let mut v = vec![1, 2, 3]; // v é um vetor de i32
    v.push(4); // adiciona o número 4 ao vetor
    for i in &v { // itera sobre o vetor
        println!("{}", i); // 1, 2, 3, 4
    }
}

Neste exemplo, criamos um vetor v com os valores 1, 2 e 3. Depois, usamos o método push para adicionar o valor 4 ao vetor. Por fim, iteramos sobre os valores do vetor usando um loop for e imprimimos cada valor no console.

Aqui está um exemplo de como usar uma struct:

struct Person {
    name: String,
    age: u32,
}

fn main() {
    let p = Person {
        name: String::from("John"),
        age: 30,
    };
    println!("{} is {} years old", p.name, p.age); // John is 30 years old
}

Neste exemplo, definimos uma struct chamada Person com duas propriedades, name e age. Em seguida, criamos uma nova instância de Person com um nome e idade específicos e, finalmente, imprimimos essas informações no console.

Funções

As funções em Rust são definidas usando a palavra-chave fn. Aqui está um exemplo de uma função que calcula a soma de dois números:

fn sum(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let result = sum(5, 10);
    println!("5 + 10 = {}", result); // 5 + 10 = 15
}

Neste exemplo, definimos uma função chamada sum que recebe dois parâmetros a e b do tipo i32 e retorna a soma dos dois valores. Em seguida, chamamos a função sum com os valores 5 e 10 e imprimimos o resultado no console.

Conclusão

Este artigo apresentou uma introdução básica ao Rust e exemplos de variáveis, estruturas de dados e funções. Se você deseja aprofundar seus conhecimentos em Rust, aqui estão 10 tópicos importantes para estudar:

  1. Propriedade de propriedade e empréstimos
  2. Macros
  3. Tipos genéricos
  4. Estruturas de dados, como structs e enums
  5. Tratamento de erros e panics
  6. Traits e implementação
  7. Concorrência e paralelismo
  8. Rust FFI (interface de funções estrangeiras)
  9. Módulos e organização de código
  10. Gerenciamento de memória e ciclo de vida de objetos

Ao explorar esses tópicos, você poderá se aprofundar nas capacidades do Rust e criar código eficiente, seguro e escalável.

Referências