Bibliothèque standard de Rust : aperçu complet des modules et fonctionnalités principales

Bibliothèque standard de Rust : aperçu complet

La bibliothèque standard de Rust (std) est un ensemble de modules fondamentaux qui fournissent au développeur tout le nécessaire pour créer des applications fiables, rapides et sécurisées. Contrairement à de nombreux autres langages, Rust accorde une attention particulière à la sécurité mémoire et au parallélisme sans ramasse-miettes. Dans cet article, nous allons détailler les composants clés de std avec des exemples de code.

1. Modules principaux de la bibliothèque standard

La bibliothèque est divisée en plusieurs groupes logiques. Examinons les plus importants.

1.1. Module std::collections

Contient des structures de données pour stocker et gérer des collections d'éléments. Les plus populaires :

• Vec<T> — tableau dynamique (équivalent de ArrayList en Java).
• HashMap<K, V> — table de hachage pour stocker des paires clé-valeur.
• HashSet<T> — ensemble de valeurs uniques.
• BTreeMap et BTreeSet — collections triées basées sur un arbre rouge-noir.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Alice"), 100);    scores.insert(String::from("Bob"), 90);

    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

1.2. Module std::io

Gère les entrées-sorties : lecture au clavier, travail avec les fichiers, entrées-sorties tamponnées. Traits clés : Read et Write.

use std::io::{self, BufRead};

fn main() -> io::Result<()> {    let stdin = io::stdin();    for line in stdin.lock().lines() {        println!("Vous avez saisi : {}", line?);    }    Ok(())}

1.3. Module std::thread

Permet de créer et de gérer des threads d'exécution. Rust garantit la sécurité des données entre les threads grâce au système de possession et aux traits Send et Sync.

use std::thread;

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

    for i in 1..5 {        println!("Thread principal : {}", i);    }

    handle.join().unwrap();}

2. Travail avec les chaînes de caractères et le texte

En Rust, il existe deux types de chaînes :

• String — chaîne mutable et propriétaire (stockée dans le tas).
• &str — tranche de chaîne immuable (référence à une séquence UTF-8).

fn main() {    let mut hello = String::from("Bonjour, ");    hello.push_str("le monde !");    println!("{}", hello); // Affiche : Bonjour, le monde !

    let slice: &str = &hello[0..7];    println!("Tranche : {}", slice); // Affiche : Bonjour}

3. Gestion des erreurs

Au lieu d'exceptions, Rust utilise deux énumérations :

• Option<T> — pour les cas où une valeur peut être absente (Some ou None).
• Result<T, E> — pour les opérations pouvant échouer (Ok ou Err).

use std::fs::File;use std::io::Read;

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

fn main() {    match read_file("test.txt") {        Ok(content) => println!("Contenu : {}", content),        Err(e) => eprintln!("Erreur : {}", e),    }}

4. Itérateurs et fermetures

Les itérateurs en Rust sont paresseux et puissants. Ils permettent de traiter des séquences de données sans boucles explicites.

fn main() {    let numbers = vec![1,