第 5 章：错误处理

在系统编程中，错误处理是不可避免的一个环节。Rust 提供了多种错误处理机制来确保程序的可靠性和安全性。本章将详细介绍 Rust 中的错误处理方法，帮助你在开发过程中更好地处理各种可能的错误情况。

panic! 和 unwrap

panic! 宏

在 Rust 中，panic! 宏用于程序出现不可恢复的错误时立即停止执行，并显示错误信息。

fn main() {
    // 故意引发 panic!
    panic!("Something went wrong!");
}

当 panic! 被调用时，程序会打印出错误信息并退出。这种方式适用于那些致命的错误，程序无法继续运行的情况。

unwrap 方法

unwrap 方法用于 Option 和 Result 类型。如果 Option 是 Some 或 Result 是 Ok，那么 unwrap 会返回其中的值；否则会调用 panic!。

fn main() {
    let some_option: Option<i32> = Some(42);
    let none_option: Option<i32> = None;

    // 正常情况下，返回 42
    println!("Value: {}", some_option.unwrap());

    // 这行代码会引发 panic!
    println!("Value: {}", none_option.unwrap());
}

使用 unwrap 时需要非常谨慎，因为如果 Option 是 None 或 Result 是 Err，程序将立即崩溃。为了避免这种情况，可以使用 expect 方法来提供更多的错误信息。

fn main() {
    let some_option: Option<i32> = None;

    // 提供详细的错误信息
    println!("Value: {}", some_option.expect("Expected a value, but got None!"));
}

Option 和 Result

Option 枚举

Option 枚举用于处理可能不存在的值。它有两个变体：Some 和 None。

fn main() {
    let some_number: Option<i32> = Some(5);
    let no_number: Option<i32> = None;

    match some_number {
        Some(num) => println!("We have a number: {}", num),
        None => println!("We have no number"),
    }

    match no_number {
        Some(num) => println!("We have a number: {}", num),
        None => println!("We have no number"),
    }
}

Result 枚举

Result 枚举用于处理可能失败的操作。它有两个变体：Ok 和 Err。

fn divide(dividend: i32, divisor: i32) -> Result<i32, String> {
    if divisor == 0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(dividend / divisor)
    }
}

fn main() {
    let result = divide(10, 2);
    match result {
        Ok(value) => println!("Quotient: {}", value),
        Err(e) => println!("Error: {}", e),
    }

    let result = divide(10, 0);
    match result {
        Ok(value) => println!("Quotient: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

错误传播

在 Rust 中，错误传播是一种常见的错误处理方式。通过使用 ? 运算符，可以简化错误传播的代码。

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("hello.txt")?;
    let mut username = String::new();
    file.read_to_string(&mut username)?;
    Ok(username)
}

fn main() {
    match read_username_from_file() {
        Ok(username) => println!("Username: {}", username),
        Err(e) => println!("Failed to read the file: {}", e),
    }
}

在这个例子中，? 运算符会在函数出错时自动将错误返回给调用者，而不是使用 unwrap 或 match。

自定义错误类型

在实际项目中，可能需要定义自己的错误类型来处理特定的错误情境。可以通过实现 std::fmt::Debug 和 std::fmt::Display trait 来创建自定义错误类型。

use std::fmt;

#[derive(Debug)]
struct CustomError {
    details: String,
}

impl CustomError {
    fn new(msg: &str) -> CustomError {
        CustomError { details: msg.to_string() }
    }
}

impl fmt::Display for CustomError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.details)
    }
}

impl std::error::Error for CustomError {
    fn description(&self) -> &str {
        &self.details
    }
}

fn main() {
    let my_error = CustomError::new("This is a custom error");
    println!("Error: {}", my_error);
}

通过定义自己的错误类型，可以更清晰地表达错误信息和处理逻辑。

graph TD
A[函数调用] --> B{Result}
B -- Ok --> C[正常返回值]
B -- Err --> D[错误处理]

本章节涵盖了 Rust 中的错误处理机制，包括 panic! 和 unwrap, Option 和 Result, 错误传播和自定义错误类型。通过掌握这些技术，你可以在编程中更有效地处理错误，提高代码的鲁棒性和可靠性。