rust/std

当然可以 👍 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 标准库其实分三层：

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

结构如下：

core ──→ alloc ──→ std

---

📚 五、如何学习和查找

👉 命令行文档查看：

rustup doc --std

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

---

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