《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);
  

9. 标准库参考链接

• Rust 标准库官方文档

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