《Rust编程入门》附录B：Rust标准库概览

附录B：Rust 标准库概览

Rust 的标准库（std）是构建高效、安全 、功能丰富的程序的重要基石。它提供了丰富的模块、数据结构 、工具和功能，支持开发者处理日常编程任务，包括文件操作、并发、网络通信和内存管理等。

1. 核心模块

1.1 std::prelude

• 自动导入到每个 Rust 程序中的模块，提供常用功能：
  • 宏：println!、format! 等。
  • 基础特性：Clone、Copy、Debug 等。
  • 基础数据结构：Option、Result。

1.2 std::primitive

• 提供核心语言的原语类型，例如：
  • 标量类型：i32、f64、char 等。
  • 复合类型：tuple、array。

2. 数据结构

2.1 容器

• Vec（向量）：
  动态大小的数组。

  let mut vec = Vec::new();
  vec.push(1);
  vec.push(2);
  

• HashMap（哈希表）：
  键值对存储。

  use std::collections::HashMap;
  let mut map = HashMap::new();
  map.insert("key", "value");
  

• HashSet（哈希集合）：
  存储唯一值的集合。

  use std::collections::HashSet;
  let mut set = HashSet::new();
  set.insert(1);
  

2.2 字符串

• String：
  可变的 UTF-8 字符串。

  let mut s = String::from("Hello");
  s.push_str(", World!");
  

• str：
  不可变的字符串切片。

  let s = "Hello, World!";
  

3. I/O 操作

3.1 文件操作

• 读取文件：

  use std::fs;
  
  let content = fs::read_to_string("file.txt").unwrap();
  println!("{}", content);
  

• 写入文件：

  use std::fs::File;
  use std::io::Write;
  
  let mut file = File::create("output.txt").unwrap();
  file.write_all(b"Hello, Rust!").unwrap();
  

3.2 标准输入输出

• 读取用户输入：

  use std::io;
  
  let mut input = String::new();
  io::stdin().read_line(&mut input).unwrap();
  println!("You typed: {}", input.trim());
  

• 标准输出：

  println!("Hello, World!");
  

4. 并发与多线程

4.1 线程

• 创建线程：

  use std::thread;
  
  thread::spawn(|| {
      println!("Hello from another thread!");
  }).join().unwrap();
  

4.2 同步工具

• Mutex：
  提供线程安全的可变共享资源。

  use std::sync::Mutex;
  
  let m = Mutex::new(5);
  {
      let mut num = m.lock().unwrap();
      *num += 1;
  }
  println!("{:?}", m);
  

• RwLock：
  读写锁，允许多个读者或一个写者。

  use std::sync::RwLock;
  
  let lock = RwLock::new(5);
  {
      let r = lock.read().unwrap();
      println!("Read value: {}", *r);
  }
  

4.3 通道

• 消息传递：

  use std::sync::mpsc;
  
  let (tx, rx) = mpsc::channel();
  tx.send("Hello").unwrap();
  println!("Received: {}", rx.recv().unwrap());
  

5. 网络编程

5.1 TCP

• TCP 客户端：

  use std::net::TcpStream;
  
  let mut stream = TcpStream::connect("127.0.0.1:8080").unwrap();
  stream.write(b"Hello, server!").unwrap();
  

• TCP 服务器：

  use std::net::TcpListener;
  
  let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
  for stream in listener.incoming() {
      println!("New connection: {:?}", stream);
  }
  

5.2 UDP

• UDP 套接字：

  use std::net::UdpSocket;
  
  let socket = UdpSocket::bind("127.0.0.1:8080").unwrap();
  socket.send_to(b"Hello", "127.0.0.1:9090").unwrap();
  

6. 错误处理

6.1 Result 枚举

• 用法：

  fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
      if b == 0 {
          Err("Division by zero")
      } else {
          Ok(a / b)
      }
  }
  

6.2 Option 枚举

• 用法：

  let some_value: Option<i32> = Some(42);
  if let Some(val) = some_value {
      println!("Value: {}", val);
  }
  

7. 时间与日期

7.1 std::time

• 获取当前时间：

  use std::time::SystemTime;
  
  let now = SystemTime::now();
  println!("{:?}", now);
  

• 测量时间间隔：

  use std::time::Instant;
  
  let start = Instant::now();
  // Some time-consuming task
  let duration = start.elapsed();
  println!("Elapsed time: {:?}", duration);
  

8. 工具与宏

8.1 调试工具

• dbg! 宏：

  let x = 42;
  dbg!(x); // 输出到标准错误
  

8.2 断言

• assert! 和 assert_eq!：

  assert!(1 + 1 == 2);
  assert_eq!(2 * 2, 4);
  

10. 智能指针与内存管理

Rust 标准库提供多种智能指针，在零成本抽象的前提下管理堆内存：

use std::sync::Arc;
use std::thread;

let data = Arc::new(vec![1, 2, 3]);
let mut handles = vec![];

for i in 0..3 {
    let d = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        println!("线程 {}: {:?}", i, d);
    }));
}
for h in handles { h.join().unwrap(); }

11. 核心 Trait 速查

掌握标准库 Trait 是写出地道 Rust 代码的关键：

12. 常用宏合集

// 输出与调试
println!("格式化: {}", value);    // 标准输出
dbg!(&variable);                    // 调试输出（包含文件名和行号）

// 集合构造
let v = vec![1, 2, 3];              // 向量
let m = HashMap::from([("k", 1)]); // 哈希表（Rust 1.56+）

// 内存分配
let b = Box::new(5);                // 堆分配

// panic 与终止
panic!("致命错误: {}", reason);     // 不可恢复错误
unreachable!();                     // 标记不可达代码（编译器优化提示）
unimplemented!();                   // 占位符，编译通过但运行 panic

// 条件编译
cfg!(target_os = "linux");          // 编译期条件判断

9. 标准库参考链接

• Rust 标准库官方文档
• Rust Reference — The Standard Library

通过本附录，开发者可以快速查阅 Rust 标准库的重要模块和功能，助力高效开发！