james (James)

或西或东，或南或北 —— Rust 中的枚举（Enum）

james — Sat, 30 Nov 2024 09:48:40 +0800

Rust 是一种强类型语言，意味着每一种“东西”都应归属于某一种确切的类型。类型信息为如何解读内存数据提供了一种标准，明确地规定了其所占内存的宽度与所能表达的范围。在 Rust 中，除指针类型（引用、Trait Object等）外，其类型的取值范围都是一个有限集合，理论上都是可以被枚举的。比如，u8 的取值范围是[0,255]。

但 Rust 为什么还要专门设计一个枚举(Enum)出来呢？其想重点表达的意思是：这种类型其的取值范围相对很少，少到只需要扳扳指头就可以把它枚举完。比如，年循四季，月藏三旬，周迭七日，日替昼夜，人分男女。

通过枚举机制，用户可以根据业务需求，精确地设计其类型的取值区间。这样做的好处是，能充分享受 Rust 强大的类型系统的红利，把因类型歧义所导致的相关潜在问题提前暴露到编译时。

枚举的定义与实例化

Rust 中的枚举，分为两种。一种跟 C 语言差不多，可以刻画一个枚举所包含的各种状态；另一种，不只可以表示不同的状态，还可以给状态关联上数据。为了方便讨论，我们姑且把前者称为常规型枚举，后者为关联型枚举。

常规型枚举

要在 Rust 中定义一个枚举类型，只需要用enum关键字，后面跟着你想要定义类型的名称，然后用对花括号开启一个代码区。在代码区中，分别标记出想要的被称作为变体的状态即可。

//枚举的名称，通常遵循驼峰式命名、大写字母开头
enum EnumName { 
    State1, //变体1
    State2, //变体2
    State3, //变体3
    ...
}

作为与结构体中字段的区别，枚举中的状态被称作为变体。它强调的是，各个状态之间的关系是排它的。即一个具体的枚举实例的值在这些状态中变化，在某一时刻只能是其中某一种状态。

来看一个例子，如果要定义表示性别的枚举 Gender，它的可能取值范围是：雄性 与 雌性。

/// 表示性别的枚举
enum Gender {
    Male,   // 雄性
    Female, // 雌性
}

现在已经定义好了 Gender枚举类型，可以创建该类型的两个不同变体的实例：

let male = Gender::Male;
let female = Gender::Female;

注意上面的::连接符号，它表示是某个枚举类型下面的某个的变体。我们采用EnumeName::StateName方式，唯一确定一个枚举值。这与老式的 C 语言中的枚值是不一样的。其好处是，不容易出现名称上的冲突，同一个变体的名字可以在别的枚举中使用。

由于Gender::Male 和 Gender::Female都是 Gender类型的值，那么就可以把它们传递到一个接收Gender类型作为参数的函数中了。比如：

fn perform_some_task_with_gender(gender: Gender, ...some_rest_args) {}

还记得我们之前为老刘的马定义的结构体吗？当时，我们把马的性别定义为u8，并约定：0表示母马、1表示公马。那么实例化时，如果传入数字100，该如何应对呢？在根据性别作不同处理的代码逻辑中，就可能会出现业务层面的Bug！如果使用我们定义的Gender作为类型的话，就不会出现上述的问题，因为其取值被限制了在合法的范围内。下面是修改后的代码：

struct Horse { 
    // --snip--
    gender: Gender, // 马的性别，被限制在合法的范围内。
    // --snip--
}

关联型枚举

与传统的 C 语言不同，Rust 支持在枚举中的变体上关联想要的数据。其大致语法如下：

enum EnumName {
    State1,
    State2(AssociatedType1),
    State3(AssociatedType2),
    ...
}

对所关联的数据类型没有要求，可以是除正在定义的枚举本身类型之外的任何类型。如果想关联正在定义的枚举本身类型，可以改为相应的指针类型。另外，在一个枚举类型中，没有关联数据的变体可以与关联数据的变体并存。各个变体所关联的数据类型也可以不一样。

我们乘坐时间快车，穿越至大明洪武年间，来到了去圣人山冬瓜岭的路上。刚越岭，见一人立于松下，时远眺东南之来路。见我等来人，笑迎而至。拱手道：“昨夜梦中见天开，知有贵客至，今早候于此矣。”此人正是故人一明先生。入其舍，鸡鸣犬吠，堂中新筑土屋，梁柱粗实，院中竹篱环绕，鸡鸭成群，颇具田园之乐。一明端茶以待，笑言：“吾弃文而耕田，六载有余，方知躬耕自乐，胜于枯坐书斋也。”茶过三盏，杀鸡烹羊，炖汤煮菜。红泥火炉笑欢颜，几碗浊酒话天边。与君共此时，一杯何以酣？

看得出来，一明先生通过几年辛勤劳作，积累了不少的财富。下面是老刘脱密后的资产清单：

妻：只能有一个，这是明朝哦，女人也是男人的财产
妾：可以有多个
房屋：以栋数为单位计数
家畜：牛、马、羊等
粮食：玉米、稻谷、黄豆等
蔬菜：因白菜等无法保存，通常直接长在地里，以种植面积计算

为了记录老刘手头的资产，我们怎样设计相关的数据类型呢？一个常见的思路，先设计一个用来表示资产种类的枚举，再设计一个包含有 2 个字段的结构体，一个字段的类型为资产种类，别一个为对应的数量。但是，这里存在一些棘手的问题，有的种类不需要数量信息（因为它只有一个，比如妻子），有的种类又存在多级嵌套（比如牛和玉米，它们还存在上一级类型）。当考虑到这些问题之后，其复杂性就增加了不少。面对这种场景，正是 Rust 中枚举发挥威力的时候，因为它可以关联数据。现在，我们尝试设计一下吧。

/// 资产枚举
enum Asset {
    Wife,                           // 正妻，只能有一个，故无需关联数据
    Concubine(u8),                  // 妾，可以有多个
    House(u8),                      // 房子，以栋计算
    Livestock(LivestockType),       // 家畜，关联家畜种类
    Grain(String, u32),             // 粮食作物，关联作物种类和存量（单位：斤）
    // 因为蔬菜不便储存，所以以种植面积估算
    Vegetable {                     // 蔬菜，使用结构体样式，关联蔬菜种类和种植面积
        name: String,               // 蔬菜名称，假设种类繁多不便统一，使用String
        area: f32,                  // 种植面积（单位：亩）
    },
}

/// 家畜种类的枚举
enum LivestockType {
    Cattle,    // 牛
    Horse,     // 马
    Goat,      // 山羊
    Pig,       // 猪
    Dog,       // 狗
}

对于Asset枚举，其中的Wife没有关联数据，Concubine和House关联的是一个单一类型u8，Livestock关联的是另一个枚举类型LivestockType，Grain关联的是元组类型(String, u32)。Vegetable比较特殊，它关联的是一种称作为匿名结构体的类型：{name: String, area: f32,}。

定义好了这些类型后，就可以用它们来表示具体的资产呢了。

// 300斤稻谷
let paddy = Asset::Grain("稻谷".to_string(), 300);

// 1.5亩白菜
let cabbages = Asset::Vegetable {name: "白菜".to_string(),area: 1.5,};

// 牛
let cattle = Asset::Livestock(LivestockType::Cattle);

细心的同学应该已经发现，上面的类型设计是有缺陷的，不是吗？现在只能标识家畜种类，不能记录其数量。所以，我们要对上面的LivestockType做一些调整，其目的是用于资产的统计，所以需要另外再设计一个类型。下面是重新设计后的代码：

/// 用于资产统计的家畜种类的枚举
enum LivestockAssetType {
    Cattle(Gender, u8),    // 牛
    Horse(Gender, u8),     // 马
    Goat(Gender, u16),     // 山羊
    Pig(u8),               // 猪 作为资产，在市面上不需要区分公母
    Dog(u8),               // 狗 作为资产，在市面上不需要区分公母
}

/// 资产枚举
enum Asset {
    // --snip--
    Livestock(LivestockAssetType),  // 家畜，关联家畜种类
    // --snip--
}

现在，我们就可以记录家畜资产了：

// 3头公牛
let cattle_asset = Asset::Livestock(LivestockAssetType::Cattle(Male, 3));

// 2匹公马
let horse_asset = Asset::Livestock(LivestockAssetType::Horse(Male, 2));

完美！是不是很方便呢？

枚举还有一个好处就是，通过把不同的类型包装在同一个枚举类型中，使其成为同一的类型，方便与外界交互。比如下面的记账函数，它根据家畜市场价格，把各种资产货币化后记入相应的会计科目中。虽然资产种类繁多，但由于我们通过枚举把它们统一化了，所以不管是牛还是马，都可以被视作同一物传入到函数的参数中。

fn record_assets2accounts(livestock: LivestockAssetType){...}

枚举的关联函数与方法

枚举跟结构体一样，也可以有关联函数与关联方法。其使用要求与结构体是一样的，具体情况请参照结构体中相关内容，在此就不再赘述了。

常用枚举类型

Option

Option 是 Rust 标准库中一种枚举，它用来表明一个类型可以有空值的概念，即要么有效值，要么为空。其设计目的是为了解决传统编程语言中空值(null)引发的问题，通过类型系统提供一种安全、显式的方式来表示一个值要么存在（Some），要么缺失（None）。在许多语言中，空值通常由 null 或类似的概念表示，这种设计虽然简单，但存在一些显著问题：首先，空值的存在是隐式的，程序员无法在类型层面确定某个值是否可能为 null；其次，访问空值通常会导致运行时错误，这种错误往往不容易在编译阶段发现。

Option 的定义如下：

enum Option<T> {
    Some(T), // 表示值存在，包含一个类型T的值
    None,    // 表示空值
}

Some(T)表示有一个类型T 的值，T是一个泛型类型（我们还没有学习泛型，你现在可以简单地把它当成是一个类型的占位符），这意味着 Option 枚举的Some变体可以包含任意类型的数据。None表示没有值，等同于别的语言中空值(null)的概念。看几个例子：

let some_number = Some(5); // some_number的类型为 Option<i32>
let some_string = Some("a string"); //some_string的类型为 Option<&str>

let absent_number: Option<i32> = None; //必须加上完整的类型信息，因为无法推定Option<T>中的T

如果使用 None 而不是 Some，需要告诉 Rust Option<T> 是什么类型的，因为编译器只通过 None 值无法推断出 Some 成员保存的值的类型。每一个Option<T>中，都可能会有None，无法分辨它到底属于哪一个类型。

当为Some值时，我们就知道存在一个值。当为None值时，在某种意义上，它跟空值具有相同的意义：并没有一个有效的值。那么，Option<T>为什么就比空值要好呢？因为Option<T> 和 T是不同的类型，编译器不允许像一个肯定有效的值那样使用Option<T>。例如，这段代码不能编译，因为它尝试将Option<i8> 与i8 相加：

let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x + y;

我们忽略编译器的具体错误信息，尝试分析一下它未能通过编译的原因。给一个变量指定为Option的时候，我们是想表达它可能不存在值（空值），那么在使用的时候，我们肯定需要注意它的非空与空的两种状态，对其分别做出相应的处理，特别是当它是空的情况。也就是说，Rust 通过提供Option<T>类型，让它与T是两个不同类型，这样会由类型系统保证程序员不会忽略对空值存在。如果采用传统语言中的空值(null机制，由于空值隐含在类型中（一体两面），一不小心就会忽略对空值的特殊处理。

类型系统阻止Option<i8> 与i8相加，因为它们不是同一种类型，或者说两个类型之间没有实现相加法操作。只有在Option<i8>存在有效值的时候，把有效值i8抽取出来后才能相加。代码如下：

let x: i8 = 5;
let y: Option<i8> = Some(5);

//如果是Some(T),获取内容T;如果是None直接panic
let y_i8 = y.unwrap(); 

let sum = x + y_i8;

从Option中获取有效值，可以通过代码所示的unwrap（如果能确定它有值），也可以采取后文介绍的match与if let。

Option是一个非常强大的工具，标准库和实际项目中都有它的身影。它提供了大量实用的API，我们不可能介绍它的所有细节。其具体情况，请参照相关文档。

Result

Result是标准库给我提供的另一个很重要的枚举类型，其主要作用是用于错误处理。关于错误处理的内容，后续会有专文介绍。在这里，只是从枚举类型的角度，对它作一个简单的介绍。其定义如下：

enum Result<T, E> {
    Ok(T),  // 表示操作成功，包含成功的值 T
    Err(E), // 表示操作失败，包含错误信息 E
}

Result是一个枚举，包含两个变体：Ok(T) 和 Err(E)。Ok 表示操作成功，并包含成功的值 T；Err 表示操作失败，并携带错误信息 E。这种双重状态的设计，使得程序员在使用时必须显式地处理错误情况，从根本上避免了传统异常机制可能带来的隐蔽性问题。

操作枚举的常用方法

match 运算符

match 是一种控制流运算符，在功能上类似于if else 和有些语言（比如 C 语言）中的swith语句。但match要比它们强大，因为它在做判断时支持模式匹配（模式匹配会另开专文讨论）。可以把模式匹配想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。同样地，值也会通过 match 的每一个模式，并且在遇到第一个“符合”的模式时，值会进入相关联的代码块并在执行中被使用。

还是拿我们之前提及过的家畜记帐函数为例，看看如何使用 match 实现其记帐逻辑。

fn record_assets2accounts(livestock: LivestockAssetType) {
    // --snip--
    match livestock {
        LivestockAssetType::Cattle(gender, count) => { /*在花括号内，处理牛相关的逻辑*/ },
        LivestockAssetType::Horse(gender, count) =>    
                        Horse::record_2_accounts(gender, count),//一条语句不用加花括号
        LivestockAssetType::Goat(_, count) => {/*在花括号内，处理羊相关的逻辑*/},
        LivestockAssetType::Pig(cout) => {/*在花括号内，处理猪相关的逻辑*/},
        _ => {/* _ 表示除了上面处理的状态外的其他所有状态，本例中只包括狗*/},
    }
    // --snip--
}

上面的示例代码，根据 livestock 的各种状态，分门别类地做了相应的处理。代码中各个状态关联的数据使用了模式匹配，比如：Pig(count)，由于表示猪的变体定义是Pig(u8)，所以count会匹配到猪所关联的数量；Cattle(gender, count)，由于表示牛的变体定义是Cattle(Gender, u8)，所以gender、count会分别匹配到牛所关联的性别与数量。还可以使用_，忽略相应的关联的数据，比如Goat(_, count)忽略羊的性别，这可能是公羊与母羊在市面上的价格是一样。

现在做一个简单的总结：

match会对一个值（表达式计算后会返回一个值），在所对应类型的所有取值范内进行判定，不能遗漏任何一种情形。
如果满足判定条件，处理 =>后对应的代码段。判定时用到了模式匹配，它可以绑定值，以便在对应的处理代码中使用。也可以用-，忽略相应位置所对应的绑定的值。
可以用-表示除已经列出的状态之外的情况，这种情形也必须要有对应的处理。
match 代码块在整体上作为一个表达式会返回值，这就意味着各个分支处理代码（=> {...}）返回值的类型必须一致。

关于上述的最后一点，举个例子解释一下。比如：

fn handle_with_gender(gender: Gender) {
    // --snip--
    match gender {
        Male => {println!("malle");}, //此处的返回类型是 `()`
        Female => 3, // 此处的返回类型是 `i32`
    }
    // --snip--
}

编译上面代码会出现：match arms have incompatible types的错误，这是显然的，因为match 作为一个表达式，它应该有自己确切的类型，而出现两种不一样的类型必然是不允许的。如果还不明白，把它赋给一个变量就明白了。

// 当编译器为`ret`推定类型时，就陷入了两难之地。ret到底应该是哪种类型呢？
let ret = match gender {...};

if let 控制流

在搞明白了match后，再来讨论if let就相当简单了。我们知道，使用match时，必须要对每一种情况都进行处理，漏掉任何一个都不能通过编译。试想这样一个情况，假如一个枚举有 10 个状态，我们只关心其中的某一个状态，其他情况全部忽略。如果用match实现的话，代码逻辑大致如下：

match some_enum_instance {
    Sate_Cared => {...},
    _ => {...}
}

这样是不是很麻烦？每一次都必须写上_来处理其他情况。在这种场景下，就是if let发挥威力的时候，可以少写很多代码。与上面样版代码等价的用if let代码如下：

if let some_cared_enum_value = some_enum_instance {
    ...
};

下面我们分别用match与if let举几个具体例子，两者都完成一样的功能。

let livestock_asset = LivestockAssetType::Dog(3);
match livestock_asset {
    LivestockAssetType::Dog(n) => println!("There have {} dogs", n),
    _ => (),
}

//对应的`if let`代码：
if let LivestockAssetType::Dog(n) = livestock_asset {
    println!("There have {} dogs", n);
}

if let 还可以跟上else，用于处理其他的情形，比如：

let mut count = 0;

let some_u8_value = Some(0u8);
match some_u8_value {
    Some(3) => count += 1,
    _ => count += 2,
}

//对应的`if let`代码：
if let Some(3) = some_u8_value {
    count += 1;
} else {
    count += 2;
}

枚举的内存布局

在 Rust 中，枚举的内存布局由两部分组成：

标签（Tag）：标识当前枚举属于哪一个变体。
数据（Data）：存储与变体相关联的数据，取关联数据中占用空间最长的变体。

枚举的内存分配方式取决于其变体及其关联数据的特性。Rust 会采用一种最优的方式，以确保枚举占用最小的内存空间。

常规枚举的内存布局

对于不携带关联数据的枚举（称为 C 风格枚举），其内存布局与整数非常相似。例如：

enum Direction {
    North,
    East,
    South,
    West,
}

Direction 枚举包含四个变体，每个变体的值在底层会被编译为整数。具体的布局可以类比为：

枚举变体	对应整数值
`North`	0
`East`	1
`South`	2
`West`	3

此时，Direction 的大小为一个 u8，因为取二位就足够了（2 的 2 次方刚好能表示四个变体），但长度是以字节为单位，最少也要一个字节 (u8）。

fn main() {
    let direction1 = Direction::East;
    println!("Size of Direction: {}", std::mem::size_of_val(&direction1)); // 输出 1
}

所对应的内存布局如下图：

关联数据枚举的内存布局

如果枚举的变体携带数据，Rust 会为变体关联数据分配内存，并在枚举中增加一个标签来指示当前变体。例如：

enum Value {
    Int(i32),
    Float(f64),
}

在这个例子中，Value 的内存布局需要同时容纳：

一个变体标签（1 bit 表示 Int 或 Float）。
两种数据中的最大值（f64 占 8 字节）。

因此，Value 的内存大小为 16 字节。这是因为：最大的变体是f64类型，需要占用 8 个字节，另外还有用于记录变体的标签位占 1 个字节。这两者跟结构体字段一样是组合关系，所以需要参照结构体布局方案，即需要考虑内存对齐。对齐值为两者的最小公倍数，所以对 1 个字节的标签位扩展到 8 个字节。

fn main() {
let value = Value::Float(2.0_f64);
    println!("Size of Direction: {}", std::mem::size_of_val(&value)); // 会输出 16
}

所对应的内存布局如下图：

空值优化布局

Rust 利用指针的特殊值（如 NULL）优化内存布局，使一些枚举类型不需要额外的空间。例如：

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

对于 Option<&T> 类型，Rust 会利用指针值本身的空值语义进行优化：

None 表示为 NULL。
Some(T) 表示为指针值。

因此，Option<&T> 与 &T 的大小是相同的，不需要额外的内存。

use std::mem;

fn main() {
    let v = 42;
    let some_value: Option<&i32> = Some(&v);
    let none_value: Option<&i32> = None;

    println!("Size of Option<&i32>: {}", mem::size_of::<Option<&i32>>()); // 输出 8，即一个指针（地址）的长度
}

some_value 与 none_value 所对应的内存布局图：

可见，对于 Option<&T> 类型，即使包含两种状态，其大小与普通指针一致。

对于枚举的布局问题，我们简单总结如下：

枚举的总大小是 最大变体的大小 加上 对齐后标签的大小。
Rust 不会强行将标签扩展到与对齐值一致，只要对齐要求满足即可。
这种优化节省了内存，同时仍然保持了内存对齐的正确性。

总结

本文系统地讨论了枚举相关的话题，主要包括枚举的意义、枚举的定义与实例化、Option和Result等内容。在文章后部分，还就如何使用match、if let控制流运算符操作枚举、枚举的内存布局等内容，进行了简要地介绍。枚举与结构体一样，都是构建 Rust 程序的重要构件，希望本文能对正在学习 Rust 的您有好所帮助。

如筑如堵，如埤如坻 —— Rust 中的结构体

james — Wed, 27 Nov 2024 03:26:08 +0800

hi，好久不见！有近半年未更新了。我先自罚三杯吧。

一杯是为了农田里犁头与泥土的约定，一杯是为了地铁里被挤压的青春。最后一杯，为了莫名者散落于代码间的悲喜。

今天要讨论的话题是，结构体 (Struct)。摸着良心讲，结构体真的很简单！但作为一个旨在入门的系列教程，没有理由把它绕过去。个人觉得，越是简单的东西，越是不好写。在写这篇文章之前，我几经徘徊，无从下手。到目前为止，此文可能是最差的那一篇吧。发布出来，权当抛砖引玉吧！

我们知道，内存里存放的是无差别的 0 与 1 的序列。“天地不仁，以万物为刍狗”。这是一片混沌的世界，在内存的眼里，众生平等，无界无相无色，无贵贱亦无高下。为了给这个混沌的世界带来光，Rust 提供了基本数据类型（比如整型、字符等），这样就可以对 0 与 1 的序列进行有意义的解读。至此，混沌的世界有了生气。但仅仅依靠这些基本数据类型，不足以 (或者说不方便) 构建绚丽多彩的世界。于是，Rust 又提供了另一个神器，让我们能够自定义各种数据类型以建模业务世界。这个神器，就是自定义类型，在 Rust 中包括结构体(Struct)、枚举(Enum)、联合体(Union)。当然，本文只说结构体，嗯。

可以通过结构体来自定义要想的数据类型，它刻画了这个类型应当由哪些部分组成、各个部分对应的名字与类型以及作为结构体整体上所应支持的行为，然后，它将作为一个整体被 CPU 所理解与使用。如果把基本数据类型比作是建构房屋的砂石、水泥、钢筋、砖块等单元材料，那么结构体就是由这些单元定制的各种预制构件。

好了，故事讲得差不多了。现在让我们来看看在 Rust 中结构体 (Struct) 的具体情况吧。

结构体的定义

在 Rust 中结构体的定义语法如下：

struct StructName { //名称以大小字母开头，采取驼峰式拼写
    field1: data_type1,
    field2: data_type2,
    field3: data_type3,
    ...
}

结构体定义以struct关键字开头，后面紧跟着结构体的名字（名字的首字母通常大写），然后在名字后跟上一对花括号（{通常不换行）。在花括号内，列出你希望结构体所包含的内容，这些内容是由一条条称为字段的东西组成的。比如 field1: data_type1,，这就是一条字段，它定义了一个叫做field1字段，它所对应的类型是data_type1。各个字段之间用,分隔，作为一种习惯，即使是最后一个字段的后面也会默认带上,，这么做的好处也是显然的，比如要在一个已有结构体中插入或者新增一个字段时至少可以少按一次键盘😁。一个字段的类型可以是基本类型，也可以其他已经定义好的结构体类型，还可以是指向正在定义的本结构体的指针类型。

嗯，这就是结构体定义的全部内容了，是不是很简单呢？现在来看一个具体的例子吧。

在具体写代码之前，我想交代一下背景，这可能会贯穿到我们后续的一系列文章中。我们正在用 Rust 写一部中国农耕文化史，记录我们记忆深处的故事。

话说大明洪武年间，在湖广省辰州府有一座圣人山，顶上有一冬瓜岭，这里居住一个叫刘一明的人，时年三十又三。说起刘一明，有一段来历。一明本系江西吉安府人，两年前迁于此。公子聪慧过人，自幼读圣贤，十六即中秀才。然因时运不济，屡试不第，至而立仍为布衣，且孑然一身。某夜梦一赤眉仙人，身披丹甲，脚踏祥云，头生两角如钳，不知何方神圣。仙人劝戒一明远离功名，并赐诗一首与他，诗云：金陵三月好风光，秦淮烟柳转眼空。焚书西行遇圣人，枕瓜而眠粮万顷。梦醒，一明顿悟，其心犹云破月来。遂焚书十担余，誓忘功名。是年洪武廿‌六年，岁次癸酉，适逢“洪武移民”，一明随众一路西行。逾月余，至一千又二百余里处，忽遇一山。巍巍然齐天，白云束腰，望之或有仙气。问之何山？答曰：圣人山。又指白云生处，复问之何地？答曰：冬瓜岭也。一明甚喜，岂非“枕瓜而眠”乎？遂伐木结庐、累石起灶定居于岭上，拓荒开路、播谷栽菽，已二载余也。

这是一段从书本到农田的弃文从农之路。辛酸无奈，但又洒脱从容，还有希望与欢愉。是的，农田一直是勇者乐园，乡村始终是本真的起点。我们的文化，就在那泥土的一翻一覆间；我们的情怀，就在那锄犁的声声碰撞中。寺庙与朝堂，只是懦夫、窃盗者与流氓们的临时庇护所。

对不起，我知道已经跑题了，让我们立马回归正题。刘先生为方便出行与驮运农货，花了 12 两白银，托人从二百里余外的宝庆府马贩张老六处买了一匹白马。现在让我们为其设计一个数据类型。稍加思考，其代码可能如下：

struct Horse { //给这个新的类型取了一个名字:Horse
    name: String, //马的名字，假设马的数量不会太多，主人用不同名字就可以区别
    age: u8, //马的年龄，以月计算
    gender: u8, // 马的性别，规定1是公马、0是母马
    skin_color: String, //马的肤色，比如白马、黑马、枣红色、或者是杂色等
}

很简单，是吧。现在，一个全新的数据类型 Horse 就定义好了。

结构体的实例化

那应该怎么去使用这个类型呢？如何用马这个类型，去创建或者说记录一个实实在在的马呢？这就是结构体实例化问题。

在 Rust 中实例化结构体的完整语法如下：

SomeStructName {
    field1: field1_value,
    field2: field2_value,
    field3: field3_value,
    ...
}

我们要实例化（记录）老刘买的小白马，其代码如下：

let white_horse = Horse {
        name: "丰行".to_string(), //"丰行"，寓意着五谷丰登
        age: 26,
        gender: 1, // 1 表示是公马
        skin_color: "白色".to_string(),
    };

可以通过.运算符，从结构体实例中获取某个字段的信息。比如想知道上面这匹马的年纪：

let age = white_horse.age;

如果要修改结构体实例中的某个字段信息，可以直接对字段进行赋值。比如要更改马的年纪：

white_horse.age = 27;

由于结构体中各个字段是以结构体作为一个整体被使用的，修改某个字段信息，等同于修改了这个结构体实例。所以要使一个结构体实例能被修改，必须要符合我们之前所说的有关变量可变性的规定，也就是说，在定义white_horse变量时必须加上mut关键字，即let mut white_horse = ...

在一个函数或是方法中实例化一个结构体，如果字段的名称与其对应的欲赋值参数或者上下文中的变量名称相同，则可以省略字段名，直接写上参数或变量即可。例如：

// 参数与字段同名
fn build_horse(name: String, age: u8) -> Horse {
    Horse {
        name,//欲赋值变量与字段同名，都是name，省略字段名
        age,//欲赋值变量与字段同名，都是age，省略字段名
        gender:1,
        skin_color: "白色".to_string(),
    }
}


// 上下文中的变量与字段同名
    let age = 28_u8;
    let name = "丰行".to_string();
    let gender = 1_u8;

    let horse2 = Horse{
        name,
        age,
        gender,
        skin_color: "白色".to_string(),
    };

当然，也可以通过一个已有的实例，来实例化一个新的结构体实例。刘一明同志，闻鸡而出、披星而归，加上精打细算，两年后手上又有了一大笔积蓄。为扩大生产，又找张老六购得一匹新马。此马与之前的白马同年同月同日生，也是公马。因其浑身枣红，老刘给它取名“赤瑶”，寓意红红火火、事业爱情双丰收。

现在，请我们为老刘记录一下这匹新买的马。代码可能如下：

let red_horse = Horse {
        name: "赤瑶".to_string(),
        skin_color: "枣红".to_string(),
        ..white_horse //注意：后面不需要加`,`
    };

以上的代码创建了一个新马 red_horse，该实例只是名字与颜色不同于白马，其他的信息是一样的（age、 gender 字段的值与 white_horse 相同）。 ..white_horse 必须放在最后，以指定其余的字段应从 white_horse 的相应字段中获取其值，但我们可以选择以任何顺序为任意字段指定值，而不用考虑结构体定义中字段的顺序。

...white_horse，事实是只是一个语法糖。它表示对于欲实例化实例中未显式列出的字段，其值将用white_horse中对应的字段进行赋值。上面代码在背后的所对应的实际代码大概如下：

let red_horse = Horse {
        name: "赤瑶".to_string(),
        skin_color: "枣红".to_string(),
        //..white_horse 等价下面的代码
        age: white_horse.age, 
        gender: white_horse.gender
    };

这里有一个问题需要注意，由于...white_horse是把一个实例中的字段值赋值另一个实例的字段，本质上是赋值行为，那么当然要遵循 Rust 中有关所有权的规定。换句话说，因字段类型的性质不同，当赋值时，要么发生复制行为，要么发生移动行为。如果是移动，意味着原变量将不可用，因为其相应字段信息被移走了（相当于这个结构体实例的这人字段，被人挖空了😜）。当然，我们上面的例子不会有问题，因为age与gender的类型为基本数据类型（均实现了Copy特征，关于特征后续会开专文讨论），在赋值时是复制行为，所以使用white_horse协助实例化red_horse后，white_horse仍然可用。

如果我们把代码修改一下，情况就不同了。比如下面的代码示例：

fn main() {
    let mut  white_horse = Horse {
        name: "丰行".to_string(),
        age: 26,
        gender: 1,
        skin_color: "白色".to_string(),
    };


    let red_horse = Horse {
        name: "赤瑶".to_string(),
        // 注释下面这一行，表示red_horse的颜色与white_horse 一样，赋值时发生移动行为
        //skin_color: "枣红".to_string(),
        ..white_horse
    };


    println!("{:?}", white_horse);
}

上述代码，将无法通过编译，会提示类似value borrowed here after partial move的错误。白马的毛色信息赋值给红马的时候，其效果好比是把白马的毛全部拔光了，😂哈哈！当然，这不是我们今天的主题，只是在这里顺便复习一下之前的内容。

关联函数与关联方法

结构体，不光可以包含字段，还可以与函数相关联。结构体实例化后，在内存中表现为一连串的二进制序列。函数，通常被加载到内存中一个称为代码段地方，函数名称作为函数调度的单位，其事实上只是一个指针类型的实例，代表了对应函数代码序列的起始处地址。可见，在内存的角度看，两者是没有任何关系的。一个，面朝大海；一个，头顶青山。但为了表达一个结构体具备某种行为能力，即该类型或该类型的实例可以调用哪些函数，需要将两者关联起来。这样，这些函数在逻辑上就隶属于某个特定的结构体类型。这就是所谓的关联的实质，关联函数与关联方法在技术实现层面是一样的，只有概念与目的上的区别。

关联函数

关联函数的语法如下：

impl SomeStructName {
    fn func1_name(arg1: Arg1Type,arg2: Arg2Type,...) -> ReturnType {...}
    fn func2_name(arg1: Arg1Type,arg2: Arg2Type,...) -> ReturnType {...}
    fn func3_name(arg1: Arg1Type,arg2: Arg2Type,...) -> ReturnType {...}
    ...

}

要为一个结构体实现关联函数，使用impl关键字，在后面紧跟结构体名，然后用一对花括号开启一个代码区。在这对花括号中定义的函数，就是该类型的关系函数。函数定义的规则，与常规的函数定义没有什么区别。

现在，我们为马这个结构体来定义一个关联方法new：

impl Horse {
    fn new(name: String, age: u8, gender: u8, skin_color: String) -> Self {
        Horse {
            name,age,gender,skin_color,
        }
    }
}

以上的代码中的new函数不是一个普通的函数，而是Horse的关联函数。该函数的功能是根据传入的参数，实例化一个 Horse 实例。这个函数有两点需要稍微解释一下，一是返回类型：Self，它是一种语法糖，等同于所关联的结构体的类型，在上例中就是Horse。另一个，就是函数内创建的实例的代码Horse{...}后面没有跟上;，它表示创建并返回，相当于 return Horse{...}; 。

使用关联函数的例子，比如下面代码，我们使用上面的定义的new函数。

let horse = Horse::new(
        "丰行".to_string(),
        28_u8,
        1,
        "白色".to_string()
    );

在以上代码中，我们在调用new函数的前面加上了前缀Horse::，它表明new不是一个普通的函数，而是一个关联函数，其在逻辑上隶属于Horse类。所以，我们调用关联函数的时候，既要指明它所隶属的类型信息，还要指明函数本身的函数名信息。其中的::符号表示后者在前者的范围内。但在编译后的可执行文件中所包括的符号信息，可能会是类似：_some_prefix_horse_new_(...)形式的名称，可见关联函数本质还是一种普通函数，只是为表达既定的语义，编译作了额外的支持。

关联方法

关联方法跟关联函数基本上是一样的，它们之间的区别仅仅在函数的参数上。这个区别，是由关联方法与关联函数在概念上的区别所导致的。关联函数，强调的是一个函数隶属于一个类型，相当于其他语言中的静态方法。而关联方法，则强调的是一个函数隶属于一个类型的实例，这一点与其他大部分的面向对象语言中的方法是一致的。

关联方法要求所定义的函数的参数中，有一个参数必须是self/&self/&mut self中的一种，这样，该方法就与实例之间存在一种关联了。其中self是self: Self的语法糖，表示调用方法的实例，其他两者分别表示调用方法的实例的不可变与可变引用。在impl SomeStruct代码区内定义的函数，如果满足上面对于参数的要求，那么它就是这个类型的关系方法，否则就是关联函数。

下面，举几个关联方法的例子吧。

impl Horse {

    // 获取马儿的名字
    fn get_name(&self) -> String {
        let name = self.name.clone();
        name
    }

    // 设置马儿的名字
    fn set_name(&mut self, name: String) {
        self.name = name;
    }

    fn run(self) {
        // 马儿在奔跑...
    }

    fn carry(&self,goods: u16) {
        // 马儿驮运货物
    }
}

下面是具体使用这些关联方法的示例。

fn main() {
    let mut  horse = Horse::new(
        "丰行".to_string(),
        28_u8,
        1,
        "白色".to_string()
    );

    // 获取马儿的姓名
    let name = horse.get_name();
    //重新设置马儿的年龄
    horse.set_name("赤瑶".to_string());

    // 让马儿驮运 50kg 的货物
    horse.carry(50);

    // 让马儿奔跑起来，由于参数是self,运行该方法后，horse实例的所有权被移走
    horse.run();

    // 下面代码将无法通过编译，horse因调用run()而失效。
    //_ = horse.get_name();

}

上面代码展示了如何用instance.method()方式调用一个关联方法，这种调用方式很符合人类的思维方式，感觉instance拥有了method这种行为，调用起来甚是自然。事实上，instance.method()只是一种语法糖，编译器在背后会把它转换成：

SomeType::method(
    instance/&instance/&mut instance,
    other_rest_args...
);

比如，对于下面的代码：

horse.carry(50);

编译器会把它转换成：

Horse::carry(&horse,100);

编译器的这种转换，为程序员提供极大的便利，它会自动为instance 添加 &、&mut 或 * 以便使 instance 与方法签名匹配。比如，上面的代码中，horse是self类型，而carry要求的参数是&self，当直接用self类型的实例调用方法时，编译器自动用实例的引用（&self）传递到方法中。同理，如果参数要求是self，而调用者是&self，编译器会先把引用先解引用后*self），再把得到的本体传递到方法中。

对于一个结构体，可以使用impl为其开辟多个代码区，用于划分不同的的业务逻辑。在代码区内，既可以写关联函数，也可以写关联方法。

impl Horse {// 基本属性相关的代码区
    ...
}

impl Horse {// 出行相关的代码区
    ...
}

impl Horse {// 驮运农货相关的代码区
    ...
}

对于关联方法，最后一个需要提及的问题是，要注意在调用方法时的所有权转移问题。就是，如果一个类型没有实现Copy特征，当调用一个参数要求是self 的方法后，实例的所有权将发生转移。也这是，上面示例代码中，当调用horse.run()后，horse实例不可再用的原因。可见，所有权原则在 Rust 中无处不在！不熟悉的朋友，敬请查看我之前的相关文章。

几个特殊的结构体

元组结构体

元组结构体也是一种结构体，同样有自己的名字，只是没有具体的字段名，只有字段的类型。当你想给整个元组取一个名字，并使元组成为与其他元组不同的类型时，元组结构体是很有用的。

要定义元组结构体，以struct关键字和结构体名开头，后面紧跟着一个元组类型。下面是两个分别叫做 Color 和 Point 元组结构体的定义和用法：

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

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

注意 black 和 origin值的类型不同，因为它们是不同的元组结构体的实例。你定义的每一个结构体有其自己的类型，即使结构体中的字段有着相同的类型。例如，一个获取 Color 类型参数的函数不能接受 Point 作为参数，即便这两个类型都由三个 i32 值组成。在其他方面，元组结构体实例类似于元组：可以将其解构为单独的部分，也可以使用 . 后跟索引来访问单独的值。

单元结构体

单元结构体，没有包含有任何字段，仅仅只提供一个名字，它类似于空元组()类型。既然单元结构体不包含字段，那么设计这种类型的用意思是什么呢？如果你看了前面的内容，你应该知道结构体除了字段信息外，还有一个重要的信息就是关系函数或方法。对，设计这种类型之目的，就是为了给它增加关联函数或关联方法。当然也可以为它实现特征（Trait），我们后面会有专文讨论特征的话题。现在你只需要知道，所谓的特征在本质上也算是一种关联方法，只是在关联方法的基础上增加了一些限制罢了。

下在是一个单元结构体的例子。

struct UnitStruct;
impl UnitStruct {
    fn do_something(&self) {}
}
fn main() {
    let unit_object = UnitStruct;
    unit_object.do_something();
}

可见，单元结构体除了没有字段外，与普通的结构体没有什么区别。

结体体的可见性

可见性是 Rust 中的重要内容，后续会开专文讨论。在这里，仅仅简单地说一下与结构体相关的内容。在讨论这个话题之前，我先声明一下：接下来的言辞，可能不精准，但不会影响对后续相关内容的理解。

所谓的可见性，是指一个类型能被访问的范围。对于结构体来说，主要有两层含义。一是，该结构体类型作为一个整体能否被外界访问；二是，如果该结构体可以被访问，那么哪些字段可以被外界访问？哪些字段不能被访问？

总体的情况是，结构体及其字段、关系函数和方法的可见性，大致可分为两个级别。一个是公共的（用pub关键字标），另一个是私有（默认）的。对于公开级别的，如果定义该结构体所处的模块能被使用者所在模块可见，那么对应被标记的结构体或字段也能被使用者访问，否则不可访问。对于私有级别，仅能在定义该结构体的当前模块内被访问。

先看一例子吧。

// main.rs
struct Horse {
    name: String, 
    age: u8, 
    gender: u8, 
    skin_color: String, 
}

impl Horse {
    fn new(name: String, age: u8, gender: u8, skin_color: String) -> Self {
        Horse {
            name,age,gender,skin_color,
        }
    }
    fn run(self) {}

    fn carry(&self,goods: u16) {}
}



fn main() {
    let horse = Horse::new("丰行".to_string(),
    28,
    1,
    "白色".to_string());

    let name = horse.name.clone();
    horse.carry(100);
}

以上代码可以正常通过编译，在main函数中可以访问Horse类型及其关联函数与方法。这是因为，mian函数与结构体的定义在同一个main.rs文件中，虽然结构体以及内部的字段和关联函数与方法都是私有的（没有加上pub关键字）。

再举一个例子。

/// horse.rs
struct Horse {
    name: String, 
    age: u8, 
    gender: u8, 
    skin_color: String, 
}

impl Horse {
    fn new(name: String, age: u8, gender: u8, skin_color: String) -> Self {
        Horse {
            name,age,gender,skin_color,
        }
    }

    fn run(self) {}
    fn carry(&self,goods: u16) {}
}


/// main.rs
mod horse;
use horse::*; // 先忽略此行
fn main() {
    let horse = Horse::new("丰行".to_string(),
    28,
    1,
    "白色".to_string());

    let name = horse.name.clone();
    horse.carry(100);
}

这一次，我们把定义马的逻辑抽到了horse.rs中，并通过mod horse导入至main中作用域中。编译上面的代码，会出现类似：failed to resolve: use of undeclared type Horse的错误信息，表明不能识别Horse类型，也就是说Horse类型不能被外界访问。因为，我们的Horse默认的可见性是私有的，其仅能在hosre模块内被访问。要想让上面的main函数通过编译，必须修改代码。修改后可可编译的代码如下：

/// horse.rs
pub struct Horse { //加上pub，以便外界可访问
    pub name: String, //加上pub，以便外界可访问
    age: u8, 
    gender: u8, 
    skin_color: String, 
}

impl Horse {
    pub fn new(name: String, age: u8, gender: u8, skin_color: String) -> Self {
        Horse {
            name,age,gender,skin_color,
        }
    }

    fn run(self) {}

    //加上pub，以便外界可访问
    pub fn carry(&self,goods: u16) {}

}

可见，想对外公开，只需在前面加上pub 关键字。好了，这就是有关结构体中可见性的情况了。

让我们来作个简单的总结：

结构体，默认情况是私有的，仅在定义它的模块内可见，若要公开需加上pub关键字。如果结构体本身是私有的，其字段与关联方法必然也是不可访问的。
结构体的各个字段，有自己的可见性，默认情况是私有的，若要公开需加上pub关键字。
结构体的关联函数与方法，有自己的可见性，默认情况是私有的，若要公开需加上pub关键字。

结构体的内存布局

所谓的内存布局，是指结构实例中的字段在内存中是如何被排列的，以及该实例最终所占用的内存空间尺寸。这里涉及到一个重要的话题，就是内存对齐问题。至于什么是内存对齐，以及为什么需要内存对齐，我不想做过多的讨论，要彻底地讲清楚可能需要开一篇专文。在这里打一个不是很恰当也不准确的比方，但可以方便我们理解。把数据比做是物品，把内存比做是一个连续的场地，场地上画了一条线性排列的格子，每一个格子都标有序号用以表示它的位置，物品整齐地摆放在场地的格子里。把 CPU 比做人，人与这些物品打交道时，人需要走到这些格子上去查看或者拿取物品。假设人走路时每走一步可以跨越 N 个格子，那么如果一个数据从其开始到结束点的长度，处在两个步伐的交叉处，就很不方便，自然会影响工作效率。最理想的情况是，这些数据尽量都放在步行的起始处（或步长内）。

常规内存布局

Rust 内存布局问题的关键，是内存对齐。内存对齐问题，分基本数据类型与自定义类型两种情况，现在我们分别来讨论。

基本类型的对齐

比如 u32 需要在内存中以 4 字节对齐，u8 类型则需要 1 字节对齐。通常一个占用 N 个字节的类型，它的实例就是按 N 个字节对齐。按 N 个字节对齐的意思是，存放它的地址必须是对齐值N的整数倍，当 N 为 1 时，表示可以存储在任意位置。

结构体的对齐

结构体作为一个独立的数据类型，它的对齐值取决于其所包含的字段类型。会以所包含字段中类型长度最大的值，作为整个结构体的对齐值。然后再按照这个对齐值，对字段进行排列组合，再进行填充（padding)。结构体最后所占用的内存长度，等于各字段原本的数据长度，再加上，所有字段的 padding 长度的总和。

看一个实际的例子：

#[derive(Debug)]
struct Example {
    a: u8,  // 1 字节
    b: u32, // 4 字节
    c: u16, // 2 字节
}

fn main() {
    let ex = Example {a:1,b:2,c:3};
    println!("Example size: {}", std::mem::size_of::<Example>()); // 输出大小
    println!("Align of struct: {}", std::mem::align_of::<Example>()); // 输出对齐值
}

运行上面程序，会输出：

Example size: 8
Align of struct: 4

表明结构体Example实例在内存占用 8 个字节，整个结构体的对齐值为 4 个字节。实例ex在内存中的具体布局如下图所示：

如果我们把b:u32 改为b: u64，程序会输出：

Example size: 16
Align of struct: 8

此时，内存布局如下：

通过这个例子，我们可以得到正常情况下，Rust 中结构体实例在内存布局的规律：

编译器根据节约内存的原则，结合对齐值，会对字段的顺序进行重新排列（不需要人为排序）。
结构体的对齐值，为所包含字段中的最大的那一个（多个字段长度的最小公倍数，通常为 2 的 N 次幂）。
如果一个结构体的对齐值是 N ，那么结构体的总长度必须是 N 的整数倍。
为了匹配对齐值，编译器会根据情况把多个字段合并在一起，并插入0作为 padding。如果是最后一个字段，不会插入填充值，比如上图中的字段a:1，其后面的b04ae7b78f 是内存中原本的内容。这是可以理解的，因为当访问ex.a的时候，已经找它的起始地址，再选择一个字节的长度（u8的宽度）即可，后面的信息自然可以忽略掉。

几个特殊的内存布局

Rust 为我们提供另外几种内存布局模式，用于某些特定的场景。

`#[repr(align(N))]`

#[repr(align(N))] 允许我们显式地为结构体或类型指定一个对齐值，这对于优化内存布局或者确保特定的对齐需求非常有用。该属性将确保该类型的对齐值为N个字节。

假设我们想要确保结构体按照 8 字节对齐：

#[repr(align(8))]
struct AlignedStruct {
    a: u8,
    b: u32,
}

fn main() {
    println!("Size of AlignedStruct: {}", mem::size_of::<AlignedStruct>());
    println!("Align of AlignedStruct: {}", mem::align_of::<AlignedStruct>());
}

输出：

Size of AlignedStruct: 8
Align of AlignedStruct: 8

该类型实例的内存布局如下图：

`#[repr(C)]`

#[repr(C)]可以确保 Rust 结构体的内存布局与 C 语言的结构体布局一致。这对于与 C 语言进行 FFI（外部函数接口）时非常重要。C 语言的结构体通常要求严格的内存布局，因此 Rust 必须遵循与 C 相同的规则。

 #[repr(C)]
struct Example {
    a: u8,
    b: u32,
}

FFI 是一个很重要的内容，现在你只需要知道是用来和 C 交互的就行了。C 中结构体布局问题请查阅其相关的内容。

#### #[repr(transparent)] #[repr(transparent)]是 Rust 中用于新类型模式的一种标记，它用于指示一个结构体或枚举具有透明的内存布局，也就是说，结构体的内存布局与其唯一字段的内存布局完全相同。该标记常用于封装底层类型时，避免对齐和大小的改变，从而保持与底层类型相同的内存布局。

 #[repr(transparent)]
struct MyU32(u32);

fn main() {
    println!("Size of MyU32: {}", std::mem::size_of::<MyU32>());
    println!("Align of MyU32: {}", std::mem::align_of::<MyU32>());
}

输出：

 Size of MyU32: 4
Align of MyU32: 4

这会使得结构体 MyU32 的内存布局与其唯一字段 u32 完全相同，且不会引入任何额外的填充字节或对齐要求的改变。这样做的好处是，便于与 C 语言等其他语言进行互操作。如果我们希望在 Rust 中封装一个 C 语言中的类型，并确保其内存布局与 C 类型兼容，#[repr(transparent)] 是一个理想的选择。

#### #[repr(packed)] #[repr(packed)] 属性可以让 Rust 编译器取消结构体中的填充字节，使得结构体紧凑地排列。这种方式可能会导致字段不符合其自然对齐要求，因此在访问这些字段时需要特别小心，以避免性能问题和潜在的未定义行为。

 #[repr(packed)]
struct PackedExample {
    a: u8,
    b: u32,
}

PackedExample的对齐值为：1，其实例的总长度为：5。对应的内存布局如下：

总结

本文系统地讨论了结构体相关的内容，主要包括结构体的意义、结构体的定义与实例化以及关联函数与方法等内容。在文章后面，还就结构体的可见性与内存布局等问题，进行了简要地介绍。结构体是构建 Rust 程序的重要构件，希望本文能对正在学习 Rust 的您有好所帮助。

好了，这可能是结构体中的所有内容了！嗯，我是说可能是。

不以规矩，不能成方圆 —— Rust 王国的物权法

james — Wed, 12 Jun 2024 20:00:53 +0800

孟子曰：离娄之明，公输子之巧，不以规矩，不能成方圆。 —— 《孟子》离娄章句上篇语

所有权与借用机制，明确了内存资源的权属，规范了借用内存资源的秩序，巧妙地解决了内存管理中的三大经典问题，是 Rust 王国的物权法。本文将从核心思想、具体规则以及对规则的验证等方面，对所有权与借用机制进行深入浅出的介绍，旨在让读者能快速的理解所有权与借用的内涵。

核心思想

我们已经知道了一些事实的真相。那就是，栈中的内容会自动实现创建与释放，每调用一个函数都会创建一个函数栈，函数内部的创建的变量在这个栈里有效，当函数返回时，这个函数栈会整体的被弹出，这些变量就变得不可见了，也就等同于被释放了。函数栈的空间范围，就是栈内变量的生命周期，变量仅在其生命周期内有效。我们还知道，对堆的使用，其实都需要通过栈作为中转。分配一个堆上的空间，会在栈上有一个指针类型的变量与之关联，之后对堆内容的读写操作，无一不是通过与之关联的栈上指针变量进行的。

很显然，栈与堆存在着依赖关系，它们同生不同死，一个是自生自灭，另一个却贪恋红尘、不死不休。说到这里，一个自然而然的想法就是，我们能不能通过栈中的变量来管理堆中内容，能让他们同生共死呢？这种朴素的想法，即使是山野山夫也能想到的，这也是“道法自然”的体现，数据结构中的“树”、“链表”、“队列”等等都是如此。

Rust 正是基于这种朴素自然的思想，提出了以所有权为基石的一系列方法论，用以回答内存管理中的三个问题的。其核心思想是：把栈与堆关联起来，通过对栈的自动化先天特性进行赋能，以实现对堆资源管理的自动化。

为了实现上述核心思想，Rust 设计了具体的方案。那就是，把所有的内存资源“拟物化”，然后比照我们现实社会，制订了《物权法》来管理这些资源。编译器充当大法官的角色，在编译时，对源代码进行检查，如果存在有不合法行为，就拒绝编译。

该物权法包括两部分内容，一是所有权，二是借用。所有权篇，明确了物的权属问题，即回答了“内存资源的所有者是谁？谁有权处置？”等问题。借用篇，提出了借用的概念（借用者可以通过引用方式借用内存资源），并明确了多个借用者之间、借用者与所有者之间的关系，旨在盘活内存资源、挖掘其资源价值。前者是体，后者为用。

所有权

所有权部分相关的主要法条如下：

1.每一个值，都有一个对应的变量作为它的所有者；
2.在某一时段内，值有且只有一个所有；
3.当所有者离开自己的作用域时，它持有的值就会被释放掉。

现在对该法条中的“所有者”与“作用域”以及其相关的概念，作一下解读。

所有者

对于栈中的值，其所有者就是自身或者说它对应的变量符号；对于堆中的值，其所有者就是保存在栈上的变量。

看一张图：

作用域

作用域是针对变量而言的，通俗地讲就是它的可见范围。如果变量是可见的，其所代表的资源是存活的；如果变量是不可见的，其所代表的资源就应该被释放。一个变量是否可见，就是看它是否在当前的程序栈中，在栈内的变量就是可见，否则就是不可见的。所以，变量作为域的长度，等于变量所在位置到最内层栈的栈顶长度。事实上，作用域是生命周期的空间化概念。

比如如下代码：

{ // 变量 s 还没有声明，所以 s 不可见、不可用
    let s = 5;  // 从这里开始， s 可见、可用
} // 作用域结束， s 不可见、不可用

复制与移动

值是资源，变量是所有者。我们的目的是要让值与变量保持一一对应，达到同生共死。当一个变量赋值给别一个变量的时候 (函数的传参也一样），就要考虑到始终保持这种一一对应关系不被打破。对此，就赋值行为，Rust 引入了“复制”与“移动”机制，以对不同的场景作分别处理。

1. 复制

所谓的复制，是把值按位逐一拷贝一份，然后用一个新的变量（即所有者）与之关联。

是否采取复制行为，关键是看一个类型是否实现了 Copy 特征。对于储备在栈上的值，其内存大小是在编译时可知的，比如基本数据类型都默认实现了该特征，所以会采取复制行为。

这些类型主要有：

类型	描述
基本类型	整数、浮点数、布尔值和字符类型等
复合类型	数组、元组
指针类型	引用、裸指针、函数指针等

比如：

// 下面的每个值都只有一个所有者，赋值时的行为是复制
let num1 = 42;
let num2 = num1; // num2是一个新的所有者，它的值是 num1值的复制品，num1仍然是一个有效的所有者
println!("{}", num1); // 42,可以通过 num1 使用值

let arr1: [i32; 3] = [1, 2, 3];
let arr2 = arr1;

let num = 21;
let p1 = &num;
let p2 = p1;

2. 移动

移动是 Rust 的默认行为，没有实现了Copy特征的类型变量在赋值（或函数传参）时，都会发生移动行为。所谓的移动，是指会让值的原变量失效，而新的变量作为值的所有者。

现在我们来讨论一下为什么要这么设计？假设有一个栈中的变量a，是指针类型，它里面所保存的值是某个 堆内存 中的地址，此时，栈与栈的内容如下图：

当把这个变量a赋值给同类型的变量b会发生什么呢？

let a: 指针类型 = 堆内存A的起始地址
let b: 指针类型 = a

如果按照之前的复制行为进行赋值，栈与堆中的内容会如下：

如图所示，此时堆中的值有栈上的两个变量与之关联。这就违背了“一个值只有一个变量作为所有者”的规定，所以这种复制行为对于指针类型的变量在赋值时就不适应。上面讨论的是纯粹的指针类型变量的情况，对于组合类型，如果其中某个分量的类型也是指针这种类型，并且指向堆内存的值，也会出现同样的问题，即一个值将会有多个变量与其关联。出现这种情况的原因是，这种复制其实是浅拷贝，即仅仅对栈上的内存进行byte to byte的拷贝。顺便提一下，Rust 也支持深拷贝，提供了一个叫做Clone的特征，其中有个 clone()方法会实现深拷贝。但通常深拷贝会消耗更多的性能，所以必须显式调用。

如果按移动方式进行的话，上面这个例子中，当完成赋值操作后，原变量a 将失效，不允许再使用。此时，栈与堆中的内容如下：

对于在编译期无法知道其大小的类型（这种类型要么直接关联有堆内存中的值，要么至少有一个分量关联有堆内存中的值），比如字符串类型，在赋值时会采取移动行为。这些类型主要有：

类型	描述
字符串类型	str, 本质上是一个 u8 类型的数据序列，实际中经常使用的形式：&str 和 String
切片类型	[T], 它代表类型为 T 的元素组成的数据序列：实际中经常使用的形式：Vec
trait object	trait object 的大小只有在运行时才能确定
...	...

3. 自动释放

通过上面的分析，可以看出 所有者、 复制与移动 机制，保证了法条中第一和第二条的规定，但还不能保证第三条的要求。变量在作用域 结束后，将变得不可访问（类似于释放），但如果这个变量是指针类型，还应该让其所指向的堆内容也一同释放。为了实现这一要求，Rust 约定，一个类型如果实现了Drop特征（其中有一个drop方法），该类型的变量离开作用域之前，编译器会插入调用drop方法的代码，用以负责处理释放堆内容等相关善后操作。

这样，当栈变量释放的同时，与之关联的堆空间也得到了释放，也保证了法条的第三条的规定。这也是体现所有权的核心思想：把栈与堆关联起来，通过对栈的自动化先天特性进行赋能，以实现对堆资源管理的自动化。

验证所有权规则

所有权相关的内容已经讨论完了，现在我们来验证下。下面我们分别使用编译期可知大小的基本类型i32与编译期未知大小的动态类型String进行验证。字符串类型String内部有一个指针类型的变量，指向堆上实际存放字符串的空间，程序在运行的时候，可能通过操作这块堆内存实现字符串内容的动态增减。

现在，我们开始验证吧。看看，这些类型能不能满足所有权机制的要求。

1. 验证固定尺寸的类型

作用域

fn main() {
   let a = 5;

   { // b 的作用域是内部的花括号内
      let b = 6;
   }

   // 此处，b 已经离开作用域，固不可见、不可访问
   let a = b;
}

以上代码无法通过编译，会报：error[E0425]: cannot find valuebin this scope错误，说明变量仅在作用域内生效。

赋值

fn main() {
   let a = 5;
   let b = a; // 发生复制行为
   println!("{},{}", a, b);
}

以上代码能通过编译，并输出 5,5

函数传参

fn func1(a: i32) {
   println!("{}", a);
}

fn main() {
   let a = 5;
   func1(a); //传参时，发生复制行为

   println!("{}", a); // 传参后，原变量仍然有效
}

以上代码，能通过编译，运行后会打印出变量a的值：5。

2. 验证动态尺寸的类型

作用域

fn main() {
   { // s1 的作用域是内部的花括号内
      let s1 = "abc";
   }
   let s2 = s1; // 此处，s1 已经离开作用域，固不可见、不可访问
}

以上代码无法通过编译，会报：error[E0425]: cannot find values1in this scope 错误，说明变量仅在作用域内生效。

赋值

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

   // 因为，String这种动态类型
   // 没有实现`Copy`特征，所以赋值时发生的是移动行为，所有权转移至新的变量
   let s2 = s1; 

   println!("{}", s1);

}

以上代码无法通过编译，会报：error[E0382]: borrow of moved value:s1`` 错误，说明所有权发生转移，原变量失效。

6  |    let s1 = String::from("hello");
   |        -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
...
10 |    let s2 = s1; 
   |             -- value moved here
11 |
12 |    println!("{}", s1);
   |                   ^^ value borrowed here after move

以上代码之所以会无法通过编译的原因是，String这种类型由于没有实现Copy特征，在赋值的时候进行的移动行为。移动作为会导致值所关联的原变量失效，值的所有得变成新的变量。这个行为如下图所示：

如果不是进行移动，而是复制，会是下图的效果：

如果把let s2 = s1 改成let s2 = s1.clone()，实现的深拷贝，其效果如下：

函数传参

fn func1(a: String) {
   println!("{}", a);
}

fn main() {
   let s1 = String::from("abc");
   func1(s1); // 发生移动行为，所有权转移到函数中，原变量s1不可用

   println!("{}",s1); // s1 在此处不可用

}

函数传参的规则跟赋值类似，函数调用时会传参，传参数的过程等同于赋值。上面代码无法通过编译，会报：error[E0382]: borrow of moved value:s1`错误，说明所有权转移至func1函数体内，原变量s1`失效。

error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:9:18
  |
6 |    let s1 = String::from("abc");
  |        -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
7 |    func1(s1); // 发生移动行为，所有权转移到函数中，原变量s1不可用                    ...
  |          -- value moved here
8 |
9 |    println!("{}",s1); // s1 在此处不可用
  |                  ^^ value borrowed here after move

函数返回

值的所有权，也可以从函数内部返回到调用方。

fn main() {
  let s1 = gives_ownership();         // gives_ownership 将返回值
                                      // 移给 s1

  let s2 = String::from("hello");     // s2 进入作用域

  let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                      // takes_and_gives_back 中,
                                      // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String {           // gives_ownership 将返回值移动给
                                           // 调用它的函数

  let some_string = String::from("yours"); // some_string 进入作用域

  some_string                              // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

  a_string  // 返回 a_string 并移出给调用的函数
}

3. 验证自动释放

为了验证当变量离开作用域时，会不会调用Drop特征中的drop方法以完成诸如释内存等清尾工作。我们需要自己定义一个类型，并为这个类型实现Drop特征。我们还没有学习如何自定义类型，也不知道特征是怎么事。我在这里简单地介绍一下，特征类似于别的语言中的接口，它定义一组行为，具体就是指一组方法，用于描述这个特征所具备的能力。这些方法，通常都是没有实现的，仅仅只是给出方法的签名，如果某个类型实现了某个特征中的这些方法，就称这个类型具备了某个特征。

首先，我们定义一个类型：

struct Wrapper(i32);

上面代码的意思是，我们定义了结构体类型Wrapper，它包含了一个i32类型的成员。但需要主要的是，Wrapper类型实例虽然在内存中的布局与i32一样，但它的实例是不能与i32实例进行互相赋值。第二步，就是为Wrapper类型实现Drop特征，因为该特征已经有标准库定义好了，它只有一个方法 drop，所以我们实现这个方法就可以了。

impl Drop for Wrapper {
    fn drop(&mut self) {
        println!("Wrapper类型的实例正在被释放...");
    }
}

至此，我们自定义了一个类型，并且为该类型实现了Drop特征，接下来我们看看，当这个类型实例的变量（所有者）离开作用域时，会发生什么？

struct Wrapper(i32);

impl Drop for Wrapper {
    fn drop(&mut self) {
        println!("Wrapper类型的实例正在被释放...");
    }
}

fn main() {
   let wrapper1 = Wrapper(11);
   let wrapper2 = wrapper1; // 所有权转移到 wrapper2, 原所有者失效
} //  wrapper2先离开作用域，由于它是值的所有者，所以还会调用drop()方法

执行cargo run运行上面的程序，终端上会输出：

Wrapper类型的实例正在被释放...

以上代码中，所有权由wrapper1转移到wrapper2，当wrapper2离开作用域时会调用drop()方法释放资源，由于wrapper1已经失效，所以没有调用drop()方法，保证了没有重复释放问题。

借用

所有权机制，把内存资源限制在其所有者内，要对已有内存资源的使用意味着所有权的转移，这就限制了内存作为资源的使用价值。为了盘活内存资源价值，Rust 引入了借用机制。

借用是目的，引用是手段。其实质是，通过引用的方式，借用原本没有所有权的值。

引用

引用，是 Rust 指针类型家族中的重要成员之一（另一个类型是祼指针，祼指针用于 Unsafe 场景，引用用于 Safe 场景），分为不可变引用(&T) 与 可变引用(&mut T)。引用不持有值的所有权，当引用离开其作用域时，它所指向的值不会被丢失。这也就是为什么把引用也叫作借用的原因。之所以有不变与不可变之别，主要是区分引用对被引用本身的使用权限，前者只能读，后者还可以修改。

与引用机制相关的主要法条如下：

在任何一段给定的时间里，你要么只能拥有一个可变引用，要么只能拥有任意数量的不可变引用。
引用总是有效。

不可变引用

不可变引用，用&T表示，其中T表示具体的类型，通过不可变引用无法去修改被引用本体的内容。

比如：

let a = 5;

// 定义了一个引用类型ref_a, 它保存的内容是变量a的内存地址，&表示取地址，在这里表示取变量a在内存中的地址。
let ref_a = &a;

可以通过ref_a来访问它所引用的本身 a，这个过程叫作解引用，解引用是通过*来完成的。比如：

// 对引用类型的变量ref_a进行解引用，具体过程是先找到ref_a中的内容（变量a的地址），
// 然后再根据该地址去找到变量a 中的内容。
let b = *ref_a;

引用跟其他指针类型一样，其内容都是另一个值的内存地址。但一个重要的区别是，引用必须要有被引用的本身，否则就失去了引用的本身意义。也就是说，在对引用进行解引用之前，引用必须要被初始化，即其中的内容必须是一个变量的内存地址，且这个变量是有效的，这就是法条中“引用总是有效”的意思。这条规则适用于所有引用，包括不可变与可变引用。

看一段代码：

fn main() {
    let ref_some: &i32;
    let some_value = *ref_some;
}

以上代码无法通过编译，会报类似如下的错误信息：

error[E0381]: used binding `ref_some` isn't initialized
 --> src/main.rs:4:22
  |
2 |     let ref_some: &i32;
  |         -------- binding declared here but left uninitialized
3 |
4 |     let some_value = *ref_some;
  |                      ^^^^^^^^^ `*ref_some` used here but it isn't initialized

由于引用不占用值的所有权，传递引用不会导致被引用资源的所有权转移，这在诸如“用一个变量调用一个函数后，继续使用原变量”这种需要多种使用资源的场景特别有用。比如：

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

    let len = calculate_length(&s1);

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

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

上面代码，通过引用&s1调用calculate_length()计算出字符串s1的长度后，由于没有发生所有权的转移，所以可以继续使用s1。这就把借用的内涵体现的淋漓尽致。

如果我们要通过不可变引用来改变被引用本身的内容是不被允许的，比如：

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

    change(&s);
}

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

上面代码将无法通过编译，会报类似如下的错误：

error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
8 |     some_string.push_str(", world");
  |     ^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
  |

其原因是，我们不能通过不可变引用&s调用push_str方法改变字符串的内容。

可变引用

可变引用，用&mut T表示，其中T表示具体的类型，关键字mut强调可变，通过可变引用可以修改被引用本体的内容。

把上面代码稍做如下修改，即可通过编译。修改后的代码：

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

    change(&mut s);
}

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

下面代码，是定义可变引用 (&T)，并进行解引用与改变内容的示例：

fn main() {
    let  mut  a = 5; // 必须标注为mut,否则无法被可变的引用
    let ref_a = &mut a;

    let b = *ref_a;
    println!("b = {b}");

    *ref_a += 100;
    println!("After changed: a= {a}");
}

另外一点要注意的是，一个变量要允许被可变地引用，其本身必须是能被修改的，这是显然的，一个不允许被修改的变量，当然通过引用也不能被修改，因为毕竟引用只是本体的一个别名罢了。

验证引用的规则

在验证引用的规则之前，我想再重复一次这个规则。规则一是，在任何一段给定的时间里，你要么只能拥有一个可变引用，要么只能拥有任意数量的不可变引用；规则二是，引用总是有效的。规则一，我们在前面已经验证过了，现在我们来验证规则二。

可以拥有任意数量的不可变引用

fn main() {
    let s = String::from("the web3");
    let r1 = &s;
    let r2 = &s;
    println!("{}", *r1);
    let r3 = &s;
    println!("{}", r2);
}

以上代码演示了可以拥有任意数量的不可变引用，可以通过编译。

在任何一段给定的时间里，只能拥有一个可变引用

fn main() {
    let mut  s = String::from("the web3");
    let r1 = &mut s;
    println!("{}", *r1);
    let r2 = &mut s;
    println!("{}", *r2);
    //println!("{}", *r1); // 放开这行代码，无法通过编译
}

以上代码，对字符串s有两个借用r1和r2，应该是违背了这个规则。但是却能正常通过编译！！这到底是哪里出问题呢？难道《物权法》的规则失效了？

其实不然，是我们没有读懂“一段给定的时间里”的内涵。因为我们的代码是顺序执行的，它所强调的给定时间主要是强调是引用定义到该引用使用这一段时间，比如上面的引用r1在定义到使用 (通过引用打印）的这段时间内，没有其他可变引用引用本体s，而使用完r1后，后面再没有通过r1就访问或修改本体，虽然r1的作用域持续到函数结束处，但编译器认为它作为引用的使命就已经结束了，而当使用r2的时候，从定义r2到使用r2这个时间段内，也只有r2引用到本体。可见，这是符合规则要求的，所以能正常通过编译。

不可变引用与可变引用不能同时存在

let mut  s = String::from("the web3");
let r1 = & s;
println!("{}", *r1);
let r2 = &s;
println!("{}", *r2);

let r3 = &mut s;
println!("{}", *r3);
//println!("{}", *r2); // 放开这行代码，无法通过编译

以代码也是可以正常通过编译，其原因跟上面的一样，当使用r3可变引用时，前面的r1、r2作用引用的使命已经结束，此时此刻，对于本体s而言，它只有一个可变引用r3，没有不可变引用。

如果放开最一行代码，将无法通过编译，因为在r3的时候，对于本体s而言，它有一个可变引用r3，还有一个不可变引用r2。

对于同一个本身的引用中，“只能有一个可变引用”以及“可变引用与不可变引用不能共存”的判断，有一个非常实用的标准，那就是：如果定义引用处至最后使用引用处之间，包含有另外的对于同一本体的引用的定义或使用，就违背了规则，否则符合规则。

如果套用数学的术语，我们可以尝试作如下定义：

设 o 为本体，对 o 的某个不可变引用 x 的定义处记为：Rs_o1_x，最后一个使用处记为：Re_o1_x；
设 o 为本体，对 o 的可变引用 x 的定义处记为：Rs_o3_x，最后一个使用处记为：Re_o3_x；
对于给定的不可变引用 i，在定义处与最后使用处的区间(Rs_o1_i,Re_o1_i)内，如果存在任意Rs_o3_x 或 Re_o3_x （其中 x<>i) ，则违背了规则；
对于给定的可变引用 i，在定义处与最后使用处的区间(Rs_o3_i,Re_o3_i)内，如果存在任意Rs_o1_x/Rs_o3_x 或 Re_o1_x/Re_o3_x （其中 x<>i)，则违背了规则；
其他情况，符合借用法的规则。

对不起，我承认我已经小题大作了！其实把定义处与最后使用处画一条线连起来，就明白了，线条没有交叉和包含就可以了。

切片

切片是引用类型的一种，它不同于普通引用把被引用本体当成一个整体使用，切片只对被引用本体的部分内容进行引用。这就是切片类型的实质！切片通常是对诸如数组、字符串等这种连续数据中的部分序列进行引用。

由于切片也是一种引用，所以引用类型所具备的所有特性、对引用约束的机制以及引用的使用场景，同样适合于切片类型。

字符串字面量的切片

let s = "hello world";

上面代码中的"hello world"就是字符串字面量，编译后会被直接编译到二进制程序中，程序加载内存后，会被存储在静态区，静态区中的内容是不能修改的。"hello world" 的类型是str，它是一个虚无的类型，它表示在静态区中的数据序列，在编译时无法这个序列有多长，因为里面的具体内容及长度取决于程序中各种字符串字面量定义情况。这有点类似于镜中花、水中月，只可意喻、不可言传，更不能直接拿来使用。要使用str，就必须通过它的引用&str，但由于静态区保存有很多内容，不能把整个内容当成一个整体引用来使用，于是就需要明确指出引用从何处开始，至何处结束，这也体现了切片是引用部分内容的实际意义。可见，引用也是解决无法使用编译期未知大小类型的万能法宝！

上面代码中的s就是一个&str类型，表示对静态内存区中某一段内容的引用。

切片类型通常是一个保存栈上的结构体，其中一个字段用来标识引用的起始位置，另一个字段用来标识要引用数据的长度。

字符串切片

字符串切片是对字符串String中保存在堆内存中的实际数据感兴趣，引用其中某一段内容。比如：

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

let hello = &s[0..5];
let world = &s[6..11];

上面的hello的类型是&str，表示一个对 String 类型的切片，具体意思是，引用字符串s在堆内存中的数据序列中从第一个位置开始至第五个位置结束这一段内容，[0..5]中0表示起始位置的索引值，5表示切片终止位置的下一个位置。

上面代码中的变量world在内存的示意图：

数组切片

数组保存着同类型的连续的元素，也可以通过切片来引用部分元素序列。

fn main() {
    let arr = [1,2,3,4,5];
    let slice_for_arr = &arr[1..4];
    println!("{}", slice_for_arr[0]);
}

上面代码中slice_for_arr 就是对数组arr的切片，它引用从第 2 个元素开始至第 4 个元素结束的序列（[2,3,4])。

这里有几个概念要作一下解释：

[T;n] 表示数组，比如[i32,3]是一个长度为 3、内部的元素的类型为 i32 的数组；
[T] 是一个虚无的概念，程序中无法直接使用，表示某个类型T的数据序列，类似于str编译期无法知道其大小
&[T] 是对[T]的切片，表示对类型T的数据序列的某个区段范围内的数据的引用，类似于&str。

悬垂引用

所有权的一物一所有者机制，解决了内存泄露问题。借用规则的第一条：“在任何一段给定的时间里，要么只能拥有一个可变引用，要么只能拥有任意数量的不可变引用”，解决了数据竞争问题。

对于“引用总是有效的”之第二条规则，我们已经验证过编译器会确保在使用引用之前必须初始化，否则无法通过编译。这也似乎解决了悬垂指针问题。

但事实是，编译器没有那么聪明，有时它无法确定一个引用是不是有效的！

对于一些简单的问题，编译器会明确给出结论，比如：

fn main() {
    let ref_i32: &i32;
    {
        let a = 5;
        ref_i32 = &a;
    }
    println!("{}",*ref_i32);
}

上面代码无法通过编译，会认为是悬垂引用。又比如：

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

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

    &s
}

上面代码也无法通过编译，同样会认为是悬垂引用，并给出了缺少生命周期参数标的错误。具体的错误信息如下：

error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`

但对于一些复杂的场景，编译器没有那么智能，它没有办法精准地跟踪一个引用与被引用本体的关系以及两者的生命周期的长短，也就没有办法确保被引用本体是不是比引用活得更长。尤其是在存在引用类型字段的结构体中，且结构体内方法又有引用类型的参数和引用类型的返回值时，对编译器来说，这种不确定性就更为明显。

基于此，Rust 提出了生命周期与标注机制，把变量的生命周期进行量化，然后让程序员去对引用进行显式的标注，用以向编译器指明函数中各种传入引用与传出引用之间、引用与被引用本体之间的关系，进而让编译去决定是否符合借用规则。

限于篇幅，不能就生命周期标注的内容作更多的介绍，后续会另开专文解读。

总结

所有权与借用是 Rust 语言的基石，本文以通俗易懂的言语，就所有权与借用相关的内容进行了全面系统地介绍。但愿，你能懂我。

欲知山中事，须问打柴人 —— 程序与内存的那点事儿

james — Thu, 30 May 2024 13:30:15 +0800

近水识鱼性，近山识鸟音。欲知山中事，须问打柴人。 —— 《增广贤文》

所有权，是 Rust 中的一个重要语言特性，也是其他特性的基石。能否理解所有权的内涵，直接影响 Rust 后续学习的进展。所有权涉及诸如内存管理等其他相关概念，了解这些相关的概念，将有利于加深对所有权概念的理解。所以有必要就相关内容作一个科普性介绍，于是就有了该文。

当然，这些属于《操作系统》中的知识，本文只是做一个简要的介绍，可能有不准确甚至错误之处，但应该不影响我们的目的 —— 掌握所有权！

1. 程序的生死轮回

1-1. 生成可执行程序

用计算机程序语言编写的源代码，通过编译器的编译、汇编、链接，生成某个特定目标机器上的可执行程序。这个可执行程序里，存放的都是“二进制”的内容，人类无法识别，专供 CPU 阅读。不同的目标系统上的可执行程序的格式也不一样，比如Windows下是PE格式，Mac Os 下是Mach O格式，Linux下是ELF格式，等等。这一步，就是无中生有。在物理层面，实实在在地生成了一个文件，只是它还没有生命。

1-2. 加载到内存

当用户运行一个程序时（比如点击桌面上的WeiChat图标），会呼叫操作系统中一个叫做加载器的神仙，他会把欲执行程序进行乾坤大挪移，即按照一定的规则把它搬送到内存中合适的位置。这还不够，还需做一系列的准备工作，比如加载程序所依赖的动态库等等。然后会把控制权移交给被加载的程序。这个时候，程序变变身成进程，程序就有了生命。

1-3. 开始运行

被加载程序接管控制权后，会从main开始执行代码，我们的程序就正式开始运行了。程序的运行，其实就是CPU反复地读写内存的过程。CPU 根据指令寄存器的内容，从内存中的代码段中读取具体的指令，然后执行指令，在指令的执行过程中会对内存进行各种读写操作。就这样周而复始、生生不息，直到程序运行完毕或者用户显式关闭。当然，运行过程中遇到了异常也会被强行中断。

1-4. 打个比方

上面的这个过程，我想用厨师做菜的过程来来尝试做进一步的解释，虽然不是太恰当，但愿能有所帮助。

厨房里有一个工作长板，长板上面摆放一些碗，碗里面放有准备好的各种小食材和油盐酱醋等调料等。厨房隔壁有一间很大的储藏间，用来存放各种食材等源材料。假设每一道菜肴都会有两张纸条，一张用以说明制作该菜肴的工艺流程，指导厨师应该怎么做，比如第一步拿什么菜，第二步洗菜，第三步是切菜，等等；别一张，用以说明所需食材的位置，有的就放在厨房的碗中，有的放在储藏间的某层架子上。另外，为厨师配有一个伙计，助手听从厨师的使唤，在储藏间与厨房之间跑腿。

炒菜时，厨师先会拿到该道菜的两条纸条，按照纸条上的流程一步一步的操作。需要食材时，按照纸条去找。如果食材放在厨房内部的，他自己去拿，如果是放在储藏间，就使唤伙计去跑脚。

这里的厨师就 CPU，厨房长板上的碗就是内存中的栈，储藏间就是内存中的堆。纸条本身就是可执行程序，当厨师拿到纸条的时候，就代表程序运行起来了。

2. 内存管理

程序加载到内存后，操作系统会为其创建一个对应的进程，并以进程为单位在内存中分配了独立的进程空间。这是一个封闭的空间，该程序中的指令无法访问进程空间外的其他内存空间。进程空间大致分为代码区、常量区、全局静态区、栈区、堆区。

2-1. 内存的分区

代码区

主要存放程序的可执行指令、函数符号表等信息，CPU 根据这些指令及符号表进行相应的操作。

栈区

程序运行的实际“练兵场”，里面存放局部变量、形参、返回值等。

堆区

是供程序在运行过程按需要使用的区域，在需要时申请，不需要时释放。申请堆内存，是指 CPU 根据代码区中的分配指令（malloc对应的机器指令)，在运行的时候进行的；释放堆内存，是根据释放指令 (free对应的机器指令)，也是在运行的时候进行的。

其他的区

这些区的叫法可能不太一样，主要用来存放只读的数据，比如常量字符串、全局或静态变量等内容。这些内容，通常是在编译的时候就写死在可执行程序文件里面的。

程序加载到内存时，操作系统会为进程分配一个栈空间和一个堆空间。栈主要是用来运行函数，堆用来保存运行时按需求分配的内容。栈与堆的大小都是有限的，这也就是调用一个没有返回条件的递归函数时，会导致耗尽栈空间，而被操作系统终止的原因。

这两个空间，一开始可以认为是空白无瑕的，里面几乎没有数据。CPU 从 代码区 中读取指令，若是遇到与内存操作相关的指令，要么对栈、要么对堆，做各种读写操作，比如分配内存或修其中的内容，经过这种一系列的操作后，这两个空间中的内容就会各有千秋。

2-2. 栈与函数调用

可以把这个第一次分配的栈看作是整个程序的最外层栈，main函数就在这个栈空间中运行的，函数中声明的基本类型的变量，会存放在这个栈空间里。每一个函数被运行时，都会分配一个专门的函数栈，为了管理这些栈，有两个寄存器（栈底寄存器、栈顶寄存器）分别指向栈的底部和顶部。

比如：

fn main() {
    let a: i32 = 88;
    let b: i32 = 12;
}

CPU 会在栈空间中分配一个 4 个字节 (i32) 空间，将其赋值为88，然后再分配 4 个字节 (i32) 的空间，将其赋值为12。每进行一次栈空间的分配，都会同时修改栈顶寄存器（SP）的内容，让栈顶指针始终指向栈顶，上面代码执行完后时，SP指向b所代表的内容。

当我们在一个函数内部，调用另一个函数时，会开辟一个新的栈空间以供这个被调用程序使用，这就是所谓的函数调用栈。

比如：

fn add(a: i32, b: i32) -> i32 {
{
    a + b
}

fn main() {
    let a: i32 = 88;
    let b: i32 = 12;

    let c = add(a,b);
    println!("a + b = {}", c);
}

当调用 add函数时，首先会保存调用方的（比如main函数对应的栈等）现场信息，然后在当前栈顶 push 一个新的栈。在新的栈空间里，会分配相应的空间用于放置参数对应的内容，接着调用加法指令完成加法操作，接着把结果返回到调用方。返回的过程，其实就是把当前函数 (add函数) 栈 pop 出去，再恢复现场信息，比如让栈底/栈顶寄存器分别指向原调用函数 (main) 的函数栈。

可见，对于栈空间的分配与释放过程，是由栈底与栈顶寄存器中的内容决定的，它是一个自动的过程。程序是无法显式更改其流程的。栈空间的分配与释放无非是两个寄存器内容的改变而已。所以，我们不用关心栈空间的分配与释放问题！

2-3. 指针类型

指针类型的变量，跟其他变量一样，本身都是内存中的一个位置，CPU 也是通过变量的名称找到这个位置。但是，这个位置对应的空间上存放的内容是描述另一个内存空间的位置信息，即内存的地址。

之所以要专门介绍指针类型，是因为它是程序与堆内存交互的媒介，程序总是通过先访问保存在栈上指针，然后根据指针中存放的地址再去访问堆上空间。

当然，指针类型的变量本身，既可以放在栈上，也可以放在堆上；指针类型变量中存放的值，既可以是栈上的内存地址，也可以是堆上的内存地址。只是大多数情况，指针变量本身存放在栈上，其存放的内容是堆上的空间地址。

2-4. 堆空间

堆空间是程序在运行的时候按需使用到的那一部分内存，相当于“炒菜”中的那个大房间。当 CPU 读取到向堆分配内存的指令时，就会动态地分配一块堆内存空间。为了使用这一块分配的堆内存，需要记住这块堆内存的起始地址，所以，在分配完堆内存的同时，会返回它的起始地址，这个起始地址会用一个变量保存起来以备后用。这个变量就是一个经典的指针，通常是保存在栈空间中的。

可见，要访问堆上的内容，要通过栈上指针类型的变量进行中转。CPU 对内存的视角，从这个意义上讲，只限制在栈内，栈才是程序运行的主戏台，堆顶多只是一个幕后者。

与栈不同的是，堆空间的管理是离散的，分配堆内存前，无法预知其具体的地址。由于缺少栈空间管理自动性，所以必须的记住分配的堆内存地址，用以在不需要使用时，显式地释放堆内存。

如果对堆上分配的内存空间管理不善，就会出现如下 3 个主要问题：

忘记释放不再需要使用的堆空间，导致内存泄露问题；
当多个指针变量指向同一个堆地址空间时，通过其中一个指针变量释放后，再通过其他指针变量使用，会导致悬垂指针（野指针）问题；
当多个指针变量指向同一个堆地址空间时，通过多个指针变量重复释放问题。

2-5. 要解决的问题

内存管理的核心是对堆内存的管理，其要解决的核心问题就是，堆内存可能出现的上述 3 个问题，即内存泄露、悬垂指针、重复释放。寻求对这三个问题的解决方案，是作为一门编程语言的第一要务。业界已有两种主流的解决方案，一种是手动管理方式(比如C/C++)，另一种是垃圾回收管理方式(比如Golang/Java)。不过，现在出现了第三种方案，那就是 Rust 提出的所有权机制 !

3. 总结

本文就一个程序从源代码到运行的整个过程进行了系统地介绍，重点讨论了内存中栈与堆在程序运行中各自充当的角色以及两者的区别。栈才是程序运行的主戏台，要访问堆上的内容，要通过栈上指针类型的变量进行中转。栈内存的管理是自动的，堆是内存管理的重点与难点。要做好内存管理，其实质就是要解决可能出现的内存泄露、悬垂指针、重复释放等问题。继手动管理、垃圾回收的内存管理方式后，Rust 中创造性地提出了所有权机制。

九层之台，起于累土 —— Rust 语言基础

james — Sun, 26 May 2024 20:56:59 +0800

合抱之木，生于毫末；九层之台，起于累土；千里之行，始于足下。

——《道德经》第六十四章

本文介绍 Rust 语言的基础内容，也是任何一门计算机语言中的通用的部分。其旨在让你快速上手 Rust 的编程，主要包括的内容有：变量、数据类型、函数、程序控制流等。学完这些内容后，应能掌握面向过程式（OOP）编程，能较熟练地编写出用于解决诸如查找与排序等数据结构与算法相关的问题。

1. 变量与常量

1-1. 变量

几乎在我们所接触的所有语言中都存在变量这个概念，在 Rust 中的变量，基本上等同于其他语言中的定义。变量可以理解为一个名字，这个名字代表着内存中的某一块内存。内存中的内容当然会变化，这也是变字所表达的最明显含义。当然，对于用于这个名字的标识符范围也是有规则约束的，其规则遵同其他语言的通用规则，比如：不能用数字开头、不能使用诸如if之类的语言保留字等等。

闲话少说，让我们直奔主题吧！

定义变量

let some_name: data_type = some_value;

上面示例代码，是一个完整的变量定义语句。它表示定义了一个名为some_type的变量，它的类型为data_type，其对应的值为some_value。 Rust 的编译器很智能，大部分情况下，可以省略data_type，其类型可以由右边的值自动推断出正确的类型。

这就完了，发现与其他语言没有什么区别。但 Rust 还有点不一样，接下来我们来说说它的不同之处吧。

变量定义在 Rust 中有一个专门的叫法：变量绑定。
所有的变量默认是不可变的（这也可能是绑定的原因吧）。
要想让变量绑定的值能改变，在定义的时候，必须在变量名的前面显式地标注 mut关键字。

看一段代码：

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

运行上面的程序，会得到类似如下的编译错误：

2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {}", x);
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error

上面的错误指出错误的原因是 cannot assign twice to immutable variable x（不能对不可变变量二次赋值），因为我们尝试给不可变的 x 变量赋值为第二个值。

我们只需在上面的变量x前面加上mut关键字，程序就可以正常通过编译并输出预期的结果。

let mut x = 5;

变量的遮蔽

意思就是，第一个变量可以被第二个同名的变量所遮蔽（shadow），这意味着当我们使用变量时我们看到的会是第二个变量的值。变量遮蔽后，原先的那个被遮蔽的变量失效（对于后续的代码不可见）。我们可以通过使用相同的变量名并重复使用 let 关键字来遮蔽变量，如下所示：

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

需要注意的是，新变量与被遮蔽的变量之间的关系，仅仅是名字在字面上一样，仅此而已！这就意味着，新变量可以有完全不同的类型，比如：

let x = 5; //x 的类型由编译器自动推导为 `i32`
let x = "new value"; // x 的类型由编译器自动推导为 `&str`

1-2. 常量

常量（constant）是绑定到一个常量名且不允许更改的值。但在 Rust 中，变量默认也是不可变的，那为什么还需要引入常量的概念呢？两者间的差别有：

常量不允许使用 mut。
常量在定义（绑定）的时候，必须要显式初始化值，没有默认值。
常量在定义（绑定）的时候，必须要显式地指定数据类型，编译器不会进行类型推导。
常量可以在任意作用域内声明，包括全局作用域。
常量只能设置为常量表达式，而不能是函数调用的结果或是只能在运行时计算得到的值。

下面是一个定义常量的示例代码：

const DAY_IN_WEEK: u8 = 7; // Rust 常量的命名约定是全部字母都使用大写，并使用下划线分隔单词。

2. 数据类型的本质

运行程序所需要的数据，一般存储在内存中。内存元器件中的高电平与低电平的物理状态，被解读为0和1的位（bit），8 个位（bit）为一个字节（byte）。这里的位、字节都是一种数据类型。但仅仅用位与字节这种原始的类型，不足以（不便于）刻画我们的业务，于是就出现了诸如表示数字的整型、表示一连串字符的字符串 等等用于特定场景的有点业务味道的类型。不过，这种类型，通常是在机器架构层面提供的。作为一种语言的编译器层面，也当然会有对应之物。当然，进一步，语言层面，往往会提供更多的类型，以满足使该语言对业务建模的需求，比如，结构体、枚举、类等等。

每一个数据类型，都规定了该类型所占用的长度，比如在 32 位系统中，整型通常用占用 4 个字节（32 位），布尔类型占用 1 个字节（8 位）。即使整数1只需要一个位来表示，也要占用 32 位。

数据类型是对数据的抽象，不同的类型，其抽象的粒度不一样。数据类型，为 CPU 解读内存数据提供了共识。当 CPU 通过变量（内存地址的别名）去访问内存时，可以根据类型信息，知道把从内存位置开始到什么地方结束的这一块内存内容当成一个整体去解读。这个，对指针类型尤为明显，比如指针类型的解指针和作自增操作。

内存中原本只是0101...这种毫无意义的物件，这是一个混沌的世界。"神说要有光，于是就有了光"！这个神，肯定是我们道家中的神仙，他“道法自然”，点化万物，0101...立马变成了各种生机勃勃的精灵，有红楼里轮回三生三世的绛珠仙草，有九龙潭的鳌、羚、鹰、鱼、虾、蛇，有沧海畔那“蝉眼龟形脚似蛛，未曾正面向人趋”的螃蠏侠，有... 于是就有了五色缤纷的世界，当然也有了险恶的江湖。对不起，扯远了。

3. 基本类型

3-1. 整数类型

整数是没有小数部分的数字， i32 类型，表示有符号的 32 位整数（i 是英文单词 integer 的首字母，与之相反的是 u，代表无符号 unsigned 类型）。下表显示了 Rust 中的内置的整数类型：

类型定义的形式统一为：有无符号 + 类型大小 (位数)。无符号数表示数字只能取正数和0，而有符号则表示数字可以取正数、负数还有0。就像在纸上写数字一样：当要强调符号时，数字前面可以带上正号或负号；然而，当很明显确定数字为正数时，就不需要加上正号了。有符号数字以补码形式存储。

每个有符号类型规定的数字范围是 -(2^n - 1) ~ 2^n - 1 - 1，其中 n 是该定义形式的位长度。因此 i8 可存储数字范围是 -(2^7) ~ 2^7 - 1，即 -128 ~ 127。无符号类型可以存储的数字范围是 0 ~ 2^n - 1，所以 u8 能够存储的数字为 0 ~ 2^8 - 1 ，即 0 ~ 255。

此外，isize 和 usize 类型取决于程序运行的计算机 CPU 类型：若 CPU 是 32 位的，则这两个类型是 32 位的，同理，若 CPU 是 64 位，那么它们则是 64 位。

整形字面量可以用下表的形式书写：

这么多类型，有没有一个简单的使用准则？答案是肯定的，Rust 整型默认使用 i32，例如 let i = 1，那 i 就是 i32 类型，因此你可以首选它，同时该类型也往往是性能最好的。isize 和 usize 的主要应用场景是用作集合的索引。

3-2. 浮点数类型

浮点数（floating-point number）是带有小数点的数字，在 Rust 中浮点类型（简称浮点型）数字也有两种基本类型。Rust 的浮点型是 f32 和 f64，它们的大小分别为 32 位和 64 位。默认浮点类型是 f64，因为在现代的 CPU 中它的速度与 f32 的几乎相同，但精度更高。所有浮点型都是有符号的。下面是一个演示浮点数的示例：

fn main() {
    let x = 2.0; // 默认类型为： f64

    let y: f32 = 3.0; // f32
}

浮点数按照 IEEE-754 标准表示。f32 类型是单精度浮点型，f64 为双精度浮点型。

Rust 的所有数字类型都支持基本数学运算：加法、减法、乘法、除法和取模运算。整数除法会向下取整。下面代码演示了各使用一条 let 语句来说明相应数字运算的用法：

fn main() {
    // addition
    let sum = 5 + 10;

    // subtraction
    let difference = 95.5 - 4.3;

    // multiplication
    let product = 4 * 30;

    // division
    let quotient = 56.7 / 32.2;
    let floored = 2 / 3; // Results in 0

    // remainder
    let remainder = 43 % 5;
}

3-3. 字符类型

直接看代码：

let c = 'z';
let z = 'ℤ';
let heart_eyed_cat = '😻';

有几点需要注意：

声明的 char 字面量采用单引号括起来，这与字符串字面量不同，字符串字面量是用双引号括起来。
Rust 的字符类型大小为 4 个字节，表示的是一个 Unicode 标量值，这意味着它可以表示的远远不止是 ASCII。标音字母，中文/日文/韩文的文字，emoji，还有零宽空格 (zero width space) 在 Rust 中都是合法的字符类型。

3-4. 布尔类型

Rust 中的布尔类型有两个可能的值：true 和 false，布尔值占用内存的大小为 1 个字节：

fn main() {
    let t = true;

    let f: bool = false; // 使用类型标注,显式指定f的类型

    if f {
        println!("这是段毫无意义的代码");
    }
}

使用布尔类型的场景主要在于流程控制，例如上述代码的中的 if 就是其中之一。

4. 复合类型

复合类型（compound type）可以将多个值组合成一个类型。Rust 有两种基本的复合类型：元组（tuple） 和 数组（array）。

4-1. 元组

元组是将多种类型的多个值组合到一个复合类型中的一种基本方式。元组的长度是固定的：声明后，它们就无法增长或缩小。

我们通过在小括号内写入以逗号分隔的值列表来创建一个元组。元组中的每个位置都有一个类型，并且元组中不同值的类型不要求是相同的。

let tup: (i32, f64, u8) = (500, 6.4, 1); // 定义元组的示例代码

可以通过下标索引访问：

println!("1st number is {}", tup.0); // 0表示第一个元素，1表示第二个元素...

可以解构：

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

没有任何值的元组是一种特殊的类型，只有一个值，也写成 ()。该类型被称为单元类型（unit type），该值被称为单元值（unit value）。如果表达式不返回任何其他值，就隐式地返回单元值。

// 单元类型 （）
// 单元类型在Rust中是非常重要的类型，如果表达式不返回任何其他值，就隐式地返回单元值，
// 如没有返回值的函数或者作用域

let a: () = {};
fn return_tuple() {}
let func: () = return_tuple();
assert_eq!(a, func);

4.2 数组

数组的具体定义很简单：将多个类型相同的元素依次组合在一起，就是一个数组。数组的三要素：

长度固定，一经定义就不可以改变
元素必须有相同的类型
依次线性排列

一个简单的示例：

// 通过索引来访问或者修改数组中的元素
let arr = [1, 2, 3, 4, 5]; // 编译器自动推导arr的类型为[i32;5] 数组
let mut arr1 = [0, 0, 0, 0, 0];
arr1[0] = 100;
println!("{:?}", arr1); // [100, 0, 0, 0, 0]

数组的正式类型： [元素的类型; 数组元素的总长度]，比如：

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

可以使用下面的语法初始化一个某个值重复出现 N 次的数组：

let a = [3; 5]; // a 数组包含 5 个元素，这些元素的初始化值为 3

访问数组时，索引的范围：[0, 数组长度 N)，即从 0 开始到长度 N-1。如果越界访问，会导致 Rust 运行时错误。

至此，数组就介绍完了，最后有两个注意的点：

数组是存储在栈上
数组的长度也是类型的一部分，[u8; 3] 和 [u8; 4] 是不同的类型。

5. 函数

函数其实也是一种数据类型，函数名称跟其他的变量名一样会关联到内存中代码区的某一个地方，代码将从这个地方开始执行代码。函数除了有名称，还有对应的具体类型，即函数签名，用来描述调用函数需要需要传入的数据，即参数 及 函数运行结束后返回的数据类型 等信息。

Rust 函数签名如下：

fn func_name1(param1: type1, parm2: type2,...) -> return_type //完整函数的签名

fn func_name2() -> return_type // 无参数函数的签名

fn func_name3(param: type1) // 无返回值函数的签名，默认返回值的类型为 ()

fn func_name4() // 无参数且无返回值函数的签名

在函数签名后面加上一对大括号，写在这对括号内的代码叫做函数体。总体来说，Rust 函数与其他 C 系语言（比如 C/C++/Java 等）是类似的。上一段代码：

// 1 函数定义
// 1.1 没有参数和返回值的函数
fn foo() {
    println!("foo")
}

// 1.2 有参数和返回值的函数

fn bar(s: &str) -> String {
    String::from(s)
}

// 1.3 参数类型必须显式声明，比如引用或者可变性

fn foobar(mut s: &str) -> &str {
    s = "rust";
    s
}

// 2 函数调用

foo();
bar("Rust");
foobar("go");

// 3 函数作为参数

fn a(f: fn() -> u32) -> u32 {
    let value = f();

    value
}

fn b() -> u32 {
    42
}

// 把函数作为参传给另一个函数

a(b);

有一个比较特殊的地方需要注意一下，就是函数返回值如果是表达式，可以不用显式的加上return关键字，代码末尾也不用加上;号，比如上面的函数b()中返库的42。这种便捷技巧，请一定要掌握！在 Rust 中实践中应用得相当广泛。 Rust 把有语句与表达式之分，两者的区别，请记住一句话：“语句用来指示干什么工作，本身不返回值；否则就是表达式“。比如 let apple = 5 就是指示做绑定操作，并没有返回值，所以它是语句；42+1、88，没有指示干什么操作，都是表达式。

最后一点，就是如果函数没有显式返回，其返回的类型是()，类似于 C 语言中的void，表示什么都没有。

6. 程序控制流

6-1. if 表达式

if 表达式允许根据条件执行不同的代码分支，跟其他语言没有什么区别。看一段代码：

fn main() {
    let number = 6;

    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");
    }
}

条件必须为 bool 类型，这点与 C 语言是不一样的。

在 let 语句中使用 if

因为 if 是一个表达式，我们可以在 let 语句的右侧使用它来将结果赋值给一个变量，如下代码：

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

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

number 变量将会绑定到表示 if 表达式结果的值上。

6-2. loop 循环

loop用来实现一个无限循环，可以使用 break 语句在任何时候退出一个循环，还可以使用 continue 跳过循环体的剩余部分并开始下一轮循环。如下面代码：

fn main() {
    let mut count = 0u32;

    println!("Let's count until infinity!");

    // 无限循环
    loop {
        count += 1;

        if count == 3 {
            println!("three");

            // 跳过这次迭代的剩下内容
            continue;
        }

        println!("{}", count);

        if count == 5 {
            println!("OK, that's enough");

            // 退出循环
            break;
        }
    }
}

嵌套循环和标签

在处理嵌套循环的时候可以 break 或 continue 外层循环。在这类情形中，循环必须用一些 'label（标签）来注明，并且标签必须传递给 break/continue 语句。

#![allow(unreachable_code)]

fn main() {
    'outer: loop {
        println!("Entered the outer loop");

        'inner: loop {
            println!("Entered the inner loop");

            // 这只是中断内部的循环
            //break;

            // 这会中断外层循环
            break 'outer;
        }

        println!("This point will never be reached");
    }

    println!("Exited the outer loop");
}

从 loop 循环中返回

可以从loop中返回值：将该值放在 break 之后，它就会被 loop 表达式返回。

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

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

    assert_eq!(result, 20);
}

6-3. while 循环

while 关键字可以用作当型循环（当条件满足时循环）。

fn main() {
    let mut x = 0; // 计数器变量
    while x < 5 {
        println!("x is {}", x);
        x += 1;
    }
}

6-4. for 循环

for 循环是 Rust 的大杀器，相比其他的两种，在性能与安全方面都具有优势。for事实上只是迭代器的一种语法糖，在这里不便于全面介绍清楚，在后面讨论迭代器的时修改再做详尽介绍。在此，仅跟出几种常用的范例。

使用 for 遍历区间

for in 结构可以遍历一个 Iterator（迭代器）。创建迭代器的一个最简单的方法是使用区间标记 a..b。这会生成从 a（包含此值）到 b（不含此值）的，步长为 1 的一系列值。

fn main() {
    for i in 1..6 {
        println!("{}", i);
    }
}

以上代码循环输出一个从 1 到 5 的序列。或者，可以使用 a..=b 表示两端都包含在内的范围。上面的代码可以写成：

fn main() {
    for i in 1..=5 {
        println!("{}", i);
    }
}

使用 for 遍历集合

用 for 遍历集合，其实质是遍历一个 Iterator（迭代器），运行时执行的是迭代器的相关方法。细节后面讨论迭代器时再说。

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

6.5 while vs for

看两段完成同样功能代码：

while 实现的

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index = index + 1;
    }
}

代码对数组中的元素进行计数。它从索引 0 开始，并接着循环直到遇到数组的最后一个索引（这时，index < 5 不再为真）。这种通过索引访问元素的方式，由于越界会 panic，所以每一次循环都会检查index的值，这就影响了性能。

for 实现的

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}

可以看出，for 并不会使用索引去访问数组，因此更安全也更简洁，同时避免运行时的边界检查，性能更高。

总结

本文就语言的通用部分作了较系统的介绍，一些与 Rust 固有特色相关的概念未作深入探究。阅读完本文，读者应该掌握了 Rust 中的“十八般兵器”的基本使用。

与君初相识，犹如故人归 —— 初识 Rust

james — Fri, 24 May 2024 10:49:41 +0800

与君初相识，犹如故人归。天涯明月新，朝暮最相思。 —— 杜牧《会友》

友情提示：本文项目中的内容直接来自于《The Rust Programming Language》中第 1 章与第 2 章（部分内容由 AI 翻译），可能冗长乏味，建议慎重阅读。若有未详尽或不准确之处，请直接阅读原书之内容。

在上一章里，介绍了 Rust 的一些基本情况，也搭建好了 Rust 的开发环境，但只是“空山不见人，但闻人语响”。现在，是时候约 Rust 出来见一面了！本文会手把手带你编写三个小项目，并对其中的代码进行细致地解读。有些内容不求你甚解，权当与 Rust 打个照面、混个面熟，也算是与 Rust 相识了。

“与君初相识，犹如故人归”，自然甚好；要是“我断不思量，你莫思量我”，请不要原谅我！

那就开始吧！

Hello,World!

作为程序界的惯例，我们选择从这个经典的程序开始，算是与 Rust 打一个招呼吧。

1. 创建项目目录

对 Rust 来说，你的代码在哪里并不重要，但还是建议为 Rust 类型项目专门创建一个目录。我们建议在你的主目录中创建一个项目目录并将所有项目保存在那里。

打开终端并输入以下命令以创建项目目录和“Hello, world!”目录项目目录中的项目。

对于 Linux、macOS 和 PowerShell，请输入：

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

对于 Windows CMD，输入：

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

2.编写和运行 Rust 程序

接下来，创建一个新的源文件并将其命名为 main.rs。Rust 文件总是以.rs 扩展名结尾。如果您在文件名中使用多个单词，请使用下划线分隔它们。例如，使用 hello_world.rs 而不是 helloworld.rs。

现在打开您刚刚创建的 main.rs 文件并输入如下代码：

文件名：main.rs

fn main() {
    println!("Hello, world!");
}

保存文件并返回终端窗口。在 Linux 或 macOS 上，输入以下命令来编译和运行文件：

$ rustc main.rs
$ ./main
Hello, world!

在 Windows 上，输入命令.\main.exe 而不是./main：

> rustc main.rs
> .\main.exe
Hello, world!

无论您的操作系统是什么，字符串 Hello, world! 都应该打印到终端。如果您没有看到此输出，请参阅安装部分的“疑难解答”部分以获得帮助。

如果 Hello, world! 打印出来了，恭喜！你已经正式编写了一个 Rust 程序。这让你成为 Rust 程序员——欢迎！

3. Rust 程序剖析

让我们详细回顾一下刚刚在您的“Hello, world!”中发生的事情。程序。这是拼图的第一部分：

fn main() {
}

这些行在 Rust 中定义了一个函数。这个 main 函数很特别：它总是在每个可执行的 Rust 程序中运行的第一个代码。第一行声明了一个名为的函数 main，它没有参数并且不返回任何内容。如果有参数，它们将放在()内。

另外，请注意，函数体用{}括起来，将左大括号与函数声明放在同一行是一种很好的风格，在两者之间添加一个空格。

如果你想在 Rust 项目中坚持标准风格，你可以使用一个名为的自动格式化工具rustfmt来格式化你的代码为特定风格。

main 函数内部是以下代码：

println!("Hello, world!");

这一行完成了这个小程序中的所有工作：它将文本打印到屏幕上。这里有四个重要的细节需要注意。

首先，Rust 风格是缩进四个空格，而不是制表符。

其次，println! 是 Rust 宏。如果它改为调用一个函数，它将被输入为println（不带!）。

第三，你看到了"Hello, world!"字符串。我们将此字符串作为参数传递给println!，然后将字符串打印到屏幕上。

第四，我们用分号 ( ;) 结束这一行，这表示这个表达式已经结束，下一个表达式已准备好开始。大多数 Rust 代码行都以分号结尾。

4. 编译和运行是分开的步骤

您刚刚运行了一个新创建的程序，因此让我们检查该过程中的每个步骤。

在运行 Rust 程序之前，您必须使用 Rust 编译器通过输入rustc命令并将源文件的名称传递给它来编译它，如下所示：

$ rustc main.rs

如果您有 C 或 C++ 背景，您会注意到这类似于 gcc 或者 clang。编译成功后，Rust 会输出一个二进制可执行文件。

在 Linux、macOS 和 Windows 上的 PowerShell 上，您可以通过 ls 在 shell 中输入命令来查看可执行文件。在 Linux 和 macOS 上，您将看到两个文件。使用 Windows 上的 PowerShell，您将看到与使用 CMD 相同的三个文件。

$ ls
main  main.rs

在 Windows 上使用 CMD，您将输入以下内容：

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

这显示了带有.rs 扩展名的源代码文件、可执行文件（在 Windows 上为 main.exe，但在所有其他平台上为 main），以及在使用 Windows 时，包含带有.pdb 扩展名的调试信息的文件。从这里，您运行 main 或 main.exe 文件，如下所示：

$ ./main # or .\main.exe on Windows

执行上面的命令，此行将打印Hello, world!到您的终端。

如果您更熟悉动态语言，例如 Ruby、Python 或 JavaScript，您可能不习惯将程序作为单独的步骤进行编译和运行。Rust 是一种提前编译的语言，这意味着您可以编译程序并将可执行文件提供给其他人，即使没有安装 Rust，他们也可以运行它。如果您给某人一个.rb、.py 或 .js 文件，他们需要（分别）安装一个 Ruby、Python 或 JavaScript 实现。但是在那些语言中，您只需要一个命令来编译和运行您的程序。一切都是语言设计的权衡。

对于简单的程序来说，只用rustc编译就可以了，但是随着项目的增长，您将需要管理所有选项并轻松共享您的代码。接下来，我们将向您介绍 Cargo 工具，它将帮助您编写真实的 Rust 程序。

Hello,Cargo!

Cargo 是 Rust 的构建系统和包管理器。大多数 Rustaceans 使用这个工具来管理他们的 Rust 项目，因为 Cargo 会为您处理很多任务，例如构建代码、下载代码所依赖的库以及构建这些库。

最简单的 Rust 程序，就像我们目前所写的一样，没有任何依赖关系。因此，如果我们构建了“Hello, world!”与 Cargo 合作的项目，它只会使用 Cargo 中处理构建代码的部分。当您编写更复杂的 Rust 程序时，您将添加依赖项，如果您使用 Cargo 启动项目，添加依赖项将更容易做到。

正常情况下，Cargo 会随 Rust 一起安装。如果您通过其他方式安装了 Rust，请通过在终端中输入以下内容来检查是否安装了 Cargo：

$ cargo --version

如果你看到一个版本号，你有它！如果您看到错误，例如 command not found，请查看您的安装方法的文档以确定如何单独安装 Cargo。

1. 使用 Cargo 创建项目

让我们使用 Cargo 创建一个新项目，看看它与我们原来的“Hello, world!”有何不同。导航回您的项目目录（或您决定存储代码的任何位置）。然后，在任何操作系统上，运行以下命令：

$ cargo new hello_cargo
$ cd hello_cargo

第一个命令创建了一个名为hello_cargo的新目录。由于我们将项目命名为hello_cargo，Cargo 在同名目录中创建其文件。

进入hello_cargo目录并列出文件。您会看到 Cargo 为我们生成了两个文件和一个目录：一个Cargo.toml文件和一个 src目录，其中包含一个main.rs文件。

$ tree -L 2
.
├── Cargo.toml
└── src
    └── main.rs

其中Cargo.toml的内容，类似如下清单：

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

[dependencies]

第一行的[package]，是一个节标题，指示以下语句正在配置包。随着我们向此文件添加更多信息，我们将添加其他部分。

接下来的三行设置，是 Cargo 编译程序所需的配置信息：名称、版本和要使用的 Rust 版本。

最后一行，[dependencies]，是您列出项目的任何依赖项的部分的开始。在 Rust 中，代码包被称为 crates。这个项目我们不需要任何其他 crate，但我们将在下一个“猜数游戏”项目中使用。现在打开 src/main.rs 看看：

fn main() {
    println!("Hello, world!");
}

记得把代码中的"Hello, world!"，改成"Hello, Cargo!"

到目前为止，我们之前的项目与 Cargo 生成的项目的不同之处在于 Cargo 将代码放在了 src 目录中，且在项目根目录中有一个Cargo.toml配置文件。

Cargo 希望您的源文件位于 src 目录中。项目根目录仅用于存放 README文件、许可证信息、配置文件以及与您的代码无关的任何其他内容。

如果您启动了一个不使用 Cargo 的项目，就像我们使用“Hello, world!”所做的那样项目，您可以将其转换为使用 Cargo 的项目。方法是，将项目代码移动到 src 目录并创建一个适当的 Cargo.toml 文件。

2. 建立和运行项目

在 hello_cargo 目录中，通过输入以下命令构建项目：

$ cargo build
   Compiling hello_cargo v0.1.0 (/Users/mjsong/Desktop/rust_study/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.68s

此命令在target/debug/hello_cargo（或 Windows 上的target\debug\hello_cargo.exe）而不是在您的当前目录中创建一个可执行文件。

 $ tree -L 2
.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
    ├── CACHEDIR.TAG
    └── debug

您可以使用以下命令运行可执行文件：

$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
Hello, Cargo!

Cargo 还会在项目根目录下创建一个Cargo.lock文件，该文件跟踪项目中依赖项的确切版本。您永远不需要手动更改此文件，Cargo 为您自动管理其中的内容。

我们刚刚构建了一个项目 cargo build 并使用运行它 ./target/debug/hello_cargo，但我们也可以使用它 cargo run 来编译代码，然后在一个命令中运行生成的可执行文件：

$ cargo run
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/hello_cargo`
Hello, Cargo!

Cargo 还提供了一个名为 cargo check. 此命令快速检查您的代码以确保它可以编译但不会生成可执行文件：

$ cargo check
    Checking hello_cargo v0.1.0 (/Users/mjsong/Desktop/rust_study/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s

为什么你不想要一个可执行文件？通常，cargo check比cargo build快得多，因为它跳过了生成可执行文件的步骤。如果您在编写代码时不断检查您的工作，使用cargo check将加快该过程！因此，定期cargo check确保程序可以编译是一个推荐的做法。

让我们回顾一下到目前为止我们对 Cargo 的了解：

我们可以使用cargo build，编译程序。
我们可以使用cargo run，编译并运行程序。
我们可以使用cargo check，在不生成二进制文件的情况下构建一个项目。
Cargo 没有将构建结果保存在与我们的代码相同的目录中，而是将其存储在target/debug目录中。
使用 Cargo 的另一个优点是，无论您使用哪种操作系统，命令都是相同的。因此，我们将不再提供针对 Linux 和 macOS 与 Windows 的具体说明。

3. 为发布而构建

当您的项目最终准备好发布时，您可以使用 cargo build --release 优化来编译它。此命令将在target/release而不是target/debug中创建可执行文件。优化使您的 Rust 代码运行得更快，但打开它们会延长程序编译所需的时间。这就是为什么有两种不同的配置文件的原因：一个用于开发，当您想要快速且经常重建时，另一个用于构建您将提供给用户的最终程序。如果您要对代码的运行时间进行基准测试，请务必使用 cargo build --release 构建项目。

4. Cargo 作为公约

对于简单的项目，Cargo 并没有提供比rustc更多的价值，但是随着你的程序变得更加复杂，它会证明它的价值。对于由多个 crate 组成的复杂项目，让 Cargo 协调构建要容易得多。

尽管这个 hello_cargo 项目很简单，但它现在使用了很多你将在 Rust 职业生涯中使用的真正工具。事实上，要处理任何现有项目，您可以使用以下命令使用 Git 签出代码，切换到该项目的目录并构建：

$ git clone example.org/someproject
$ cd someproject
$ cargo build

猜数游戏

项目的需求：程序将生成一个介于 1 和 100 之间的随机整数。然后它会提示玩家输入猜测。输入猜测值后，程序将指示猜测值是过低还是过高。如果猜对了，游戏将打印祝贺信息并退出。

1. 新建项目

我们同样采用 Cargo 创建与管理项目，执行如下命令：

$ cargo new guessing_game
$ cd guessing_game

项目已经创建好了，其效果跟上一个项目一样，如果编译运行会在终端打印名称“Hello,world!"，我们将在基础上进行迭代，一步步地完成我们的需求。但作为一个习惯，在继续新代码之前，我们要用 cargo check 验证一下之前的代码是否有问题。

2. 处理猜测

猜谜游戏程序的第一部分将要求用户输入，处理该输入，并检查输入是否符合预期。在src/main.rs中输入如下代码。

fn main() {
    use std::io;
    fn main() {
        println!("Guess the number!");
        println!("Please input your guess.");
        let mut guess = String::new();
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");
        println!("You guessed: {}", guess);
    }
}

这段代码包含很多信息，所以让我们逐行查看。要获取用户输入然后将结果打印为输出，我们需要将 io（输入/输出库）从标准库（也就是 std）引入到项目中。

use std::io;

作为默认行为，Rust 会将预导入模块内的条目自动引入每一段程序的作用域中，它包含了一小部分相当常用的类型。但假如你需要的类型不在预导入模块内，那么我们就必须用 use 语句来显式地进行导入声明。std::io 库包含了许多有用的功能，我们可以使用它来获得用户的输入数据。

main函数是程序的入口点：

fn main() {}

fn 表示声明一个新的函数，main表示函数的名称（main 有特定的含义，表示整个程序的入口程序），()里面可以有参数，{表示函数体的开始，}表示函数体的结束，在{}可以写实现函数功能的具体代码。 println! 宏可以将字符串打印到屏幕上：

println!("Guess the number!");
println!("Please input your guess.");

此代码正在打印一个提示，说明游戏是什么并请求用户输入。

3. 用变量存储值

接下来，我们将创建一个变量来存储用户输入，如下所示：

let mut guess = String::new();

Rust 中用let来绑定一个变量（在其他语言叫定义或者声明），上面的语句的意思是指，我们把右边的值（字符串对象，现在可以理解为一个空的字符串）绑定到左边的名为guess的变量上。这里有一个值得注意的地方是在 guess前面多了一个mut，它的意思是，guess变量的值在之后还会变化，这也是符合我们需求的，因为它将用来保存用户的输入。在 Rust 世界中，所有的变量在绑定（定义）之后，是不能改变的，除非绑定（定义）的时候在名称前面显式地标 mut 。看一下下面的代码：

let apples = 5; //不能改变
//apples = 8; //此处会导致编译错误
let mut oranges = 5;
oranges = 8; // ok，因为定义oranges时标注为 mut

现在顺便来说一下String::new()的意思，new 是该 String 类型的关联函数，关联函数是在类型上实现的函数，在本例中为 String. 它会返回一个 String 实例给左边的变量guess。String 是标准库提供的字符串类型，是可增长的 UTF-8 编码的文本位。关于 String 的情况，目前也只能就此打住，后面会专门地讲解它。

4.接收用户输入

io::stdin()
    .read_line(&mut guess)

程序开头通过use std::io导入 io 库，io::stdin()会获取到 std::io::Stdin 实例，表示终端标准输入句柄的类型。调用 read_line(&mut guess) ，可以获取用户的输入。我们还将&mut guess 作为参数传递read_line 给它以告诉它存储用户输入的字符串。

上面这段代码的意思是，将用户输入的任何内容放入标准输入并将其附加到字符串中（不覆盖其内容），所以我们因此将该字符串作为参数传递。字符串参数需要是可变的，以便该方法可以更改字符串的内容。

& 表示此参数是一个引用，它为您提供了一种方法，让您的代码的多个部分访问一个数据，而无需多次将该数据复制到内存中。引用是一个复杂的特性，Rust 的主要优势之一是使用引用是多么安全和容易。你不需要知道很多细节来完成这个程序。现在，您需要知道的是，与变量一样，引用在默认情况下是不可变的。因此，您需要编写 &mut guess而不是 &guess 使其可变。

5. 使用 Result 类型处理潜在异常

尽管我们现在讨论的是第三行文本，但它仍然是单个逻辑代码行的一部分。下一部分是这个方法：

.expect("Failed to read line");

我们可以把这段代码写成：

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

但是，一长行很难阅读，因此最好将其分开。当您使用.method_name() 语法调用方法时，引入换行符和其他空格以帮助分解长行通常是明智的。

read_line() 从标准输入中获取用户的输入并把输入的内容附加到字符串，同时会返回一个io::Result 类型的实例。Result是一个枚举类型，枚兴类型由一系列固定的值组合面成。这些值被称作枚举的变体。对于Result而言，它拥有Ok 和 Err 两个变体。其中Ok变体表明当前的操作执行成功，并附带执行后产生的结果。相应地，Err 变体则表明当前的操作执行失败，并附带执行后引发失败的具体原因。

Result 类型的值定义了一系列的方法，expect 就是其中之一。例如 io::Result 实例的值是Err，那么expect 方法就会中断当前的程序，并将传入的字符串显示出来；如果是Ok，就会取出Ok中附带的值，并将它作为结果返回给用户。

如果你不调用 expect方法，编译程序的话，会收到类似警告：note: thisResultmay be anErrvariant, which should be handled 。

6. println! 使用占位符打印值

除了右大括号之外，到目前为止，代码中只有一行要讨论：

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

此行打印现在包含用户输入的字符串。可以将{}想象成一个固定值的占位符，您可以使用花括号打印多个值：第一组花括号保存格式字符串后列出的第一个值，第二组保存第二个值，依此类推。在一次调用中打印多个值 println! 如下所示：

let x = 5;
let y = 10;

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

此代码将打印 x = 5 and y = 10.

7. 测试一下程序的效果

现在，让我们来运行一下上面的代码：

cargo run
   Compiling guessing_game v0.1.0 (/Users/mjsong/Desktop/rust_study/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.71s
     Running `target/debug/guessing_game`
Guess the number!
Please input your guess.

88
You guessed: 88

到目前为此，我们已经完成了猜数游戏的第一部分：可以从用户的键盘获得输入并将它们打印出来。

8. 生成一个保密数字

接下来，我们需要生成一个保密的数字来供玩家进行猜测。需要保证每一次数字不一样，且在 1-100 之间。

8-1. 使用 Cargo 获取依赖

这显然是一个随机数问题，只是 Rust 标准库中没有既有的随机数库可用。Crates.io 是 Rust 生态系统中的人们发布他们的开源 Rust 项目供其他人使用的地方。所以，我们可以到crates.io仓库中，去寻找有没有现成的轮子可用。

首先，打开 cargo 仓库（ https://crates.io/ ），尝试查询 "rand" 关键字：

排在列首是rand 包（crate），点进去查看文档发现其功能满足我们生成随机数的需求，当前最新版是0.8.5 。

现在该 Cargo 发挥作用的时候了，打开Cargo.toml文件，悠改如下类似代码，增加rand包的依赖。

[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8.5"

但一种更好的办法是用cargo add 命令增加依赖包，比如在项目目录下，执行：

$ cargo add rand
    Updating `ustc` index
      Adding rand v0.8.5 to dependencies
             Features:
             + alloc
             + getrandom
             + libc
             + rand_chacha
             + std
             + std_rng
             - log
             - min_const_gen
             - nightly
             - packed_simd
             - serde
             - serde1
             - simd_support
             - small_rng

这样会自动更新 Cargo.toml 文件中的内容，并成功把依赖包及依赖包所依赖的包下载到本地，然后编译这些依赖。如果是直接在Cargo.toml的[dependencies]文件中手动填写依赖，则需要在执行 cargo build 或 cargo check 时，才会下载、编译 依赖包及其依赖包所依赖的包。

在Cargo.toml文件中，标题后面的所有内容都是该部分的一部分，该部分一直持续到另一个部分开始。在[dependencies]您告诉 Cargo 您的项目依赖于哪些外部 crates 以及您需要这些 crates 的哪些版本。

Cargo 非常的智能，cargo build 后，如果我们没有对 Cargo.toml文件作任何的修改，再次执行 cargo build，会跳过下载、编译所依赖的第三方库。

8-2. 通过 Cargo.lock 文件确保可重现的构建

注意：原书中的内容有误，以下内容作过修正。

Cargo 有一种机制，可确保您每次或其他任何人构建代码时都可以重建相同的产物。在你第一次使用cargo build后，会在项目目录中生成该文件，根据依赖的语义化版本 找到符合要求的具体版本号，并将其写入到该文件中。

在这里，我们指定版本为 0.8.5 , Cargo 会按照标准的语义化版本系统（有时称为 SemVer）解读具体的含义。该数字 0.8.5 实际上是 ^0.8.5 一种简写，这意味着至少0.8.5，但低于的任何版本0.9.0 ，但是不保证任何版本 0.9.0 或更高版本都具有与以下示例使用的相同的 API。

如果当前0.8.5是最新版，会在.lock文件中写入0.8.5，并用该版本构建；如果之后出了一个 0.8.6，再次构建时，会将文件中的版本修改为0.8.6，并使用0.8.6 进行构建！

换句话说，当前项目将会一直使用 0.8.X 版本的 rand 包（其中，X >= 5），直到你手动升级至其他版本。

9. 生成一个随机数

让我们开始使用 rand 来生成一个数字来猜测。下一步是更新 src/main.rs，程序清单如下：

use std::io;
use rand::Rng;

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

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

    println!("The secret number is: {}", secret_number);

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

    let mut guess = String::new();

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

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

首先，我们使用 use rand::Rng 引入了 rand::Rng，这里的Rng 是一个特征（trait），它定义了随机数生成器需要实现的方法集合。

接着，又增加了另外一行代码：

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

rand::thread_rng() 会返回一个特定的随机数生成器，该生成器位于本地线程空间，并通过操作系统获得随机数种子。这个生成器又调用其方法 gen_range，该方法是在刚刚引入的Rng trait 中定义的方法，它接收两个数字作为参数，并生成一个范围在两者之间的随机数。

现在用 cargo run 运行程序，每次都会获得一个 1 到 100 之间的保密数字！

10. 比较猜测数字与保密数字

现在，我们有了一个随机生成的保密数字，还有一个用户输入的猜测数字。接下来，我们编写比较的代码。

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

fn main() {
    // --snip--

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

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

在这里，我们引用了std::cmp::Ordering类型，该类型有Less/Greater/Equal三个变体，通过表示比较两个数字的结果。guess 的 cmp用于与guess进行比较，返回的类型就是Ordering。 match对比较的结果进行决判，分别就三种变体做不同的处理，由于一共只有三种可能的情况，所以不管是哪一种，都会被math处理掉。

运行上面的程序，会得到如下的错误：

error[E0308]: mismatched types
   --> src/main.rs:21:21
    |
21  |     match guess.cmp(&secret_number) {
    |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
    |                 |
    |                 arguments to this method are incorrect
    |
    = note: expected reference `&String`
               found reference `&{integer}`

该错误的核心原因是：类型不匹配！因为 guess的类型是 String，而 secret_number的类型是整形 (i32)。为了能正常进行比较，需要将程序中读取的输入从 String 转换成数值类型。修改代码如下：


// --snip--

let mut guess = String::new();

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

let guess: u32 = guess.trim().parse().expect("Please type a number!");

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

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

增加的代码行是：

let guess: u32 = guess.trim().parse().expect("Please type a number!");

我们创建一个名为的变量guess。但是等等，程序不是已经有一个名为的变量guess吗？确实如此，但有益的是，Rust 允许我们用一个新的值来掩盖之前的值。我们可以重用guess 变量名，而不是强迫我们创建两个唯一的变量，例如 guess_str和guess 。

我们将这个新变量绑定到表达式guess.trim().parse()。表达式中的是指包含输入作为字符串guess 的原始变量。guess实例上的trim方法将消除字符串开头和结尾的任何空格，我们必须这样做才能将字符串与u32只能包含数字数据的进行比较。用户必须按 Enter来满足read_line并输入他们的猜测，这会在字符串中添加一个换行符。例如，如果用户输入5并按下回车，guess看起来像这样5\n(“\n 代表换行符”）。（在 Windows 上，按enter会导致回车和换行，即：\r\n）。该trim方法消除\n或\r\n 。

该parse方法仅适用于可以逻辑转换为数字的字符，因此很容易导致错误。例如，如果字符串包含A👍%，则无法将其转换为数字。因为它可能会失败，所以该parse方法返回一个Result类型，就像该read_line 方法所做的一样。我们将再次使用Result的expect方法以同样的方式处理。如果由于无法从字符串中创建数字，则该调用将使游戏崩溃并打印我们给它的消息。

让我们现在运行程序！

$ cargo run
   Compiling guessing_game v0.1.0 (/Users/someone/rust_projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.40s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 51
Please input your guess.
56
You guessed: 56
Too big!

好的！即使在猜测之前添加了空格，程序仍然认为用户猜了 56。运行程序几次以验证不同类型输入的不同行为：正确猜数字，猜一个太高的数字，并猜测一个太低的数字。

我们现在已经完成了大部分游戏，但用户只能进行一次猜测。让我们通过添加一个循环来改变它！

11. 使用循环允许多个猜测

loop 关键字创建一个无限循环。我们将添加一个循环，让用户有更多机会猜测数字：修改src/main.rs中的代码如下：

    // --snip--

    println!("The secret number is: {}", secret_number);

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

        // --snip--

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

如您所见，我们已将猜测输入提示中的所有内容移至循环中。该程序现在将永远要求另一个猜测，这实际上引入了一个新问题：玩家永远都没有办法正常地结束游戏了。用户要退出程序，只能通过 Ctrl + C之类的快捷键强行终止程序。

12. 在猜测成功时优雅地退出

现在让我们的程序增加一条 break 语句，使得玩家在猜对数字后能够正常退出游戏。

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

13. 处理非法输入

目前的程序，当玩家输入一个非数字时，程序会崩溃，原因是程序没有对字符串类型在转换成数字类型失败的情况作处理。为了进一步细化游戏的行为，而不是在用户输入非数字时使程序崩溃，让我们让游戏忽略非数字，以便用户继续猜测。修改代码如下：


// --snip--

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

// --snip--

我们从一个expect调用切换到一个match表达式，从一个错误崩溃转移到处理错误。请记住，它parse返回一个Result 类型，并且Result是一个具有Ok或Err 变体的枚举。我们在 match这里使用表达式，就像我们对cmp方法的Ordering结果所做的那样。如果出现Err这种情况，通过 continue 跳到loop的开始，让用户重新输入。

很好，现在不管玩家输入什么，都不会崩溃了！

14. 完整的代码

等等！回想一下，程序仍在打印保密数字。这对测试很有效，但它破坏了游戏。让我们删除那个输出保密号码的println!吧。

完成代码如下：

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

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

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

    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;
            }
        }
    }
}

总结

通过对Hello,world!、Hello,cargo!、猜数游戏讲解，我们学会了如何使用 Cargo 来创建新项目、管理项目中的依赖，并接触了let、match、方法、关联函数及包（crate）的使用等概念。但是，我们还没有迈开学习Rust语言旅途的第一步，现在顶多只是做一些热身动作。下一篇，我们正式出发，你准备好了吗？

工欲善其事，必先利其器 —— Rust 开发环境之搭建

james — Sat, 18 May 2024 17:22:04 +0800

子曰：工欲善其事，必先利其器。居是邦也，事其大夫之贤者，友其士之仁者。

本章是《探幽 Rust 语言》系列文章的开篇之文，主要包括 Rust 语言简介、环境安装及相关配置的内容。重点是搭建开发环境，开发环境是修练 Rust 大法的练兵场和屠龙宝刀。

Rust 简介

Rust 语言最初由 Graydon Hoare 在 Mozilla Research 开发，自 2006 年起得到 Mozilla 的支持。Rust 第一个有版本号的 Rust 编译器是 2012 年 1 月发布的，2015 年 5 月 15 日发布了第一个稳定版本 1.0 版。其设计目标是成为 C++ 的替代品，旨在解决 C/C++ 语言安全性和并发性的问题。与Golang一样，被称为是21世纪的C语言，不过究竟谁才是 C语言 真正的替代者，我们只能拭目以待 ^-^ ！

Rust 特点

能想到的用于描述 Rust 特点的关键字，大致有静态强类型、极其强大的编译器、零成本抽象、无垃圾回收器（GC）、零运行时（或者说运行时很小）等等，其中的具体意思后续的文章中会有专门的介绍。Rust 同时支持包括函数式、过程式、面向对象在内的多种编程范式。总之，它一种相当优秀的现代编程语言。

让我们来看看 Rust 官方的介绍（<https://www.rust-lang.org/zh-CN/）

其主要的特点有：

高性能：Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。。
可靠性：Rust 丰富的类型系统和所有权模型保证了内存安全和线程安全，让您在编译期就能够消除各种各样的错误。
生产力：Rust 拥有出色的文档、友好的编译器和清晰的错误提示信息，还集成了一流的工具 —— 包管理器和构建工具，智能地自动补全和类型检验的多编辑器支持，以及自动格式化代码等等。

Rust 的使用场景

传统命令行程序：Rust 编译器可以直接生成目标可执行程序，不需要任何解释程序。
Web 应用：Rust 可以被编译成 WebAssembly，WebAssembly 是一种 JavaScript 的高效替代品。
网络服务器：Rust 用极低的资源消耗做到安全高效，且具备很强的大规模并发处理能力，十分适合开发普通或极端的服务器程序。
嵌入式开发：Rust 同时具有 JavaScript 一般的高效开发语法和 C 语言的执行效率，支持底层平台的开发。
系统编程：如操作系统、文件系统、游戏引擎和浏览器的组件。
跨平台应用：能够编写一次代码，运行在多种操作系统和平台上。

安装 Rust 开发环境

本文仅介绍类unix操作系统的安装，Windows等其他操作系统请参照其他相关文档。

具体的安装过程参考官方的文档：https://www.rust-lang.org/zh-CN/tools/install

Rust 中的版本

Rust 有三类版本：稳定版 (stable)、公测版 (beta) 和 nightly 版，分别对应的是 stable 分支、beta 分支和 master 分支。

稳定版（stable）：对于大多数 Rust 开发者而言，最新的稳定版 (stable) 是最好和最明智的选择
Beta 版 contributor：或是想提前尝鲜下一个稳定版新特性的开发人员，可以临时使用 beta 版本；
Nightly 版：主要针对的也是 contributor，或是想临时尝鲜最新不稳定功能特性的开发人员。

使用 rustup 安装最新 stable 版本

Rust 提供了统一的安装、管理、升级、卸载工具 —— rustup。其安装命令：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

执行上面的命令，需要先安装好curl，它会从https://sh.rustup.rs下载rustup-init.sh脚本文件，并在命令终端中执行里面的命令。如果一切顺利，最后会终端上打印出类似如下的信息：

Rust is installed now. Great!

To get started you may need to restart your current shell.
This would reload your PATH environment variable to include
Cargo's bin directory ($HOME/.cargo/bin).

To configure your current shell, you need to source
the corresponding env file under $HOME/.cargo.

This is usually done by running one of the following (note the leading DOT):
. "$HOME/.cargo/env"            # For sh/bash/zsh/ash/dash/pdksh
source "$HOME/.cargo/env.fish"  # For fish

参照上面的提示，根据系统的 shell 类型，配置 shell 的环境变量。比如：

$. "$HOME/.cargo/env"

执行完上面的命令后，查看一下安装的 rustup 版本：

$ rustup --version
rustup 1.27.0 (bbb9276d2 2024-03-08)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.78.0 (9b00956e5 2024-04-29)`

恭喜你！至此，我们已经把 rust 最新的 stable（即 1.78.0）版本安装好了。

还可以执行下面命令，查看 rust 究竟安装在哪个目录下。


$ which rustup
/Users/someone/.cargo/bin/rustup

安装与使用指定版本

安装 shell $ rustup install 1.76.0
使用 shell $ rustc +1.76.0 -V rustc 1.76.0 (07dca489a 2024-02-04) $ cargo +1.76.0 --version cargo 1.76.0 (c84b36747 2024-01-18) $ cargo +1.66.0 --version error: toolchain '1.66.0-x86_64-apple-darwin' is not installed

查看已经安装的 rust 工具链

$ rustup show

Default host: x86_64-apple-darwin
rustup home:  /Users/someone/.rustup

installed toolchains
--------------------

stable-x86_64-apple-darwin (default)
nightly-2021-03-11-x86_64-apple-darwin
nightly-2021-10-21-x86_64-apple-darwin
nightly-2022-03-14-x86_64-apple-darwin
nightly-2022-07-11-x86_64-apple-darwin
nightly-2023-04-25-x86_64-apple-darwin
nightly-2024-02-04-x86_64-apple-darwin
nightly-x86_64-apple-darwin
1.76.0-x86_64-apple-darwin
solana

安装后的几个相关目录解析

有两个目录需要关注，一个是 $HOME/.cargo(安装成功后会把.cargo/bin 加入到了 PATH 环境变量中)，另一个是$HOME/.rustup。


tree -F -L 2 .cargo
.cargo
├── bin/
│   ├── anchor*
│   ├── avm*
│   ├── bindgen*
│   ├── cargo*
│   ├── cargo-add*
│   ├── cargo-clippy*
│   ├── cargo-contract*
│   ├── cargo-dylint*
│   ├── cargo-fmt*
│   ├── cargo-miri*
│   ├── cargo-remote*
│   ├── cargo-rm*
│   ├── cargo-set-version*
│   ├── cargo-upgrade*
│   ├── clippy-driver*
│   ├── dylint-link*
│   ├── grcov*
│   ├── kickstart*
│   ├── mdbook*
│   ├── mini-redis-cli*
│   ├── mini-redis-server*
│   ├── rls*
│   ├── rust-analyzer*
│   ├── rust-gdb*
│   ├── rust-gdbgui*
│   ├── rust-lldb*
│   ├── rustc*
│   ├── rustdoc*
│   ├── rustfmt*
│   └── rustup*
├── config
├── credentials
├── env
├── git/
│   ├── CACHEDIR.TAG
│   ├── checkouts/
│   └── db/
└── registry/
    ├── CACHEDIR.TAG
    ├── cache/
    ├── index/
    └── src/

bin 目录下存放了 rust 开发中常用的 cli，比如 cargo、rustc、rustdoc、rustup 等。


tree -F -L 2 .rustup
.rustup
├── downloads/
├── settings.toml
├── tmp/
├── toolchains/
│   ├── 1.76.0-x86_64-apple-darwin/
│   ├── nightly-2021-03-11-x86_64-apple-darwin/
│   ├── nightly-2021-10-21-x86_64-apple-darwin/
│   ├── nightly-2022-03-14-x86_64-apple-darwin/
│   ├── nightly-2022-07-11-x86_64-apple-darwin/
│   ├── nightly-2023-04-25-x86_64-apple-darwin/
│   ├── nightly-2024-02-04-x86_64-apple-darwin/
│   ├── nightly-x86_64-apple-darwin/
│   ├── solana -> /Users/someone/solana-release/bin/sdk/sbf/dependencies/platform-tools/rust
│   └── stable-x86_64-apple-darwin/
└── update-hashes/
    ├── 1.76.0-x86_64-apple-darwin
    ├── nightly-2021-03-11-x86_64-apple-darwin
    ├── nightly-2021-10-21-x86_64-apple-darwin
    ├── nightly-2022-03-14-x86_64-apple-darwin
    ├── nightly-2022-07-11-x86_64-apple-darwin
    ├── nightly-2023-04-25-x86_64-apple-darwin
    ├── nightly-2024-02-04-x86_64-apple-darwin
    ├── nightly-x86_64-apple-darwin
    └── stable-x86_64-apple-darwin

setting.toml是 rust 的配置文件，其内容如下：

$ cat .rustup/settings.toml
default_host_triple = "x86_64-apple-darwin"
default_toolchain = "stable-x86_64-apple-darwin"
profile = "default"
version = "12"

[overrides]
"/Users/someone/Desktop/Demo" = "nightly-x86_64-apple-darwin"
"/Users/someone/deeper-chain" = "nightly-2021-10-21-x86_64-apple-darwin"

上面的default_toolchain，指示了当前默认使用的工具链版本stable-x86_64-apple-darwin，即目标机器为 apple，处理器架构为 x86，rust 的版本为 stable。
上面的[overrides]，是对具体的项目的版本进行定制化重写。比如对位于/Users/someone/Desktop/Demo的项目而言，其目标机器为 apple，处理器架构为 x86，rust 的版本为 nightly。

toolchains目录，它下面存放了安装到本地的所有版本的 toolchain。

使用特定版本构建项目

使用 rustup override

构建项目时所用的版本，是由.rustup/settings.toml中的default_toolchain指定的，通常情况下都是最新的 stable 版本。对于要使用特定版本进行构建的 rust 项目，我们可以通过rustup override来指定版本号。下面是一个例子：

$ cargo new hello #用cargo创建一个项目，项目名称为hello
$ rustc -V #查看rustc的版本，当前最新的版本为 1.78.0
rustc 1.78.0 (9b00956e5 2024-04-29)

$ cd hello
$ rustup override set 1.76.0 #指定当前项目的rust版本为1.76.0
info: override toolchain for '/Users/someone/Desktop/rust_study/hello' set to '1.76.0-x86_64-apple-darwin'

我们用 cargo 创建了一个新的 hello 项目，并该项目下，指定其使用 1.76.0 版本进行构建。现在，在该项目下执行 rustc 查看版本：

$ rustc -V
rustc 1.76.0 (07dca489a 2024-02-04)

再跳到项目之外的目录，再次查看 rustc 版本：

$ cd ~
$ rustc -V
rustc 1.78.0 (9b00956e5 2024-04-29)

rustc override 的原理其实是在 $HOME/.rustup/settings.toml文件中添加了一些内容：

cat .rustup/settings.toml
default_host_triple = "x86_64-apple-darwin"
default_toolchain = "stable-x86_64-apple-darwin"
profile = "default"
version = "12"

[overrides]
"/Users/someone/Desktop/Demo" = "nightly-x86_64-apple-darwin"
"/Users/someone/Desktop/rust_study/hello" = "1.76.0-x86_64-apple-darwin"
"/Users/someone/deeper-chain" = "nightly-2021-10-21-x86_64-apple-darwin"

如上所示，在 [overrides] 的第二行，新增了一条规则，指定 hello 项目的构建工具链版本为特定版本。可以使用rustup override unset取消重载效果：

$ rustup override unset

使用 rust-toolchain.toml 方件

使用上面的rustup override set命令指定工具链的版本，致使项目的配置信息与.rustup/settings.toml紧耦合在一起，不利于通过 git 进行协同合作。Rust 提供了另一种方法，即在项目根目录下放置一个名为rust-toolchain.toml配置文件，其大致内容如下：

[toolchain]
channel = "1.76.0"

取消掉之前的设置：

$ rustup override unset # 在项目的目录下执行

然后rust-toolchain.toml就生效了：

$ rustc -V #在hello项目的目录下执行
rustc 1.76.0 (07dca489a 2024-02-04)

可见，工具链的 override 存在着优先级，Rust 规定版本 override 的优先级顺序由高到低依次是：

plus 语法：rustc +1.76.0 -V
RUSTUP_TOOLCHAIN 环境变量 (default: none)
rustup override set 命令
rust-toolchain.toml
默认toolchain

几个常用命令

与搭建开发环境相关的几个常用命令，作为总结列出如下：

更新

rustup update
rustup update stable #stable可替换为你想要的版本

安装指定版本

rustup install seme_ver

卸载

rustup self uninstall

版本间切换

rustup default stable 
rustup default nightly
rustup default beta #如果没有安装，切换的时候为安装

加速 cargo

cargo 是 Rust 的重要工具，其中的作用之一就是包管理（类似于 Golang 中的 go mod，Java 中的 Maven），在开发 rust 程序时，默认会从 crates.io 仓库中下载程序所依赖的包（crate)。由于众所周知的原因，速度可能会很慢。业界一种通常做法，是把 cargo 源配置为国内的镜像。以下是在类 unix 系统中的配置方法。

进入$HOME/.cargo目录 shell $ cd $HOME/.cargo
创建config shell $ touch config #如果没有该文件
把如下所示的内容复制到config中


[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"

replace-with = 'ustc' #根据需要替换你想要的镜像，比如：tuna、rustcc 等

# 中国科学技术大学
[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index"

# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index/"

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# 阿里云rustcc社区
[source.rustcc]
registry = "https://code.aliyun.com/rustcc/crates.io-index.git"

# 字节跳动
[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index.git"

Rust 在线练兵场

如果你不想在本地安装开发环境，Rust 官方提供了一个在线练兵场以供你学习或体验。这个练兵场就是：Rust Playground

在这个 Playground 中，你可以选择 Rust 的版本（stable、beta、nightly）、编译模式（debug、release）、Rust 的版本；可以选择执行一些工具，比如 rustfmt；可以选择执行的命令：Run、Build、Test、MIR 等。

编辑器与 IDE

这一块没有具体的要求，可选择的范围也比较多。当前大致可选择的有：Vscode、Sublime Text、Rustrover、Eclipse、Clion、Vim等。

具体选择哪一款，看自己的喜好。相关的配置，可自行参照对应产品的文档。官方提供的链接：用于开发 Rust 的 IDE

总结

本文分别就Rust简介、Rust开发环境的搭建、使用特定版本构建项目、加速cargo的配置等内容进行了系统的介绍，阅读完并按照本文的步骤操作下来，应能在本地成功地搭建好 Rust 开发环境。

至此，我们有了修练 Rust 大法屠龙宝刀。只是，这把刀尚徒有其名。通往 Rust 殿堂的路，已在脚下。等待你的，有如狐如妖的诱惑，有剪不断理还乱的情愁，也有本来无一物,何处惹尘埃的通透与惬意。既然选择了，就不要轻言放弃。千磨万击还坚韧，任尔东南西北风。出发吧，少年！