《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（向量）： 动态大小的数组。

    1
2
3

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

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

    1
2
3

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

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

    1
2
3

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

2.2 字符串

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

    1
2

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

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

    1

    let s = "Hello, World!";

3. I/O 操作

3.1 文件操作

  • 读取文件：

    1
2
3
4

    use std::fs;

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

  • 写入文件：

    1
2
3
4
5

    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 标准输入输出

  • 读取用户输入：

    1
2
3
4
5

    use std::io;

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

  • 标准输出：

    1

    println!("Hello, World!");

4. 并发与多线程

4.1 线程

  • 创建线程： 
    1
2
3
4
5

    use std::thread;

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

4.2 同步工具

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

    1
2
3
4
5
6
7
8

    use std::sync::Mutex;

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

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

    1
2
3
4
5
6
7

    use std::sync::RwLock;

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

4.3 通道

  • 消息传递： 
    1
2
3
4
5

    use std::sync::mpsc;

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

5. 网络编程

5.1 TCP

  • TCP 客户端：

    1
2
3
4

    use std::net::TcpStream;

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

  • TCP 服务器：

    1
2
3
4
5
6

    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 套接字： 
    1
2
3
4

    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 枚举

  • 用法： 
    1
2
3
4
5
6
7

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

6.2 Option 枚举

  • 用法： 
    1
2
3
4

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

7. 时间与日期

7.1 std::time

  • 获取当前时间：

    1
2
3
4

    use std::time::SystemTime;

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

  • 测量时间间隔：

    1
2
3
4
5
6

    use std::time::Instant;

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

8. 工具与宏

8.1 调试工具

  • dbg! 宏： 
    1
2

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

8.2 断言

  • assert! 和 assert_eq!： 
    1
2

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

9. 标准库参考链接

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