Rust学习笔记

SmlCoke的Rust学习笔记，记录学习过程中遇到的问题和解决方案。

一. 入门¶

1.1 hello world¶

fn main() {

}

这几行定义了一个名叫 main 的函数。main 函数是一个特殊的函数：在可执行的 Rust 程序中，它总是最先运行的代码。第一行代码声明了一个叫做 main 的函数，它没有参数也没有返回值。如果有参数的话，它们的名称应该出现在小括号 () 中。
函数体被包裹在 {} 中。Rust 要求所有函数体都要用花括号包裹起来。一般来说，将左花括号与函数声明置于同一行并以空格分隔，是良好的代码风格。

println!("Hello, world!");

println! 调用了一个 Rust 宏（macro），当看到符号 ! 的时候，就意味着调用的是宏而不是普通函数，并且宏并不总是遵循与函数相同的规则。

1.2 编译与运行¶

编译指令

rustc main.rs

这将会生成文件：main.exe (Windows) 或 main (Linux 和 macOS)，和main.pdb(Windows 调试符号文件)。

1.3 cargo¶

Cargo 是 Rust 的构建系统和包管理器。
它可以处理很多任务，比如构建代码、下载依赖库并编译这些库。（我们把代码所需要的库叫做 依赖（dependencies））。

1.3.1 创建新项目¶

使用 Cargo 创建一个新项目：

cargo new hello_cargo

这样会在当前目录下创建一个名为 hello_cargo 的新目录，并且同时成为一个新的 git 仓库。该仓库包含的初始文件/文件夹如下：

• src/ 目录：包含项目的源代码文件。
  
• Cargo.toml 文件：包含项目的元数据和依赖信息。
  
• .git/ 目录：包含 git 版本控制信息。
  
• .gitignore 文件：指定哪些文件和目录不应被 git 版本控制跟踪。

当然，可以使用:

cargo new hello_cargo --vcs none

创建项目但是不构建为 git 仓库。

1.3.2 关于 Cargo.toml¶

Cargo.toml 文件是一个文本文件，使用 TOML 格式编写。它包含了项目的元数据和依赖信息。以下是一个示例 Cargo.toml 文件的内容：

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

• 第一行，[package]，是一个片段 section 标题，表明下面的语句用来配置一个包。随着我们在这个文件增加更多的信息，还将增加其他 section。
  
• 接下来的三行设置了 Cargo 编译程序所需的配置：项目的名称、项目的版本以及要使用的 Rust 版本。
  最后一行，[dependencies]，是罗列项目依赖的 section 的开始。在 Rust 中，代码包被称为 crates。
  
• 在 Cargo.toml 文件中，标题以及之后的内容属同一个 section，直到遇到下一个标题才开始新的 section。

1.3.3 构建和运行项目¶

构建项目：

cargo build

这样做之后，当前项目目录下会生成一个 target 目录，里面包含了编译后的文件。默认情况下，Cargo 会以调试模式构建项目，生成的可执行文件会放在 target/debug/ 目录下。
运行项目：

./target/debug/hello_cargo

编译好项目后，会产生一个cargo.lock文件，用于锁定项目的依赖版本，以确保在不同的机器或不同的时间构建项目时，使用相同版本的依赖库。由于 Cargo.lock 文件对于可重现构建非常重要，因此它通常会和项目中的其余代码一样提交到版本控制系统中。

强制升级依赖项到最新版本：

cargo update

或者直接修改 Cargo.toml 文件中依赖项的版本号，然后运行 cargo build，Cargo 会自动下载并使用新的版本。
编译并运行项目

cargo run

Rust 在重新编译项目之前，会检查自上次编译以来，项目的源代码或依赖项是否有任何更改。如果没有更改，Cargo 会跳过重新编译的步骤，直接运行上次编译生成的可执行文件。

检查代码

cargo check

快速检查代码确保其可以编译，但并不产生可执行文件
推荐编写代码时定期运行 cargo check 确保它们可以编译。当准备好使用可执行文件时才运行 cargo build

1.3.4 release¶

要以发布模式构建项目，可以使用以下命令：

cargo build --release

这会在 target/release 而不是 target/debug 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。
因此发布模式一般只用于最终发布的版本，而不是在开发过程中频繁使用。

二. 编程概念¶

先贴一张图，这是我在学习 Python 和 C++ 中从来没有见到过的，非常清晰的报错信息

2.1 变量¶

变量默认不可变，例如

let x = 5;

但是可以添加 mut 关键字使变量可变，例如

let mut x = 5;
x = 6;

2.2 常量¶

常量不仅默认不可变，而且一定不可变，并且不是用 let 来声明，而是用 const 来声明，而且还要标准清楚数据类型。例如

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

常量可以在任何作用域中声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。

2.3 遮蔽（shadowing）¶

我们可以定义一个与之前变量同名的新变量：称为第一个变量被第二个 遮蔽（Shadowing） 了，这意味着使用变量的名称时，编译器将看到第二个变量，直到第二个变量自己也被遮蔽或第二个变量的作用域结束
典型例子

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

输出结果为：

The value of x in the inner scope is: 12
The value of x is: 6

2.4 数据类型¶

在 Rust 中，每一个值都有一个特定数据类型（data type）
两种数据类型子集：scalar 和 compound

2.4.1 标量类型（Scalar Types）¶

Rust中的四种基本标量类型：整型、浮点型、布尔类型和字符类型

整型：

范围：\(-2^{n-1} \sim 2^{n-1}-1\)

整型字面值：

可以是多种数字类型的数字字面值允许使用类型后缀，例如 57u8 来指定类型，同时也允许使用 _ 做为分隔符以方便读数，例如1_000，它的值与你指定的 1000 相同。

整型默认是: i32

浮点型
Rust 的浮点数类型是 f32 和 f64
f32和f64几乎一样快，但是f64更精确
采用IEEE-754标准

布尔类型
Rust 中的布尔类型有两个可能的值：true 和 false。
Rust 中的布尔类型使用 bool 表示。

let t = true;
let f: bool = false; // with explicit type annotation

字符类型
用单引号声明 char 字面值，而与之相反的是，使用双引号声明字符串字面值。
Rust 的 char 类型的大小为四个字节 (four bytes)，并代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。
在 Rust 中，带变音符号的字母（Accented letters），中文、日文、韩文等字符，emoji（绘文字）以及零长度的空白字符都是有效的 char 值。

示例

let c = 'z';
let z: char = 'ℤ'; // with explicit type annotation
let heart_eyed_cat = '😻';

2.4.2 复合类型（Compound Types）¶

Rust 有两个原生的复合类型：元组（tuple）和数组（array）。

元组类型
元组是一个将多个不同类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。
示例

let tup: (i32, f64, u8) = (500, 6.4, 1);

用模式匹配（pattern matching）来解构（destructure）元组值：

let tup = (500, 6.4, 1);
let (x, y, z) = tup;
println!("The value of y is: {y}");

可以使用点号（.）后跟值的索引来直接访问所需的元组元素。例如:

let five_hundred = tup.0;
let six_point_four = tup.1;

不带任何值的元组有个特殊的名称，叫做 单元（unit） 元组。这种值以及对应的类型都写作 ()，表示空值或空的返回类型。如果表达式不返回任何其他值，则会隐式返回单元值。

数组类型
数组中的每个元素的类型必须相同
Rust中的数组长度是固定的
数组是可以在栈 (stack) 上分配的已知固定大小的单个内存块

let a = [1, 2, 3, 4, 5(;

数组并不如 vector 类型灵活。vector 类型是标准库提供的一个 允许 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，那么很可能应该使用 vector。

像这样编写数组的类型：在方括号中包含每个元素的类型，后跟分号，再后跟数组元素的数量。

let a: [i32; 5( = [1, 2, 3, 4, 5(;

可以通过在方括号中指定初始值加分号再加元素个数的方式来创建一个每个元素都为相同值的数组

let a = [3;5(; // 等同于 let a = [3, 3, 3, 3, 3(;

数组元素的访问：

let b = a[0(;

2.5 函数¶

Rust中的所有函数采用 snake case 命名约定，所有字母小写，采取下划线分割
用fn定义函数
源码中函数定义在 main 函数 之后，也可以定义在之前，只要函数被调用时出现在调用之处可见的作用域内就行。

fn func1(x: i32, label: char) {
    println!("The value of x from func1 is {x}, label is {label}");
}

2.6 语句（Statements）和表达式（Expressions）¶

Rust中，需要区分语句和表达式
- 语句是执行某些操作但不返回值的指令。例如，let 语句用于创建变量，它没有返回值。
- 表达式是计算并产生一个值的代码片段。例如，5 + 6 是一个表达式，它计算结果为 11。

函数定义也是statement，但是调用函数不是statement
语句不返回值，例如如下无法通过编译

let y = let x = 5; // ❌️
let y = (let x = 5); // ❌️

但是在C和Ruby中是可以的。

Rust 是 Expressions-Base 的语言，大多数代码都是表达式，函数调用是表达式、宏调用是表达式、用{}创建一个新的作用域也是表达式。表达式会返回一个值

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {y}");
}

这里的

{
    let x = 3;
    x + 1
}

就是一个表达式，返回值是4。

2.7 具有返回值的函数¶

• 函数可以向调用它的代码返回值。
• 我们并不对返回值命名，但要在箭头 ->后声明它的类型。
• 在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。
• 使用 return 关键字和指定值，可从函数中提前返回；但大部分函数隐式地返回最后的表达式。这是一个

有返回值的函数的例子：
最 Rust，最推荐的写法：

fn five() -> i32 {
    3*x+2
}

当然，我们也可以用 return 引导的语句提前返回：

fn five() -> i32 {
    return 3*x+2;
}

此外，这种写法也可以：

fn five() -> i32 {
    return 3*x+2
}

因为在rust中，块 {} 中的最后一条“语句”，分号是可选的

2.8 控制流¶

2.8.1 条件判断¶

Rust 中的条件判断使用 if 关键字。

if number < 5 {
    println!("condition was true");
} else {
    println!("condition was false");
}

• 所有的 if 表达式都以 if 关键字开头，其后跟一个条件
  
• 代码中的条件必须是 bool 值，如下实例无法通过编译
  

let number = 3;
if number  {
    println!("condition was true");
} else {
    println!("condition was false");
}

Rust 并不会尝试自动地将非布尔值转换为布尔值，必须总是显式地使用布尔值作为 if 的条件。这一点与C, Python, Ruby等语言不同。

2.8.2 else if 用于多重条件判断¶

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

• Rust 只会执行第一个条件为 true 的代码块，并且一旦它找到一个以后，甚至都不会检查剩下的条件了
• 使用过多的 else if 表达式会使代码显得杂乱无章，所以如果有多于一个 else if 表达式，最好重构代码。用 match 重构代码

2.8.3 使用 if 在 let 语句中赋值¶

let condition = true;
let number = if condition { 5 } else { 6 };

• if 表达式的两个分支必须返回相同类型的值

2.8.4 循环¶

Rust 有三种循环：loop、while 和 for。

loop¶

示例：

loop {
    println!("again!");
}
let result = loop {
    counter += 1;

    if counter == 10 {
        break counter * 2;
    }
};

这里包含了关于loop的两个重点：
- loop会无限循环，除非显式地使用break关键字退出循环
- loop循环可以作为一个表达式使用，并且可以通过break语句返回一个值。返回方法就是返回break后跟的值。

循环标签：
如果存在嵌套循环，break 和 continue 应用于此时最内层的循环。
如果想要中断指定的循环，可以使用循环标签（loop labels）。

let mut count = 0;
'counting_up: loop {
    println!("count = {count}");
    let mut remaining = 10;

    loop {
        println!("remaining = {remaining}");
        if remaining == 9 {
            break;
        }
        if count == 2 {
            break 'counting_up;
        }
        remaining -= 1;
    }

    count += 1;
}
println!("End count = {count}");

while¶

while number != 0 {
    println!("{number}!");
    number -= 1;
}

for¶

用的最多的循环形式

let a = [10, 20, 30, 40, 50(;
for element in a {
    println!("the value is: {element}");
}

三. 分析一个示例¶

猜字游戏：

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

3.1 导入外部库¶

use std::cmp::Ordering;
use std::io;
use rand::Rng;

3.2 io¶

io::stdin()
    .read_line(&mut guess)
    .expect("Failed to read line");

• .read_line(&mut guess)：从标准输入读取一行，并将其存储在 guess 变量中。&mut guess 表示传递的是 guess 的可变引用，这样 read_line 方法可以修改 guess 变量的内容。

• .expect("Failed to read line")：这是错误处理的一种方式。.read_line()函数返回一个Result类型的值（只可能是Ok或Err），Result是枚举类型，其示例拥有.expect()方法。如果read_line成功读取输入，它会返回一个Ok值，expect 会获取 Ok 中的值并原样返回。在本例中，这个值是用户输入到标准输入中的字节数，程序继续执行。如果发生错误，它会返回一个Err值，.expect()方法会使程序崩溃并打印出指定的错误消息。

3.3 crate¶

上面代码使用了 rand crate 来生成随机数。
- crate 是一组 Rust 源代码文件
- 在cargo.toml文件中添加依赖：

[dependencies]
rand = "0.8.5"

• 然后运行 cargo build，Cargo 会自动下载并编译 rand crate 及其依赖项。注意，版本号可能会随着时间变化而不同，而cargo.lock文件会锁定具体的版本号，便于重现构建。

3.4 match 控制流运算符¶

match guess.cmp(&secret_number) {
    Ordering::Less => println!("Too small!"),
    Ordering::Greater => println!("Too big!"),
    Ordering::Equal => {
        println!("You win!");
        break;
    }
}

• 一个 match 表达式由 分支（arms） 构成。一个分支包含一个 模式（pattern）和表达式开头的值与分支模式相匹配时应该执行的代码
  
• match 关键字后跟一个表达式（本例中是 guess.cmp(&secret_number)），该表达式的值会与后续的各个模式pattern进行比较。
  
• 每个模式后面跟着 => 符号，表示如果表达式的值与该模式匹配，则执行该模式后面的代码。
  
• match匹配到第一个满足条件的pattern后，就会执行对应的代码，不会继续检查后续的模式。

四. 所有权¶

4.1 所有权规则¶

1. Rust 中的每一个值都有一个 所有者（owner）。
2. 值在任一时刻有且只有一个所有者。
3. 当所有者离开作用域，这个值将被丢弃。

4.2 内存与分配¶

对比两端代码：

demo1：正确

let mut s = String::from("hello");
s.push_str(", world!");
println!("{s}");

demo2：错误

let s1 = "hello";
s1.push_str(", world!"); 

为什么 String 可变而字面值却不行呢？区别在于两个类型对内存的处理上。

就字符串字面值来说，我们在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中。这使得字符串字面值快速且高效。不过这些特性都只得益于字符串字面值的不可变性。不幸的是，我们不能为了每一个在编译时大小未知的文本而将一块内存放入二进制文件中，并且它的大小还可能随着程序运行而改变。

4.3 作用域、所有权与值¶

4.3.1 drop 函数¶

当一个变量离开作用域时，Rust 会调用一个特殊的函数来清理这个值占用的内存。这个函数叫做 drop，它会自动被调用来释放资源。
调用 drop 函数的唯一过程就是：“所有权离开作用域”

4.3.2 所有权的转让¶

let s1 = String::from("hello");
let s2 = s1;

这里的 s1 是一个 String 类型的变量，它拥有一个字符串值 “hello”。当我们执行 let s2 = s1; 时，s1 的所有权被转移（moved）到 s2。这意味着 s1 不再拥有 “hello” 这个字符串值，s2 现在是这个值的唯一所有者。
因此我们接下来再执行：

println!("{s1}");

会导致编译错误，因为 s1 已经不再拥有那个字符串值了。

但是对于一些类型来说，Rust 会在赋值时进行深复制（deep copy），而不是所有权转移。因为这些类型实现了 Copy trait）（Rust 不允许自身或其任何部分实现了 Drop trait 的类型使用 Copy trait）。

let x = 5;
let y = x;
println!("x = {x}, y = {y}");

在这个例子中，x 是一个 i32 类型的变量，它是一个 Copy 类型。当我们执行 let y = x; 时，x 的值被复制到 y 中，而 x 仍然有效。因此我们可以同时打印 x 和 y 的值。

所有权的转让同样会发生在函数调用中，这一点与 C++/Python/Ruby 等语言很不同。

fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动到函数里 ...
                                    // ... 所以到这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 应该移动函数里，
                                    // 但 i32 是 Copy 的，
    println!("{}", x);              // 所以在后面可继续使用 x

} // 这里，x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
  // 没有特殊之处

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{some_string}");
} // 这里，some_string 移出作用域并调用 `drop` 方法。
  // 占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{some_integer}");
} // 这里，some_integer 移出作用域。没有特殊之处

对于 String 类型，如果我们想要深度复制堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的常用方法。

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {s1}, s2 = {s2}");

4.3.3 作用域与赋值¶

let mut s = String::from("hello");
s = String::from("ahoy");

println!("{s}, world!");

起初我们声明了变量 s 并绑定为一个 "hello" 值的 String。接着立即创建了一个值为 "ahoy" 的 String 并赋值给 s。在这里，完全没有任何内容指向了原始堆上的值。因此原始的字符串立刻就离开了作用域。Rust 会在其上运行 drop 函数同时内存会马上释放。当结尾打印其值时，将会是 “ahoy, world!”。

总之，作用域、所有权与值的转让关系可以一句话总结：将值赋给另一个变量时它会移动。当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。。

只需要记住它们满足的最核心的三个条件：
1. Rust 中的每一个值都有一个 所有者（owner）。
2. 值在任一时刻有且只有一个所有者。
3. 当所有者离开作用域，这个值将被丢弃。

4.4 引用与借用¶

4.4.1 不可变引用¶

引用（reference）像一个指针，因为它是一个地址，我们可以由此访问储存于该地址的属于其他变量的数据。与指针不同，引用在其生命周期内保证指向某个特定类型的有效值。

当我们传入函数参数时，往往只想让参数获取值的引用，而不是获取值的所有权。这一点可以通过引用完成：

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

变量的引用不具有所有权，因此试图通过引用修改值是行不通的，会导致编译错误，例如：

fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

4.4.2 可变引用¶

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

• 可变引用允许我们修改通过引用访问的数据。
• 但是在任何给定的时间，只能有一个可变引用。

4.4.3 多引用的存在性问题¶

两条原则：
(1) 不可变引用可以同时存在多个，因为大家都没有修改值的能力，不用担心自己引用的数据会被其他引用修改。
(2) 可变引用在同一时间只能有一个，因为如果有多个可变引用指向同一数据，那么就无法保证数据的一致性了。

幸运的是，Rust 的编译器在编译时会自动检测引用的生命周期

let mut s = String::from("hello");

let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{r1} and {r2}");
// 此位置之后 r1 和 r2 不再使用

let r3 = &mut s; // 没问题
println!("{r3}");

不可变引用 r1 和 r2 的作用域在 println! 最后一次使用之后结束，这发生在可变引用 r3 被创建之前。因为它们的作用域没有重叠，所以代码是可以编译的。编译器可以在作用域结束之前判断不再使用的引用。

4.4.4 悬垂引用（Dangling Referances）¶

在 Rust 中编译器确保引用永远也不会变成悬垂引用：当你拥有一些数据的引用，编译器确保不允许数据在其引用之前离开作用域。
案例：

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");
    &s
}

我们仔细分析一下这段代码：

(1) 内存布局：String 在内存中是怎么存的？

当你写下 let s = String::from("hello"); 时，内存中其实分成了两部分：
* 栈（Stack）上：存放的是变量 s 本身。它是一个固定大小的结构体，包含三个字段：指针（指向堆内存）、长度（Length）和容量（Capacity）。
* 堆（Heap）上：存放的是真正的字符串内容 "hello"。栈上的指针就指向这块堆内存。

(2) 当函数结束（遇到 }）时，发生了什么？

在 Rust 中，函数体执行完毕意味着该函数的作用域（Scope）结束。此时会发生一系列连锁反应：

1. 变量名失效（Variable Name）
   变量名 s 是编译时的一个标识。一旦离开作用域，你在后续代码中就再也无法通过 s 这个名字来访问任何东西了。
2. 栈空间被回收（Stack Frame）
   函数运行所在的“栈帧”被弹出(任何语言中，函数调用以栈帧为底层本质)。这意味着存放在栈上的那 3 个字段（指针、长度、容量）所占用的内存被标记为“可用”，也就是失效了。
3. 触发 drop 函数（堆内存释放）
   这是最关键的一步。由于 s 是这块堆内存的所有者（Owner），当所有者离开作用域时，Rust 会自动调用一个名为 drop 的特殊函数。
4. drop 会立即释放 s 指向的那块堆空间（即存储 "hello" 的地方）。
5. 堆内存被归还给操作系统，不再属于当前程序。

(3) 为什么返回 &s 会产生悬垂引用？

fn dangle() -> &String {
    let s = String::from("hello"); // 1. s 创建，拥有堆内存
    &s                             // 2. 返回 s 的引用（即 s 的内存地址）
}                                  // 3. s 离开作用域，栈上的 s 消失，堆上的 "hello" 被销毁

• 返回了什么？ 你返回了一个指向变量 s 的地址。
• 引用了什么？ 此时这个引用指向的是一个刚刚被回收的栈位置。
• 后果： 接收这个返回值的外部变量，拿到的是一个指向“虚无”或“垃圾数据”的指针。如果 Rust 允许你这样做，程序在读取这个引用时就会崩溃（段错误）。

4.4.5 变量遮蔽、重新赋值与引用¶

我们观察下面这个例子（✅️）：

let s = String::from("hello world");
let y = &s;
let s = String::from("hello"); // 遮蔽了上一个 s
// 此时访问 y 会发生什么？

(1) 底层发生了什么？

1. 编译器在当前函数的栈帧（Stack Frame）里开辟了一块空间给 s_1。
   
2. y 存储了 s_1 的地址。
   
3. 编译器又在栈帧里开辟了一块新的、独立的空间给 s_2。
   
4. 关键点： 第二个 let 只是告诉编译器：“从现在起，当我写 s 这个词时，请指向 s_2；至于 s_1，我不打算再通过名字访问它了。”

结论： s_1 并没有消失，它依然占据着栈空间，它对堆内存 "hello world" 的所有权依然存在。

(2) 为什么 s_1 不会被立即 Drop？

Rust 的 drop（析构）触发时机只有两个：
1. 主动移动（Move）： 所有权转交给了别人。
2. 作用域结束（End of Scope）： 运行到了代码块的末尾 }。

变量遮蔽（Shadowing）不属于以上任何一种。
虽然你无法通过名字 s 访问 s_1 了，但 s_1 这个实体依然存活在当前的 {} 作用域内。它必须等到函数结束（或代码块结束）时，由编译器自动插入 drop(s_1) 的指令。

(3) 如果没有 y 引用 s_1，它会被提前 Drop 吗？

这是一个进阶细节：非词法作用域生命周期（NLL, Non-Lexical Lifetimes）。
在现代 Rust 中，如果编译器发现 s_1 被遮蔽后，后面再也没有任何地方（比如你的 y）用到 s_1 相关的内容，为了优化内存，编译器可能会提前销毁 s_1。
但如果有了 let y = &s;：
编译器看到 y 还在用，它就会强行保证 s_1 必须活到 y 最后一次使用的位置之后。

再看下面这个截然不同的例子（❌️）：

let mut s = String::from("hello world");
let y = &s;
s = String::from("hello"); 
// 此时访问 y 会发生什么？

结论：编译报错，原因：悬垂引用

• y 是对 s 的不可变借用（&String）。
  
• 重新赋值 s = ... 的动作，本质上是要销毁旧的 String 并写入新的。这需要对 s 拥有写权限（即独占访问）。
  
• Rust 规则：当存在一个不可变引用（y）时，原对象不能被修改或重新赋值。 否则 y 就会变成悬垂引用。

4.5 Slice类型¶

切片（slice）允许你引用集合中一段连续的元素序列，而不用引用整个集合。slice 是一种引用，所以它不拥有所有权。

4.5.1 字符串Slice¶

字符串 slice（string slice）是 String 中一部分值的引用，它看起来像这样：

let s = String::from("hello world");
let hello = &s[0..5(;
let world = &s[6..11(;

• s[starting_index..ending_index( 的类型是 str，str 在 Rust 中是一个“动态大小类型”（DST, Dynamically Sized Type）。它代表的是内存中的一段连续字节，但编译器在编译时不知道它到底有多长。Rust 不允许直接将 DST 存放在变量中（因为变量必须在栈上分配已知大小的空间）。
  
• &s[starting_index..ending_index( 的类型是 &str，它是一个对 str 的引用，包含地址和长度，大小是确定的
  
• “字符串 slice” 的类型声明写作 &str

我们看一个很经典的例子（❌️）：

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // 错误！

    println!("the first word is: {word}");
}

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i(;
        }
    }

    &s[..(
}

• word 是一个字符串切片 &str。它不仅引用了 s，还具体引用了 s 拥有的堆内存上的部分字节。
  
• s.clear() 需要申请一个可变借用（&mut self），因为这个操作会清空堆内存。
  
• Rust 核心借用规则：同一时间，要么只能有一个可变借用，要么可以有多个不可变借用，但二者不能共存。
  如果允许执行 s.clear()，那么 word 指向的那块内存就被释放了，word 就失效了。Rust 编译器在编译阶段就阻止了这种风险

4.5.2 其他Slice¶

字符串 slice，正如你想象的那样，是针对字符串的。不过也有更通用的 slice 类型。考虑一下这个数组：

let a = [1, 2, 3, 4, 5(;

就跟我们想要获取字符串的一部分那样，我们也会想要引用数组的一部分。我们可以这样做：

let a = [1, 2, 3, 4, 5(;
let slice = &a[1..3(;
assert_eq!(slice, &[2, 3();

4.5.3 Deref Coercion（解引用强制转换）¶

“解引用强制转换” 是一个自动挡功能。它解决的是：“如果函数要的是 &str，但我手里只有 &String，该怎么办？”
我们当然可以显示转换：

let s = String::from("hello");
let slice = &s[0..2(;

实际上，Rust 编译器会自动帮你做这个转换：

let my_string = String::from("hello");
let word = first_word(&my_string); // 注意：first_word需要传入参数&str，但是这里传的是 &String

编译器魔法：String 实现了 Deref<Target = str>。当编译器发现类型不匹配，但存在 Deref 关系时，它会自动帮你调用 .deref()。

五. 结构体¶

5.1 定义和实例化结构体¶

结构体的定义案例：

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

结构体的实例化案例：

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("[email protected]"),
        sign_in_count: 1,
    };
}

• 从结构体中获取值，用.
• 如果结构体是可变的，那么我们就可以修改它的字段：
  

  let mut user1 = ...
  user1.email = ...
  

• 整个实例必须是可变的；Rust 并不允许只将某个字段标记为可变
• 注意结构体实例化时，也可能出现所有权转移问题

5.2 元组结构体¶

可以定义与元组类似的结构体，称为元组结构体（tuple structs）。元组结构体有着结构体名称提供的含义，但没有具体的字段名，只有字段的类型
案例：

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

5.3 类单元结构体¶

• 我们也可以定义一个没有任何字段的结构体！它们被称为 类单元结构体（unit-like structs）因为它们类似于 ()，即“元组类型”一节中提到的 unit 类型。
• 类单元结构体常常在你想要在某个类型上实现 trait 但不需要在类型中存储数据的时候发挥作用.
  案例：
  

  struct AlwaysEqual;
  fn main() {
      let subject = AlwaysEqual;
  }
  

5.4 Debug trait¶

trait 是 Rust 中非常重要的一个概念，它定义了某些类型必须实现的方法集合。当一个类型实现了某个 trait，就意味着这个类型提供了 trait 中定义的所有方法的具体实现。这个概念非常近似于 Python 中的抽象基类。这里我们用 Debug trait 来举例说明：

#[derive(Debug)(
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1:?}");
}

{:#?}风格：

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo( target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle {
    width: 30,
    height: 50,
}

dbg!宏
很强，接收一个表达式的所有权（与 println! 宏相反，后者接收的是引用），打印出代码中调用 dbg! 宏时所在的文件和行号，以及该表达式的结果值，并返回该值的所有权。

#[derive(Debug)(
struct Rectangle {
    width: u32,
    height: u32,
}
fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

输出

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo( target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10:16( 30 * scale = 60
[src/main.rs:14:5( &rect1 = Rectangle {
    width: 60,
    height: 50,
}

5.5 方法¶

5.5.1 方法¶

定义和使用示例：

#[derive(Debug)(
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

• 在 area 的签名中，使用 &self 来替代 rectangle: &Rectangle，&self 实际上是 self: &Self 的缩写。在一个 impl 块中，Self 类型是 impl 块的类型的别名。方法的第一个参数必须有一个名为 self 的 Self 类型的参数，所以 Rust 让你在第一个参数位置上只用 self 这个名字来简化。注意，我们仍然需要在 self 前面使用 & 来表示这个方法借用了 Self 实例，就像我们在 rectangle: &Rectangle 中做的那样。
• 使用方法替代函数，除了可使用方法语法和不需要在每个函数签名中重复 self 的类型之外，其主要好处在于组织性。我们将某个类型实例能做的所有事情都一起放入 impl 块中，而不是让将来的用户在我们的库中到处寻找 Rectangle 的功能。

5.5.2 关联函数¶

• 所有在 impl 块中定义的函数被称为 关联函数（associated functions）
• 我们可以定义不以 self 为第一参数的关联函数（因此不是方法），因为它们并不作用于一个结构体的实例。我们已经使用了一个这样的函数：在 String 类型上定义的 String::from 函数。
• 调用方法：结构体名::函数名

六. 枚举和模式匹配¶

6.1 枚举¶

enum IpAddrKind {
    V4,
    V6,
}

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

6.2 将数据放进枚举的变体¶

enum IpAddr {
    V4(String),
    V6(String),
}
let home = IpAddr::V4(String::from("127.0.0.1"));
let loopback = IpAddr::V6(String::from("::1"));

• 枚举替代结构体还有另一个优势：每个变体可以处理不同类型和数量的数据。这一点用结构体/元组的方式无法做到
  

  enum IpAddr {
      V4(u8, u8, u8, u8),
      V6(String),
  }
  let home = IpAddr::V4(127, 0, 0, 1);
  let loopback = IpAddr::V6(String::from("::1"));
  

enum Message {
    Quit, // 类单元变体
    Move { x: i32, y: i32 }, // 类结构体变体
    Write(String), // 类元组变体
    ChangeColor(i32, i32, i32), // 类元组变体
}

6.3 Option枚举¶

enum Option<T> {
    None,
    Some(T),
}

Rust 引入 Option<T> 是为了解决其他编程语言中 Null 带来的问题。Option<T> 是一个枚举类型，它有两个变体：Some(T) 和 None。Some(T) 表示存在一个值，而 None 表示不存在值。
- 为了拥有一个可能为空的值，你必须要显式的将其放入对应类型的 Option<T> 中。接着，当使用这个值时，必须明确的处理值为空的情况。
- 只要一个值不是 Option<T> 类型，你就可以安全的认定它的值不为空。这是 Rust 的一个经过深思熟虑的设计决策，来限制空值的泛滥以增加 Rust 代码的安全性。

6.4 match 控制流结构¶

match 允许我们将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码。模式可由字面值、变量、通配符和许多其他内容构成
每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 match 表达式的返回值。

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

6.4.1 绑定值的模式¶

#[derive(Debug)( // 这样可以立刻看到州的名称
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

• 这代表了 Rust 枚举（Enum）中一个非常强大的特性：枚举的变体可以持有另一个自定义类型（甚至是另一个枚举）作为它的数据。
• 这种模式在 Rust 中被称为 “关联数据（Associated Data）”。

有了这种模式之后，我们就可以做到：

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        }
    }
}

这种设计叫 代数数据类型（Algebraic Data Types）。它的好处是：数据和逻辑是紧密结合的。

• 安全性：你不能凭空创建一个没有“州”的 Quarter。编译器会强迫你提供州的信息。
  
• 表达力：通过这种嵌套，你可以构建非常复杂的逻辑模型。例如，你可以定义一个 IpAddress 枚举，它有的变体存 V4(u8, u8, u8, u8)，有的变体存 V6(String)。这也与 Option 的原理相同，是 Rust 消灭 null 的核心设计之一。

6.4.2 匹配Option¶

比如我们想要编写一个函数，它获取一个 Option ，如果其中含有一个值，将其加一。如果其中没有值，函数应该返回 None 值，而不尝试执行任何操作。

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);

6.4.3 匹配是穷尽的¶

Rust 知道我们没有覆盖所有可能的情况甚至知道哪些模式被忘记了！Rust 中的匹配是 穷尽的（exhaustive）：必须穷举到最后的可能性来使代码有效。如下这个案例就是❌️的

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
    }
}

Rust 防止我们忘记明确的处理 None 的情况，这让我们免于假设拥有一个实际上为空的值，从而使之前提到的价值亿万的错误不可能发生。

6.4.4 通配模式和_占位符¶

• other => ：其他模式
• _ => ：可以匹配任意值而不绑定到该值，这告诉 Rust 我们不会使用这个值，所以 Rust 也不会警告我们存在未使用的变量。

6.5 if let 和 let else 语法糖¶

if let 语法获取通过等号分隔的一个模式和一个表达式。它的工作方式与 match 相同
使用 if let 意味着编写更少代码，更少的缩进和更少的样板代码。然而，这样会失去 match 强制要求的穷尽性检查来确保你没有忘记处理某些情况。

let config_max = Some(3u8);
if let Some(max) = config_max {
    println!("The maximum is configured to be {max}");
}

可以在 if let 中包含一个 else。else 块中的代码与 match 表达式中的 _ 分支块中的代码相同，这样的 match 表达式就等同于 if let 和 else

let mut count = 0;
if let Coin::Quarter(state) = coin {
    println!("State quarter from {state:?}!");
} else {
    count += 1;
}

或者使用let else语法糖：

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let Coin::Quarter(state) = coin else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

七. 包、crate和模块¶

7.1 crate, package and rs¶

7.1.1 核心概念的层级关系¶

Package (包) > Crate (单元包) > Module (模块)

• Package (包)：就是你 cargo new 出来的那个文件夹。它的标识是目录下必须有一个 Cargo.toml 文件。一个包可以包含多个 Crate。
• Crate (单元包)：是 Rust 编译的最小单位。编译器（rustc）每次编译的都是一个 Crate。它最终会生成一个可执行文件（Binary）或一个库文件（Library）。
• Module (模块)：是 Crate 内部的代码组织方式（用 mod 关键字定义的）。

7.1.2 文件夹与代码的对应关系¶

当你运行 cargo new my_project 时，Cargo 会默认创建一个 Package。

(A) src/main.rs：Binary Crate 的根
* 地位：如果你有这个文件，Cargo 会自动认为这个 Package 包含一个名为 my_project 的 Binary Crate（二进制单元包）。
* 特殊之处：
* 它是该 Crate 的 Crate Root（根文件）。编译器从这里开始读代码。
* 它必须包含一个 main 函数。
* 编译结果：一个可执行文件（在 target/debug/ 下）。

(B) src/lib.rs：Library Crate 的根
* 地位：如果你手动创建或通过 cargo new --lib 创建了这个文件，Cargo 会认为这个 Package 包含一个名为 my_project 的 Library Crate（库单元包）。
* 特殊之处：
* 它是该库 Crate 的 Crate Root。
* 它没有 main 函数。
* 编译结果：一个供别人调用的库（.rlib 文件）。

7.1.3 src/main.rs 和 src/lib.rs 的“潜规则”¶

这是初学者最容易困惑的地方：一个 Package 到底能有几个 Crate？

1. 一个 Package 最多只能有一个 Library Crate。即：src/lib.rs 只能有一个。
2. 一个 Package 可以有多个 Binary Crate。
   • 默认的一个是 src/main.rs。
   • 其他的可以放在 src/bin/ 目录下，比如 src/bin/another_tool.rs，每个文件都是一个独立的 Binary Crate。

7.1.4 为什么要区分 main.rs 和 lib.rs？（实战逻辑）¶

想象你在写一个大型程序（比如一个图片处理器）：

• src/lib.rs (Library)：这里写核心逻辑。比如“如何旋转图片”、“如何调整亮度”。这些代码是通用的，不涉及具体的交互。
• src/main.rs (Binary)：这里只负责交互。它调用 lib.rs 里的逻辑。它像是一个“外壳”，负责读取用户输入的命令行参数，然后交给库去处理。

好处：
* 你的核心逻辑（lib）可以被其他人的程序引用。
* 你可以轻松地写多个 Binary（比如一个是命令行工具，一个是图形界面工具），它们都共享同一个核心库。

7.2 定义模块 (Modules)¶

• 作用: 将代码分组，控制作用域和私有性。
• 定义方式: 使用 mod 关键字。
  

  mod front_of_house {
      pub mod hosting {
          pub fn add_to_waitlist() {}
      }
  }
  

• 模块树: 类似于文件系统目录树。
• src/main.rs 和 src/lib.rs 是 crate 根。
• 查找规则: 声明 mod garden; 时，编译器会查找：
• 内联花括号 { ... }。
• src/garden.rs。
• src/garden/mod.rs（旧风格）。

7.3 引用路径 (Paths)¶

• 绝对路径 (Absolute path): 从 crate 根开始，以 crate 关键字或 crate 名称开头。
  

  crate::front_of_house::hosting::add_to_waitlist();
  

• 相对路径 (Relative path): 从当前模块开始，以 self、super 或当前模块标识符开头。
  

  front_of_house::hosting::add_to_waitlist();
  

7.4 私有性与 pub¶

• 默认私有: 模块内的项（函数、结构体等）默认对父模块私有。
• 子访父: 子模块可以访问父模块的项。
• 父访子: 父模块无法访问子模块的私有项，除非使用 pub。
• pub 关键字:
• pub mod: 使模块对父模块可见。
• pub fn/struct/enum: 使项可见。
• 注意: 仅将模块设为 pub 不会自动将其内容设为 pub。
• super: 访问父模块路径（类似文件系统的 ..）。
  

  super::deliver_order();
  

7.5 结构体与枚举的公有性¶

• Struct:
• 结构体设为 pub，实际上其字段仍然是私有的。
• 需要单独对每个字段加 pub。
• 必须提供公有的构造函数（如果存在私有字段）。
• Enum:
• 枚举设为 pub，则其所有变体 (variants) 自动变为 pub。

7.6 总结前文：经典案例¶

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // 在夏天订购一个黑麦土司作为早餐
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // 改变主意更换想要面包的类型
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);

    // 如果取消下一行的注释代码不能编译；
    // 不允许查看或修改早餐附带的季节水果
    // meal.seasonal_fruit = String::from("blueberries");
}

7.7 使用 use 关键字将路径引入作用域¶

use 关键字的作用：可以创建一个短路径（shortcut），将路径引入作用域，这就类似于在文件系统中创建软连接。
- 一旦将路径引入作用域，就可以直接使用该名称，而不需要写出完整的路径。
- use 只能将名称引入到当前作用域。这是最核心有用的原则，必须牢记。

惯用模式：
- 函数：习惯上将父模块引入作用域，而不是函数本身。
- 理由：这样可以清楚地看出函数不是本地定义的。

// 推荐
use crate::front_of_house::hosting;
hosting::add_to_waitlist();

// 不推荐
use crate::front_of_house::hosting::add_to_waitlist;
add_to_waitlist();

• 结构体、枚举和其他项：习惯上指定完整路径。
  
  • 理由：这是惯例。
    

  use std::collections::HashMap;
  let mut map = HashMap::new();
  

  
  

  • 例外：如果两个不同模块中有同名的项，则必须引入父模块，或者使用 as 关键字重命名。

使用 as 关键字提供新的名称：

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result { /* ... */ }
fn function2() -> IoResult<()> { /* ... */ }

使用 pub use 重导出名称：
- 当使用 use 关键字时，该名称在当前作用域中是私有的。
- 如果希望调用代码也能使用该名称，可以使用 pub use。这被称为重导出（Re-exporting）。

pub use crate::front_of_house::hosting;

使用外部包（External Packages）：
1. 在 Cargo.toml 中添加依赖（例如 rand）。
2. 在代码中使用 use 将其引入作用域。

use rand::Rng;

嵌套路径（Nested Paths）：
当我们需要引入同一个包或模块下的多个项时，可以使用嵌套路径来消除大量的 use 行。

// 普通写法
use std::cmp::Ordering;
use std::io;

// 嵌套写法
use std::{cmp::Ordering, io};

// 引入模块本身及其内部项 (self)
use std::io::{self, Write};

Glob 运算符（Glob Operator）：
如果希望将一个路径下所有公有项都引入作用域，可以使用 *。

use std::collections::*;

常用于测试模块 tests 中引入 super::*。

7.8 总结前文¶

在这个场景下，.rs代码就相当于module，在.rs中用 mod/pub mod 声明的模块实际上相当于声明的是这个.rs module的子module
事实上，.rs代码确实就是 Module 的一种，mod 和 pub mod 声明的也是子模块。
例如我们对于如下的文件树：

src/
├── lib.rs            (Crate Root)
├── network.rs        (Module: network)
└── network/          (文件夹，存放 network 的子模块)
    └── client.rs     (Submodule: network::client)

对应的模块树就是

lib.rs (crate root)
├── network (module)
└── network::client (submodule)

这一点是“将模块拆分为多个文件的基础”，而且可以知道的是，文件树的结果不等于模块树，除了路径引导外，子模块的构建方式还可以在模块内部使用mod声明子模块，详见下文。

7.9 将模块拆分为多个文件¶

案例：拆分前：
src/lib.rs

mod A {
    pub mod B {
        pub fn B_f() {}
    }
}

拆分后：
src/lib.rs

mod A;

src/A.rs

pub mod B {
    pub fn B_f() {}
}

当然也可以是：
src/lib.rs

mod A;

这一点一样，然后不一样的是：
src/A.rs

mod B;

src/A/B.rs

pub fn B_f() {}

• 因此我们可以看到，模块树和文件树的关系并不是一一对应的，以上两种拆分方式有两种文件树结构，但是它们的模块树结构完全一致。

• 我们将各个模块的代码移动到独立文件了，同时模块树保持不变。这个技巧让你可以在模块代码增长时，将它们移动到新文件中。

八. 常见集合¶

8.1 Vector¶

8.1.1 定义¶

Vec<T> 是一个动态数组，可以在运行时增长或缩小。

8.1.2 创建¶

let v: Vec<i32> = Vec::new();

vec! 宏：这个宏会根据我们提供的值来创建一个新的 vector，Rust 会自动推断 vector 的类型。

let v = vec![1, 2, 3(;

8.1.3 插入、访问和删除¶

插入
.push()
访问
两种方式：
1. 通过索引：v[0(（如果索引越界会 panic）
2. 通过 get 方法：v.get(0)（返回 Option<&T>，越界时返回 None）

案例：

let v = vec![1, 2, 3, 4, 5(;
let third: &i32 = &v[2(;
println!("The third element is {third}");
let third: Option<&i32> = v.get(2);
match third {
    Some(third) => println!("The third element is {third}"),
    None => println!("There is no third element."),
}

形如：let a = v[0(; 之类的操作可能会涉及到所有权转让的问题，这行语句是否会会报错取决于所有权的转让。简单来说：
是否可以直接通过 v[0( 获取值（不加 &），取决于 T 是否实现了 Copy trait。

删除：
.pop()：从 vector 的末尾删除最后一个元素并返回它的值（如果 vector 为空则返回 None）。

8.1.4 遍历¶

使用 for 循环来获取 vector 中的每一个元素的不可变引用并将其打印：

let v = vec![100, 32, 57(;
for i in &v {
    println!("{i}");
}

我们也可以遍历可变 vector 的每一个元素的可变引用以便能改变它们。

let mut v = vec![100, 32, 57(;
for i in &mut v {
    *i += 50;
    // 为了修改可变引用所指向的值，必须使用解引用运算符
}

由于借用检查器的规则，无论可变还是不可变地遍历一个 vector 都是安全的。如果尝试在上面两个案例中的 for 循环体内插入或删除项，都会产生编译错误。for 循环中获取的 vector 引用阻止了同时对整个 vector 进行修改。

8.1.5 使用枚举存储多种类型¶

enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

let row = vec![
    SpreadsheetCell::Int(3),
    SpreadsheetCell::Text(String::from("blue")),
    SpreadsheetCell::Float(10.12),
(;

8.2 String¶

8.2.1 定义¶

String 是 Rust 中一个可增长、可变、UTF-8 编码的字符串类型。它是一个堆分配的字符串类型，提供了许多方法来处理文本数据。
其内部表现是一个 Vec<u8>

8.2.2 创建¶

创建一个空字符串：

let mut s = String::new();

从字符串字面值创建：

let data = "initial contents";
let s = data.to_string();
// 该方法也可直接用于字符串字面值：
let s = "initial contents".to_string();

或者：

let s = String::from("initial contents");

8.2.3 更新¶

追加字符串：

let mut s = String::from("foo");
s.push_str("bar");

追加单个字符：

let mut s = String::from("lo");
s.push('l');

使用 + 运算符或 format! 宏拼接字符串：

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; // 注意：s1 的所有权被转移了，s2 被借用了

深度分析一下：

let s3 = s1 + &s2;

(1) 从所有权角度，这一行发生了什么？
+ 运算符调用的是 Add trait 的一个方法。对于 String 类型，它的方法签名大致如下：

fn add(self, s: &str) -> String { ... }

第一个参数是 self，不带&，意味着会发生所有权转让。
底层执行过程：

1. 复用内存：Rust 为了效率，并不会创建一个全新的 String 然后把 s1 和 s2 拷贝进去。相反，它直接接管了 s1 的堆内存缓冲区。
   
2. 追加数据：它把 s2 的内容追加到 s1 那个缓冲区的末尾。
   
3. 重新包装：最后，它把这个增长后的缓冲区重新包装成一个新的 String 并返回，赋值给 s3。

(2) s3 包含了 s2 的不可变引用吗？
不，s3 并不包含 s2 的引用。

• 在 add 函数执行期间，它借用了 s2 的内容，并把这些内容拷贝（Copy） 到了 s3 所拥有的堆内存缓冲区里。
• 一旦 add 函数结束，借用就结束了。
• s3 和 s2 之间没有任何生命周期上的联系。

format!宏
返回一个带有结果内容的 String，使用引用而不会获取任何参数的所有权。

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");
let s = format!("{s1}-{s2}-{s3}");

8.2.4 索引字符串¶

不能通过[(直接访问字符串，因为String 是一个 UTF-8 编码的字符串，直接索引可能会导致访问到一个无效的字符边界。

从 Rust 的角度来讲，事实上有三种相关方式可以查看字符串：字节（Bytes）、标量值（Scalar Values）和字形簇（Grapheme Clusters）。

8.2.5 遍历字符串的方法¶

(1) .chars(): 按 Unicode 标量值（字符）遍历
这是最常用的方法。它将字节流解析为一个个独立的 Unicode 字符（char 类型，每个 char 固定占 4 字节）。

let s = String::from("你好世界");

for c in s.chars() {
    println!("{}", c);
}

• 结果：依次打印出 你, 好, 世, 界。
  
• 适用场景：处理文本内容、统计字符个数。
  
• 注意：这里的“字符”是 Unicode Scalar Value，但在处理带音标的字符（如 é）或 Emoji 时，一个“人类感觉的字符”可能由多个 Unicode 标量组成。

(2) .bytes(): 按字节遍历
返回底层的每一个字节（u8）。

let s = String::from("Hi!");

for b in s.bytes() {
    println!("{}", b);
}

结果：依次打印出 72, 105, 33（即 H, i, ! 的 ASCII 码）。
适用场景：底层协议解析、加密、处理纯 ASCII 文本（性能最高）。
注意：对于中文等非 ASCII 字符，一个汉字会产生 3 个字节，单独操作这些字节通常没有实际意义。

8.3 HashMap¶

HashMap<K, V> 类型储存了一个键类型 K 对应一个值类型 V 的映射。它通过一个哈希函数（hashing function）来实现映射，决定如何将键和值放入内存中。

哈希 map 是同质的：所有的键必须是相同类型，值也必须都是相同类型

8.3.1 创建¶

use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

8.3.2 访问¶

let team_name = String::from("Blue");
let score = scores.get(&team_name).copied().unwrap_or(0);

• get 方法返回一个 Option<&V>，如果键存在则返回 Some(&value)，否则返回 None。
  
• copied() 将 Option<&V> 转换为 Option<V>，前提是 V 实现了 Copy trait。
  
• unwrap_or(0) 在 Option<V> 是 None 时返回默认值 0。

8.3.3 遍历¶

for (key, value) in &scores {
        println!("{key}: {value}");
    }

8.3.4 哈希 map 和所有权¶

对于像 i32 这样的实现了 Copy trait 的类型，其值可以拷贝进哈希 map。对于像 String 这样拥有所有权的值，其值将被移动而哈希 map 会成为这些值的所有者，如示例 8-22 所示：

use std::collections::HashMap;

let field_name = String::from("Favorite color");
let field_value = String::from("Blue");

let mut map = HashMap::new();
map.insert(field_name, field_value);
// 这里 field_name 和 field_value 不再有效，
// 尝试使用它们看看会出现什么编译错误！

如果将值的引用插入哈希 map，这些值本身将不会被移动进哈希 map。但是这些引用指向的值必须至少在哈希 map 有效时也是有效的。

8.3.5 插入¶

(1) 覆盖一个值
.insert(<key>, <value>) 会将值插入到哈希 map 中，如果该键已存在，则会覆盖其值。
(2) 只在键不存在时插入
.entry(<key>).or_insert(<value>) 只有在键不存在时才会插入值。
- 如果键 key 已存在，or_insert 返回一个指向现有值的可变引用(&mut T)，不对值进行修改。
- 如果键 key 不存在，or_insert 将插入提供的值并返回一个指向新值的可变引用。

use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.entry(String::from("Yellow")).or_insert(50);
scores.entry(String::from("Blue")).or_insert(50);
println!("{scores:?}");

根据方法二，我们可以实现根据旧值更新新值，方法如下：

use std::collections::HashMap;
let text = "hello world wonderful world";
let mut map = HashMap::new();
for word in text.split_whitespace() {
    let count = map.entry(word).or_insert(0);
    *count += 1;
}
println!("{map:?}");

九. 错误处理¶

9.1 panic! 宏¶

panic! 宏会导致程序崩溃并显示一个错误信息。
用法：

fn main() {
    panic!("crash and burn");
}

9.2 用 Result 处理可恢复的错误¶

9.2.1 Result 枚举¶

enum Result<T, E> {
    Ok(T),
    Err(E),
}

T 和 E 是泛型类型参数；第十章会详细介绍泛型。现在你需要知道的就是 T 代表成功时返回的 Ok 变体中的数据的类型，而 E 代表失败时返回的 Err 变体中的错误的类型。
案例：

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {error:?}"),
    };
}

匹配不同的错误：

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");
    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {e:?}"),
            },
            _ => {
                panic!("Problem opening the file: {error:?}");
            }
        },
    };
}