Стандартная библиотека Rust: полный обзор

Стандартная библиотека Rust (std) — это ядро экосистемы языка, предоставляющее разработчикам мощные и безопасные инструменты для создания высокопроизводительных приложений. В отличие от многих других языков, Rust уделяет особое внимание безопасности памяти и нулевой стоимости абстракций, что делает std не просто набором утилит, а фундаментом для написания надёжного кода. В этой статье мы подробно разберём основные модули стандартной библиотеки, их возможности и приведём практические примеры.

Основные модули стандартной библиотеки

Стандартная библиотека Rust включает в себя множество модулей, покрывающих практически все аспекты разработки. Рассмотрим ключевые из них:

std::collections — структуры данных (HashMap, Vec, BTreeMap, HashSet и др.)
std::io — ввод-вывод (чтение/запись файлов, работа с консолью)
std::fs — работа с файловой системой
std::thread — многопоточность
std::sync — синхронизация потоков (Mutex, Arc, Barrier)
std::net — сетевое программирование (TCP, UDP)
std::path — работа с путями файловой системы
std::error — обработка ошибок

Работа с коллекциями (std::collections)

Модуль std::collections предоставляет эффективные структуры данных. Самая популярная — Vec<T> (динамический массив). Также часто используются HashMap<K, V> для хранения пар ключ-значение и HashSet<T> для уникальных элементов.

use std::collections::HashMap;

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

    // Доступ по ключу
    match scores.get(&"Blue".to_string()) {
        Some(score) => println!("Score: {}", score),
        None => println!("No score found"),
    }
}

Ввод-вывод и работа с файлами (std::io и std::fs)

Модули std::io и std::fs позволяют читать и записывать файлы, работать с консольным вводом/выводом. Rust гарантирует безопасную работу с файлами благодаря системе владения.

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

fn main() -> std::io::Result<()> {
    // Запись в файл
    let mut file = File::create("example.txt")?;
    file.write_all(b"Hello, Rust!")?;

    // Чтение файла построчно
    let file = File::open("example.txt")?;
    let reader = BufReader::new(file);
    for line in reader.lines() {
        println!("{}", line?);
    }
    Ok(())
}

Многопоточность (std::thread)

Rust предоставляет безопасную модель многопоточности через модуль std::thread. Компилятор предотвращает гонки данных на этапе компиляции благодаря правилам владения и заимствования.

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

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

    for i in 1..3 {
        println!("Главный поток: {}", i);
        thread::sleep(Duration::from_millis(50));
    }

    handle.join().unwrap();
}

Синхронизация (std::sync)

Для безопасного обмена данными между потоками используются примитивы из std::sync: Mutex (взаимное исключение), Arc (атомарный счётчик ссылок) и Barrier (барьер синхронизации).

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 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Результат: {}", *counter.lock().unwrap());
}