rust/readme.md at main

Files

e2hang 23f17bfc2c New Rust

2025-10-05 23:51:24 +08:00

9.0 KiB

Raw Permalink Blame History

当然可以 👍 Rust 的 std（标准库，standard library） 是整个语言生态的核心组成部分，它提供了 语言运行时支持、内存管理、集合、I/O、并发、系统接口、错误处理、数值计算 等几乎所有基础功能。我可以帮你系统地、分层地介绍一遍「std 的全貌 + 每个模块的主要功能 + 常用类型和技巧」。

🧱 一、`std` 总体结构

Rust 标准库的顶层结构大体可以分为以下几层：

层级	模块	说明
基础层	`std::marker`, `std::mem`, `std::ptr`, `std::cell`, `std::rc`, `std::sync`	管理内存、引用、生命周期、并发引用计数等底层特性
语言支持层	`std::ops`, `std::convert`, `std::cmp`, `std::clone`, `std::fmt`, `std::default`, `std::hash`	实现语言语义所需的 trait（加减乘除、比较、拷贝、格式化、哈希等）
基础类型层	`std::option`, `std::result`, `std::string`, `std::vec`, `std::boxed`, `std::collections`	基本容器和控制结构
系统接口层	`std::fs`, `std::io`, `std::env`, `std::process`, `std::path`, `std::time`, `std::net`	系统 I/O、文件系统、环境变量、网络、进程、时间等
并发层	`std::thread`, `std::sync`, `std::sync::mpsc`, `std::sync::atomic`	多线程、通道通信、同步原语
错误与调试层	`std::error`, `std::panic`, `std::backtrace`, `std::dbg!`	错误处理、panic 栈回溯、调试工具
预导入层（prelude）	`std::prelude::v1`	默认导入到每个作用域的常用类型，如 `Option`, `Result`, `Vec`, `Box`, `String`, `Clone`, `Drop` 等
运行时支持层	`std::process`, `std::alloc`, `std::thread::panicking`	运行时内存分配、程序退出、panic 处理

🧩 二、核心模块详解

1. `std::prelude`

Rust 每个文件默认导入：

use std::prelude::v1::*;

包含：

基本类型别名：Box, Vec, String
常用 traits：Clone, Copy, Drop, PartialEq, PartialOrd, Iterator, From, Into, Default
基本枚举：Option, Result

2. `std::io` —— 输入输出系统

主要结构：

Traits
- Read、Write：流式读写
- BufRead：带缓冲的读取
- Seek：文件定位
常用类型
- stdin(), stdout(), stderr()
- Cursor：让字节缓冲区当作文件使用

示例

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

fn main() {
    print!("请输入名字：");
    io::stdout().flush().unwrap();
    let mut name = String::new();
    io::stdin().read_line(&mut name).unwrap();
    println!("你好，{}!", name.trim());
}

3. `std::fs` —— 文件系统

File：文件读写
read_to_string()：快速读取文件
write()：写文件
metadata()：文件信息
create_dir_all()：创建多层目录

示例

use std::fs;

fn main() {
    fs::write("hello.txt", "Hello, world!").unwrap();
    let s = fs::read_to_string("hello.txt").unwrap();
    println!("{}", s);
}

4. `std::env`

环境变量：env::var("PATH")
命令行参数：env::args()
当前路径：env::current_dir()

示例

use std::env;
fn main() {
    for arg in env::args() {
        println!("参数: {arg}");
    }
}

5. `std::thread` + `std::sync` —— 并发

thread::spawn：创建线程
join：等待线程结束
Mutex / RwLock：锁机制
Arc<T>：原子引用计数
mpsc：多生产者单消费者通道

示例

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

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 h in handles {
        h.join().unwrap();
    }

    println!("结果: {}", *counter.lock().unwrap());
}

6. `std::collections` —— 集合容器

主要类型：

VecDeque（双端队列）
LinkedList
HashMap, HashSet
BTreeMap, BTreeSet（有序）

常用方法：

insert, get, remove, entry

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 90);
    scores.insert("Bob", 85);
    println!("{:?}", scores.get("Alice"));
}

7. `std::option` & `std::result`

Option<T>: 可能有值，也可能没有
Result<T, E>: 成功/失败的封装

关键方法：

.unwrap(), .unwrap_or(), .map(), .and_then()
.ok(), .err(), .expect()

fn div(a: f64, b: f64) -> Result<f64, &'static str> {
    if b == 0.0 { Err("除数不能为0") }
    else { Ok(a / b) }
}

8. `std::path` & `std::process` & `std::time`

Path, PathBuf：路径处理
Command：运行外部命令

Instant, Duration, SystemTime：时间测量

use std::process::Command;
fn main() {
    let out = Command::new("echo").arg("Hello").output().unwrap();
    println!("{}", String::from_utf8_lossy(&out.stdout));
}

9. `std::sync::atomic`

原子操作（无锁）

AtomicBool, AtomicI32, AtomicUsize 等
操作：load(), store(), fetch_add(), compare_exchange()

use std::sync::atomic::{AtomicUsize, Ordering};
static COUNTER: AtomicUsize = AtomicUsize::new(0);
fn main() {
    COUNTER.fetch_add(1, Ordering::SeqCst);
}

10. `std::net`

TcpStream, TcpListener
UdpSocket

ToSocketAddrs

use std::net::TcpListener;
fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080")?;
    for stream in listener.incoming() {
        println!("连接: {:?}", stream?);
    }
    Ok(())
}

11. `std::error`, `std::panic`, `std::backtrace`

Error trait：所有错误类型实现
panic!()：触发不可恢复错误
catch_unwind()：捕获 panic
backtrace::Backtrace：调试栈信息

12. `std::mem` & `std::ptr` —— 底层内存操作

mem::swap, mem::take, mem::replace
ptr::null, ptr::copy, ptr::write
这些是「unsafe」核心模块，支撑 Vec, Box 等容器的实现。

🧮 三、一些常用顶层类型

类型	用途
`String` / `&str`	UTF-8 字符串
`Vec<T>`	动态数组
`Box<T>`	堆分配的对象
`Rc<T>` / `Arc<T>`	引用计数（单线程/多线程）
`Mutex<T>` / `RwLock<T>`	同步锁
`HashMap<K, V>` / `BTreeMap<K, V>`	字典映射
`Option<T>` / `Result<T, E>`	控制流程
`thread::JoinHandle<T>`	线程句柄
`Duration` / `Instant`	时间度量

🧭 四、`std` 与 `core` / `alloc` 的关系

Rust 标准库其实分三层：

core：最基础层（无堆内存、无操作系统），适用于 no_std 环境。
alloc：提供堆分配支持，如 Box, Vec, String。
std：在前两者之上 + 操作系统 API + I/O + 并发。

结构如下：

core ──→ alloc ──→ std

📚 五、如何学习和查找

👉 命令行文档查看：

rustup doc --std

👉 在线官方文档（推荐）： 🔗 https://doc.rust-lang.org/std/

如果你愿意，我可以帮你生成一份 「std 模块思维导图（层级树）」 或者 「最常用 50 个 std 函数速查表」，方便查阅。你想要哪种？

9.0 KiB Raw Permalink Blame History Unescape Escape

🧱 一、std 总体结构

🧩 二、核心模块详解

1. std::prelude

2. std::io —— 输入输出系统

3. std::fs —— 文件系统

4. std::env

5. std::thread + std::sync —— 并发

6. std::collections —— 集合容器

7. std::option & std::result

8. std::path & std::process & std::time

9. std::sync::atomic

10. std::net

11. std::error, std::panic, std::backtrace

12. std::mem & std::ptr —— 底层内存操作