Bibliothèque standard Rust : aperçu complet

Bibliothèque standard Rust : aperçu complet

La bibliothèque standard Rust (std) est le cœur de l'écosystème du langage, fournissant aux développeurs des outils puissants et sécurisés pour créer des applications hautes performances. Contrairement à de nombreux autres langages, Rust accorde une attention particulière à la sécurité mémoire et aux abstractions à coût zéro, ce qui fait de std non seulement un ensemble d'utilitaires, mais un fondement pour écrire du code fiable. Dans cet article, nous allons détailler les principaux modules de la bibliothèque standard, leurs fonctionnalités et fournir des exemples pratiques.

Modules principaux de la bibliothèque standard

La bibliothèque standard Rust comprend de nombreux modules couvrant pratiquement tous les aspects du développement. Examinons les plus importants :

• std::collections — structures de données (HashMap, Vec, BTreeMap, HashSet, etc.)
• std::io — entrées-sorties (lecture/écriture de fichiers, travail avec la console)
• std::fs — gestion du système de fichiers
• std::thread — multithreading
• std::sync — synchronisation des threads (Mutex, Arc, Barrier)
• std::net — programmation réseau (TCP, UDP)
• std::path — gestion des chemins du système de fichiers
• std::error — gestion des erreurs

Travail avec les collections (std::collections)

Le module std::collections fournit des structures de données efficaces. La plus populaire est Vec<T> (tableau dynamique). On utilise également fréquemment HashMap<K, V> pour stocker des paires clé-valeur et HashSet<T> pour des éléments uniques.

use std::collections::HashMap;

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

    // Accès par clé    match scores.get(&"Blue".to_string()) {        Some(score) => println!("Score : {}", score),        None => println!("Aucun score trouvé"),    }}

Entrées-sorties et gestion des fichiers (std::io et std::fs)

Les modules std::io et std::fs permettent de lire et d'écrire des fichiers, de travailler avec les entrées/sorties console. Rust garantit une gestion sécurisée des fichiers grâce à son système de possession.

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

fn main() -> std::io::Result<()> {    // Écriture dans un fichier    let mut file = File::create("example.txt")?;    file.write_all(b"Bonjour, Rust !")?;

    // Lecture du fichier ligne par ligne    let file = File::open("example.txt")?;    let reader = BufReader::new(file);    for line in reader.lines() {        println!("{}", line?);    }    Ok(())}

Multithreading (std::thread)

Rust fournit un modèle de multithreading sécurisé via le module std::thread. Le compilateur empêche les courses de données à la compilation grâce aux règles de possession et d'emprunt.

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();}

Synchronisation (std::sync)

Pour un échange sécurisé de données entre threads, on utilise les primitives de std::sync : Mutex (exclusion mutuelle), Arc (compteur de références atomique) et Barrier (barrière de synchronisation).

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 {\