Biblioteca Padrão Rust: visão geral completa para desenvolvedores

Biblioteca Padrão Rust: visão geral completa

A biblioteca padrão Rust (std) é a base sobre a qual qualquer aplicação nesta linguagem é construída. Ela fornece um conjunto de ferramentas confiáveis, eficientes e seguras para resolver tarefas típicas, desde o trabalho com coleções até o gerenciamento de memória de baixo nível. Ao contrário de muitas outras linguagens, a biblioteca padrão Rust é projetada para minimizar a dependência de crates externos para operações básicas, mantendo ao mesmo tempo um desempenho próximo ao de C/C++.

Módulos principais da biblioteca padrão

A biblioteca padrão é organizada em módulos lógicos. Vamos examinar os principais:

• std::collections — estruturas de dados: Vec, HashMap, HashSet, BTreeMap, LinkedList e outras.
• std::io — trabalho com entrada-saída: leitura/escrita de arquivos, trabalho com streams, bufferização.
• std::fs — sistema de arquivos: criação, exclusão, cópia de arquivos e diretórios.
• std::thread — multithreading: criação de threads, sincronização via Mutex, Arc.
• std::sync — primitivas de sincronização: canais (mpsc), barreiras, semáforos.
• std::net — programação de rede: sockets TCP/UDP, endereços.
• std::time — trabalho com tempo: medições, temporizadores, durações.
• std::mem — gerenciamento de memória: tamanhos de tipos, alinhamento, swap, replace.

Coleções: de Vec a HashMap

As coleções em Rust não são apenas contêineres. Elas implementam uma API rica e garantem segurança de memória em tempo de compilação. A coleção mais popular é Vec<T> — um array dinâmico.

fn main() {    let mut numbers: Vec<i32> = vec![1, 2, 3, 4];    numbers.push(5);        // Iteração com modificação    for num in &mut numbers {        *num *= 2;    }        // Filtragem    let evens: Vec<&i32> = numbers.iter()        .filter(|&&x| x % 2 == 0)        .collect();        println!("{:?}", evens); // [2, 4, 6, 8, 10]}

HashMap — um array associativo com hashing. É importante notar que, por padrão, é usado um algoritmo de hash criptograficamente seguro (SipHash), o que previne ataques do tipo HashDoS.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Alice"), 100);    scores.insert(String::from("Bob"), 85);        // Obtenção segura de valor    match scores.get(&String::from("Alice")) {        Some(score) => println!("Score: {}", score),        None => println!("Não encontrado"),    }        // Percorrimento com iterador    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

Trabalho com entrada-saída e arquivos

O módulo std::io fornece tanto ferramentas de alto nível quanto de baixo nível para trabalhar com streams de dados. Merecem atenção especial as traits Read e Write.

use std::fs::File;use std::io::{self, Read, Write};

fn read_file(path: &str) -> io::Result<String> {    let mut file = File::open(path)?;    let mut contents = String::new();    file.read_to_string(&mut contents)?;    Ok(contents)}

fn write_file(path: &str, data: &str) -> io::Result<()> {    let mut file = File::create(path)?;    file.write_all(data.as_bytes())?;    Ok(())}

fn main() -> io::Result<()> {    write_file("example.txt", "Olá, Rust