Biblioteca Padrão Rust: visão geral completa

Biblioteca Padrão Rust: visão geral completa

A biblioteca padrão Rust (std) é o núcleo do ecossistema da linguagem, fornecendo aos desenvolvedores ferramentas poderosas e seguras para criar aplicações de alto desempenho. Ao contrário de muitas outras linguagens, o Rust dá atenção especial à segurança de memória e abstrações de custo zero, tornando a std não apenas um conjunto de utilitários, mas a base para escrever código confiável. Neste artigo, detalharemos os principais módulos da biblioteca padrão, seus recursos e forneceremos exemplos práticos.

Módulos principais da biblioteca padrão

A biblioteca padrão Rust inclui muitos módulos que cobrem praticamente todos os aspectos do desenvolvimento. Vamos analisar os principais:

• std::collections — estruturas de dados (HashMap, Vec, BTreeMap, HashSet, etc.)
• std::io — entrada e saída (leitura/escrita de arquivos, trabalho com console)
• std::fs — trabalho com sistema de arquivos
• std::thread — multithreading
• std::sync — sincronização de threads (Mutex, Arc, Barrier)
• std::net — programação de rede (TCP, UDP)
• std::path — trabalho com caminhos do sistema de arquivos
• std::error — tratamento de erros

Trabalhando com coleções (std::collections)

O módulo std::collections fornece estruturas de dados eficientes. A mais popular é Vec<T> (array dinâmico). Também são frequentemente usados HashMap<K, V> para armazenar pares chave-valor e HashSet<T> para elementos únicos.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Blue"), 10);    scores.insert(String::from("Yellow"), 50);

    // Acesso por chave    match scores.get(&"Blue".to_string()) {        Some(score) => println!("Score: {}", score),        None => println!("Nenhum score encontrado"),    }}

Entrada e saída e trabalho com arquivos (std::io e std::fs)

Os módulos std::io e std::fs permitem ler e escrever arquivos, trabalhar com entrada/saída de console. O Rust garante trabalho seguro com arquivos graças ao sistema de ownership.

use std::fs::File;use std::io::{BufRead, BufReader, Write};

fn main() -> std::io::Result<()> {    // Escrita em arquivo    let mut file = File::create("example.txt")?;    file.write_all(b"Olá, Rust!")?;

    // Leitura de arquivo linha por linha    let file = File::open("example.txt")?;    let reader = BufReader::new(file);    for line in reader.lines() {        println!("{}", line?);    }    Ok(())}

Multithreading (std::thread)

O Rust fornece um modelo seguro de multithreading através do módulo std::thread. O compilador previne condições de corrida em tempo de compilação graças às regras de ownership e borrowing.

use std::thread;use std::time::Duration;

fn main() {    let handle = thread::spawn(|| {        for i in 1..5 {            println!("Thread: {}", i);            thread::sleep(Duration::from_millis(100));        }    });

    for i in 1..3 {        println!("Thread principal: {}", i);        thread::sleep(Duration::from_millis(50));    }

    handle.join().unwrap();}

Sincronização (std::sync)

Para troca segura de dados entre threads, são usados primitivos de std::sync: Mutex (exclusão mútua), Arc (contador de referência atômico) e Barrier (barreira de sincronização).

use std::sync::{Arc, Mutex};use std::thread;

fn main() {    let counter = Arc::new(Mutex::new(0));    let mut handles = vec![];

    for _ in 0..10 {\