15天100题入门Rust——Day4

欢迎大家回到远远时间。

上回说到Rust的智能指针如何在保证内存安全的同时，提升了数据处理的效率和灵活性。我们探讨了Box<T>、Rc<T>和Arc<T>等指针类型，以及RefCell<T>和Mutex<T>等类型如何在运行时借用检查中发挥作用，实现内部可变性。

今天，我们将深入Rust的类型系统。Rust的类型系统不仅强大而且精细，它通过静态类型检查提供了安全保障，同时也是Rust零成本抽象的基石。学习如何利用类型系统来编写出既高效又安全的代码。

Day 4 问题

不可变性与变量绑定

尝试修改不可变变量

在 Rust 中，一旦一个变量被声明为不可变，它的值就不能被改变。请尝试创建一个不可变的整数变量 x，然后尝试在不使用 mut 关键字的情况下修改它的值，观察并记录下 Rust 编译器的反应。

修改结构体中的不可变字段

定义一个名为 Config 的结构体，它包含一个不可变字段 timeout。接着尝试创建一个 Config 实例，并在不破坏字段不可变性的前提下修改 timeout 字段的值。记录下尝试的过程和结果。

结构体与方法

定义并实例化结构体

请定义一个 Person 结构体，它应该包含姓名、年龄和城市等字段。然后编写一个关联函数 new，用于根据给定的参数创建 Person 结构体的实例。

实现结构体的方法

为 Person 结构体实现一个方法 introduce，该方法的作用是打印出一个介绍个人信息的语句。这个方法应该能够清晰地表达出这个人的姓名、年龄和他们所在的城市。

枚举与模式匹配

定义枚举并使用模式匹配

定义一个名为 TrafficLight 的枚举，它应该包含红灯、黄灯和绿灯这三种变体。然后为 TrafficLight 枚举实现一个方法 time，该方法返回每种灯持续的时间（以秒为单位）。最后，使用 match 表达式来处理 TrafficLight 实例，根据不同的灯显示相应的行动指示。

Option 和 Result 枚举

处理向量中的元素获取

创建一个名为 fetch_element 的函数，它尝试从一个整数向量中获取第10个元素。如果该元素存在，则返回 Some(元素)，否则返回 None。之后，使用 match 表达式来处理 fetch_element 函数的返回值。

实现安全的除法操作

编写一个名为 safe_divide 的函数，它尝试将两个数字相除。如果除数是0，则函数应该返回 Result 类型的错误。使用 match 表达式来处理 safe_divide 函数的返回值，并确保能够优雅地处理除法操作可能出现的错误。

泛型和特征约束

实现泛型函数以找到最大元素

创建一个泛型函数 largest，它接受一个任意类型的切片，并返回切片中最大的元素。要求这个函数只能用于元素类型实现了 PartialOrd 和 Copy 特征的情况。

打印泛型参数的信息

创建一个泛型函数 print_info，它接受一个实现了 Debug 特征的参数，并打印出该参数的调试信息。这个函数应该能够处理任何实现了 Debug 特征的类型。

特征和特征作为参数

定义特征和实现特征的结构体

定义一个名为 Drawable 的特征，它包含一个名为 draw 的方法。然后定义两个结构体 Circle 和 Square，并为它们实现 Drawable 特征。

使用特征作为函数参数

创建一个名为 display 的函数，它接受一个实现了 Drawable 特征的参数。在这个函数内部，调用传入参数的 draw 方法。

实现特征并为结构体提供格式化输出

定义一个名为 Printable 的特征，它包含一个返回字符串的方法 format。为 Book 结构体实现这个特征，使其能够返回格式化的书籍信息字符串。

Day 4 答案

Rust语言提供了内存安全、并发性能和系统级开发的能力，而不牺牲性能。本文将深入探讨 Rust 的几个核心概念，包括不可变性与变量绑定、结构体与方法、枚举与模式匹配、Option 和 Result 枚举，以及泛型和特征约束。我们将更好地理解 Rust 如何通过类型系统和所有权模型来防止数据竞争和空指针异常。

我们将从不可变性的基础开始，探索 Rust 如何通过限制变量的可变性来减少错误。接着，我们将研究 Rust 中结构体的使用，以及如何创建关联的方法。枚举和模式匹配的强大组合将展示 Rust 在处理多种可能性时的优雅和表现力。此外，我们将探讨 Option 和 Result 枚举，这两个枚举在 Rust 中用于优雅地处理可能的缺失值和错误。最后，我们将了解泛型和特征约束，这些特性使 Rust 能够编写灵活且可重用的代码，同时保持类型安全。

不可变性与变量绑定

尝试修改不可变变量

在 Rust 中，一旦一个变量被声明为不可变，它的值就不能被改变。请尝试创建一个不可变的整数变量 x，然后尝试在不使用 mut 关键字的情况下修改它的值，观察并记录下 Rust 编译器的反应。

尝试修改不可变变量

fn main() {
    let x = 5; // 声明一个不可变的整数变量x
    println!("The value of x is: {}", x); // 打印变量x的值

    // 尝试修改变量x的值
    // x = 6; // 这行代码会导致编译错误，因为x是不可变的

    println!("The value of x is: {}", x); // 再次打印变量x的值
}

如果取消注释第五行代码x = 6;，Rust编译器会给出错误信息：

error[E0384]: cannot assign twice to immutable variable `x`
 --> src\main.rs:6:5
  |
2 |     let x = 5; // 声明一个不可变的整数变量x
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
...
6 |     x = 6; // 这行代码会导致编译错误，因为x是不可变的
  |     ^^^^^ cannot assign twice to immutable variable

这个错误信息表明我们不能对不可变变量x进行第二次赋值。

在Rust中，变量默认是不可变的，这意味着一旦一个变量被声明，它的值就不能被改变，除非使用mut关键字明确指定为可变。

不可变性可以防止数据竞争，因为值在创建后不能被修改，所以多个线程可以安全地访问不可变变量，而不需要额外的同步。当你尝试修改一个不可变变量时，Rust编译器会阻止你，并给出错误信息。

修改结构体中的不可变字段

定义一个名为 Config 的结构体，它包含一个不可变字段 timeout。接着尝试创建一个 Config 实例，并在不破坏字段不可变性的前提下修改 timeout 字段的值。

struct Config {
    timeout: u32, // 定义一个名为 `Config` 的结构体，其中包含一个不可变字段 `timeout`
}

fn main() {
    let mut config = Config { timeout: 30 }; // 创建一个 `Config` 实例，初始化 `timeout` 为 30
    println!("Initial timeout: {}", config.timeout); // 打印初始的 `timeout` 值

    // 尝试修改 `timeout` 字段的值
    // 因为 `timeout` 字段是不可变的，所以我们不能直接赋予它新的值
    // 但我们可以通过创建一个新的 `Config` 实例来“修改” `timeout` 字段的值
    config = Config { timeout: 60 };
    println!("Updated timeout: {}", config.timeout); // 打印更新后的 `timeout` 值
}

Rust中结构体的字段默认是不可变的，除非这个结构体的实例被声明为可变的。在上面的代码中，我们首先定义了一个名为Config的结构体，它有一个类型为u32的字段timeout。然后，在main函数中，我们创建了一个可变的Config实例，并将timeout初始化为30。

由于Rust中不允许直接修改不可变字段的值，我们创建了一个新的Config实例，并用新的timeout值来替换旧的实例。这样没有直接修改字段的值，而是替换了整个结构体实例。在不违反Rust的所有权和借用规则的情况下，更新了结构体中不可变字段。如果结构体很大或者包含了不可复制的类型，需要重新考虑我们的设计，或使用内部可变性模式，例如通过Cell或RefCell来允许在不可变引用下修改数据。

结构体与方法

定义并实例化结构体

请定义一个 Person 结构体，它应该包含姓名、年龄和城市等字段。然后编写一个关联函数 new，用于根据给定的参数创建 Person 结构体的实例。

// 定义Person结构体
struct Person {
    name: String,
    age: u8,
    city: String,
}

impl Person {
    // 关联函数new，用于创建Person实例
    fn new(name: &str, age: u8, city: &str) -> Person {
        Person {
            name: name.to_string(),
            age,
            city: city.to_string(),
        }
    }
}

fn main() {
    // 使用new函数创建一个Person实例
    let person = Person::new("Alice", 30, "Shanghai");
    println!("Name: {}, Age: {}, City: {}", person.name, person.age, person.city);
}

代码定义了Person结构体，包含姓名、年龄和城市字段。通过new关联函数创建结构体实例，提高了灵活性和可维护性。

实现结构体的方法

为 Person 结构体实现一个方法 introduce，该方法的作用是打印出一个介绍个人信息的语句。这个方法应该能够清晰地表达出这个人的姓名、年龄和他们所在的城市。

struct Person {
    name: String,
    age: u8,
    city: String,
}

impl Person {
    // 实现introduce方法，用于介绍个人信息
    fn introduce(&self) {
        println!("Hello, my name is {}. I'm {} years old and I live in {}.", self.name, self.age, self.city);
    }
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 30,
        city: String::from("Shanghai"),
    };

    person.introduce(); // 调用introduce方法
}

定义一个 Person 结构体，包含姓名、年龄和城市三个字段。通过为该结构体实现 introduce 方法，每个 Person 实例都能够输出格式化的个人介绍信息。

枚举与模式匹配

定义枚举并使用模式匹配

定义一个名为 TrafficLight 的枚举，它应该包含红灯、黄灯和绿灯这三种变体。然后为 TrafficLight 枚举实现一个方法 time，该方法返回每种灯持续的时间（以秒为单位）。最后，使用 match 表达式来处理 TrafficLight 实例，根据不同的灯显示相应的行动指示。

// 定义交通信号灯枚举
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

// 为TrafficLight枚举实现time方法
impl TrafficLight {
    fn time(&self) -> u8 {
        match self {
            TrafficLight::Red => 60,    // 红灯持续60秒
            TrafficLight::Yellow => 5,  // 黄灯持续5秒
            TrafficLight::Green => 30,  // 绿灯持续30秒
        }
    }
}

fn main() {
    // 创建一个绿灯实例
    let light = TrafficLight::Green;
    
    // 使用模式匹配来处理不同的交通信号灯
    match light {
        TrafficLight::Red => println!("STOP for {} seconds.", light.time()),
        TrafficLight::Yellow => println!("CAUTION for {} seconds.", light.time()),
        TrafficLight::Green => println!("GO for {} seconds.", light.time()),
    }
}

在上述代码中，我们定义了一个名为 TrafficLight 的枚举，包含三个变体：Red、Yellow 和 Green，分别表示红灯、黄灯和绿灯。通过实现 TrafficLight 枚举的 time 方法，使用 match 表达式根据枚举的变体返回不同的持续时间。在 main 函数中，创建了一个 TrafficLight::Green 的实例，并使用 match 表达式输出相应的行动指示和持续时间。这种方式清晰表达了不同交通信号灯状态下的行动，展示了 Rust 语言中枚举和模式匹配的强大功能，提高了代码的可读性和可维护性。

Option 和 Result 枚举

处理向量中的元素获取

创建一个名为 fetch_element 的函数，它尝试从一个整数向量中获取第10个元素。如果该元素存在，则返回 Some(元素)，否则返回 None。之后，使用 match 表达式来处理 fetch_element 函数的返回值。

fn fetch_element(vec: &[i32]) -> Option<i32> {
    // 尝试获取向量中的第10个元素
    vec.get(9).cloned()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];

    // 使用match表达式处理fetch_element函数的返回值
    match fetch_element(&numbers) {
        Some(value) => println!("The 10th element is {}", value),
        None => println!("There is no 10th element."),
    }
}

在Rust中，安全获取向量元素通常使用标准库的get方法，返回Option类型，防止访问越界导致程序崩溃。以一个处理整数向量的例子，通过fetch_element函数尝试获取向量中的第10个元素，使用get方法避免越界，通过匹配Some(value)和None来处理返回值，展示了Rust错误处理利用类型系统在编译时避免运行时错误。

实现安全的除法操作

编写一个名为 safe_divide 的函数，它尝试将两个数字相除。如果除数是0，则函数应该返回 Result 类型的错误。使用 match 表达式来处理 safe_divide 函数的返回值，并确保能够优雅地处理除法操作可能出现的错误。

fn safe_divide(dividend: f64, divisor: f64) -> Result<f64, &'static str> {
    if divisor == 0.0 {
        Err("Cannot divide by zero") // 如果除数为0，返回错误
    } else {
        Ok(dividend / divisor) // 正常除法运算
    }
}

fn main() {
    let dividend = 10.0;
    let divisor = 0.0;

    // 使用match表达式处理结果
    match safe_divide(dividend, divisor) {
        Ok(result) => println!("The result is {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

safe_divide 函数接收两个浮点数参数并返回一个 Result 类型，代表操作可能成功（Ok）或失败（Err）的结果。该函数执行正常的除法操作，如果除数不为零，将结果用 Ok 包裹返回；如果除数为零，使用 Err 返回错误信息，表示不能除以零。在 main 函数中，调用 safe_divide 并使用 match 表达式处理返回的 Result。如果是 Ok，则打印出除法结果；如果是 Err，则打印出错误信息。

这种处理方式使得我们能够优雅地处理除法可能出现的错误，而不会导致程序崩溃或不可预期的行为。这也展示了 Rust 强大的错误处理能力，通过返回 Result 类型，使得错误可以在编译时被捕获，而不是在运行时突然崩溃。

泛型和特征约束

实现泛型函数以找到最大元素

创建一个泛型函数 largest，它接受一个任意类型的切片，并返回切片中最大的元素。要求这个函数只能用于元素类型实现了 PartialOrd 和 Copy 特征的情况。

// 必须满足 `PartialOrd` 和 `Copy` 这两个特征
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("The largest number is {}", result);

    let chars = vec!['y', 'm', 'a', 'q'];
    let result = largest(&chars);
    println!("The largest char is {}", result);
}

这段代码定义了一个名为 largest 的泛型函数，它接受一个类型为 T 的切片作为参数，并返回这个切片中最大的元素。这里的 T 是一个泛型类型参数，它必须满足 PartialOrd 和 Copy 这两个特征的约束，这意味着 T 类型的元素可以进行比较操作，并且可以被复制。

由于它是泛型的，所以可以用于任何实现了 PartialOrd 和 Copy 特征的类型，这包括了所有的标准数值类型和字符类型。PartialOrd 特征允许元素之间进行比较，而 Copy 特征则意味着元素类型是可以被复制的，这是因为在比较过程中我们需要复制元素。如果类型没有实现 Copy 特征，那么在比较时可能会发生所有权的转移，这会导致函数无法正常工作。

打印泛型参数的信息

创建一个泛型函数 print_info，它接受一个实现了 Debug 特征的参数，并打印出该参数的调试信息。这个函数应该能够处理任何实现了 Debug 特征的类型。

// 定义一个泛型函数print_info
fn print_info<T: std::fmt::Debug>(item: T) {
    // 打印传入参数的调试信息
    println!("{:?}", item);
}

fn main() {
    // 调用函数并传入不同类型的参数
    print_info(42); // 整数
    print_info(3.14); // 浮点数
    print_info("Hello, world!"); // 字符串切片
}

上述代码中的print_info函数就是一个泛型函数的例子。它使用了泛型类型T，这意味着这个函数可以接受任何类型的参数。这里我们通过T: std::fmt::Debug约束了类型T，它必须实现了标准库中的Debug特征。Debug特征允许我们打印类型的调试信息，通常用于开发过程中查看变量的值。

特征和特征作为参数

定义特征和实现特征的结构体

定义一个名为 Drawable 的特征，它包含一个名为 draw 的方法。然后定义两个结构体 Circle 和 Square，并为它们实现 Drawable 特征。

// 定义Drawable特征，包含draw方法
trait Drawable {
    fn draw(&self);
}

// 定义Circle结构体
struct Circle {
    radius: f64,
}

// 为Circle结构体实现Drawable特征
impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle with radius: {}", self.radius);
    }
}

// 定义Square结构体
struct Square {
    side: f64,
}

// 为Square结构体实现Drawable特征
impl Drawable for Square {
    fn draw(&self) {
        println!("Drawing a square with side: {}", self.side);
    }
}

fn main() {
    let circle = Circle { radius: 5.0 };
    let square = Square { side: 3.0 };

    // 调用各自的draw方法
    circle.draw();
    square.draw();
}

在Rust中，特征（Traits）类似于其他语言中的接口，它定义了一组方法，这些方法可以被不同的类型实现。代码中定义了一个名为Drawable的特征，它要求实现它的类型拥有一个名为draw的方法。

接着定义了两个结构体Circle和Square，分别表示圆和正方形。对于这两个结构体分别实现了Drawable特征，提供了draw方法的具体实现。在Circle的draw方法中，我们打印出圆的半径，在Square的draw方法中，我们打印出正方形的边长。

使用特征作为函数参数

创建一个名为 display 的函数，它接受一个实现了 Drawable 特征的参数。在这个函数内部，调用传入参数的 draw 方法。

// 定义Drawable特征，包含draw方法
trait Drawable {
    fn draw(&self);
}

// display函数，接受实现了Drawable特征的类型作为参数
fn display(item: &impl Drawable) {
    item.draw(); // 调用draw方法
}

// 实现Drawable特征的结构体
struct Circle {
    radius: f64,
}

// 为Circle结构体实现Drawable特征
impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle with radius: {}", self.radius);
    }
}

fn main() {
    let circle = Circle { radius: 5.0 };
    display(&circle); // 调用display函数并传入Circle实例
}

特征（Traits）类似于其他语言中的接口，它定义了一组方法签名，用于指定实现该特征的类型必须提供的行为。代码中我们定义了一个名为 Drawable 的特征，它包含一个名为 draw 的方法。

display 函数接受一个实现了 Drawable 特征的参数。这里使用 impl Trait 语法，它是一种泛型的简写方式，允许我们接受任何实现了指定特征的类型。在 display 函数内部，我们调用了参数的 draw 方法，这是多态的一种体现，即不同类型的 draw 方法可以有不同的实现。

实现特征并为结构体提供格式化输出

定义一个名为 Printable 的特征，它包含一个返回字符串的方法 format。为 Book 结构体实现这个特征，使其能够返回格式化的书籍信息字符串。

// 定义Printable特征，包含format方法
trait Printable {
    fn format(&self) -> String;
}

// 定义Book结构体
struct Book {
    title: String,
    author: String,
    year: u32,
}

// 为Book结构体实现Printable特征
impl Printable for Book {
    // format方法返回书籍的格式化信息
    fn format(&self) -> String {
        format!("Title: {}, Author: {}, Year: {}", self.title, self.author, self.year)
    }
}

fn main() {
    // 创建一个Book实例
    let book = Book {
        title: "The Rust Programming Language".to_string(),
        author: "Steve Klabnik and Carol Nichols".to_string(),
        year: 2018,
    };

    // 打印格式化后的书籍信息
    println!("{}", book.format());
}

首先定义了一个名为 Printable 的特征，它包含一个名为 format 的方法，该方法返回一个 String 类型。这个特征定义了一个可打印对象应该具备的行为，即能够提供其格式化后的字符串表示。

接着定义了一个 Book 结构体，包含书籍的标题（title）、作者（author）和出版年份（year）三个字段。这些字段被用来存储书籍的相关信息。

然后为 Book 结构体实现了 Printable 特征。在 impl 块中，我们定义了 format 方法的具体实现，它使用 format! 宏来生成一个包含书籍信息的格式化字符串。这个字符串包括书名、作者和出版年份，每个字段之间用逗号和空格分隔。

通过特征和结构体的组合，可以为不同的数据类型提供统一的格式化输出能力，而不必为每种类型单独编写格式化代码。提高了代码的复用性和模块化。

如果未来需要修改输出格式，只需修改 format 方法的实现即可，而不必修改使用该方法的每个地方，提高了代码的可维护性。

Day 4 小结

在今天的文章中，我们一起学习了Rust不可变性与变量绑定的基础知识，到结构体与方法的实际应用，再到枚举与模式匹配的灵活运用。我们还涉猎了Option和Result枚举在错误处理中的重要性，以及泛型和特征约束在代码复用和类型安全中的作用。我们了解了如何通过特征定义共通行为，并将特征作为参数来提高代码的抽象层次和灵活性。

我们深入体会到Rust语言设计的精妙之处，它可以帮助我们写出既安全又高效的代码。希望今天的内容能够帮助大家更好地理解Rust的智能指针及其背后的类型系统，让我们在Rust的学习之路上更进一步。

我们Day 5见！