第6章复合类型 on 编程那些事儿

01-字符串

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/compound-types/string.html

字符串

字符串字面量的类型是 &str，例如 let s: &str = "hello, world" 中的 "hello, world" 的类型就是 &str。

`str` 和 `&str`

🌟 正常情况下我们无法使用 str 类型，但是可以使用 &str 来替代

1
2
3
4
5


// 修复错误，不要新增代码行
fn main() {
 // let s: str = "hello, world";
 let s: &str = "hello, world";
}

🌟🌟 如果要使用 str 类型，只能配合 Box。 & 可以用来将 Box<str> 转换为 &str 类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14



// 使用至少两种方法来修复错误
fn main() {
 // 1
 // let s: Box<str> = "hello, world".into();
 // greetings(&s);
 // 2 或者
 let s: Box<&str> = "hello, world".into();
 greetings(*s);
}

fn greetings(s: &str) {
 println!("{}",s)
}

String

String 是定义在标准库中的类型，分配在堆上，可以动态的增长。它的底层存储是动态字节数组的方式( Vec<u8> )，但是与字节数组不同，String 是 UTF-8 编码。

02-数组

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/compound-types/array.html

数组

数组的类型是 [T; Length]，就如你所看到的，数组的长度是类型签名的一部分，因此数组的长度必须在编译期就已知，例如你不能使用以下方式来声明一个数组:

03-切片

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/compound-types/slice.html

切片

切片跟数组相似，但是切片的长度无法在编译期得知，因此你无法直接使用切片类型。

🌟🌟 这里, [i32] 和 str 都是切片类型，但是直接使用它们会造成编译错误，如下代码所示。为了解决，你需要使用切片的引用： &[i32]，&str。

1
2
3
4
5
6
7
8
9



// 修复代码中的错误，不要新增代码行!
fn main() {
 let arr = [1, 2, 3];
 let s1: &[i32] = &arr[0..2];

 // let s2: str = "hello, world" as str;
 let s2: &str = "hello, world";
}

一个切片引用占用了2个字大小的内存空间( 从现在开始，为了简洁性考虑，如无特殊原因，我们统一使用切片来特指切片引用 )。该切片的第一个字是指向数据的指针，第二个字是切片的长度。字的大小取决于处理器架构，例如在 x86-64 上，字的大小是 64 位也就是 8 个字节，那么一个切片引用就是 16 个字节大小。

04-元组

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/compound-types/tuple.html

元组

🌟 元组中的元素可以是不同的类型。元组的类型签名是 (T1, T2, ...), 这里 T1, T2 是相对应的元组成员的类型.

1
2
3
4
5
6
7
8


fn main() {
 let _t0: (u8,i16) = (0, -1);
 // 元组的成员还可以是一个元组
 let _t1: (u8, (i16, u32)) = (0, (-1, 1));
 // 填空让代码工作
 // let t: (u8, __, i64, __, __) = (1u8, 2u16, 3i64, "hello", String::from(", world"));
 let _t: (u8, u16, i64, &str, String) = (1u8, 2u16, 3i64, "hello", String::from(", world"));
}

🌟 可以使用索引来获取元组的成员

1
2
3
4
5
6
7



// 修改合适的地方，让代码工作
fn main() {
 let t = ("i", "am", "sunface");
 // assert_eq!(t.1, "sunface");
 assert_eq!(t.2, "sunface");
}

🌟 过长的元组无法被打印输出

1
2
3
4
5
6


// 修复代码错误
fn main() {
 // let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
 let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 println!("too long tuple: {:?}", too_long_tuple);
}

🌟 使用模式匹配来解构元组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


fn main() {
 let tup = (1, 6.4, "hello");

 // 填空
 // let __ = tup;
 let (x,z,y) = tup;

 assert_eq!(x, 1);
 assert_eq!(y, "hello");
 assert_eq!(z, 6.4);
}

🌟🌟 解构式赋值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


fn main() {
 let (x, y, z);

 // 填空
 // __ = (1, 2, 3);
 (y, z, x) = (1, 2, 3);

 assert_eq!(x, 3);
 assert_eq!(y, 1);
 assert_eq!(z, 2);
}

🌟🌟 元组可以用于函数的参数和返回值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13



fn main() {
 // 填空，需要稍微计算下
 // let (x, y) = sum_multiply(__);
 let (x, y) = sum_multiply((2,3));
 
 assert_eq!(x, 5);
 assert_eq!(y, 6);
}

fn sum_multiply(nums: (i32, i32)) -> (i32, i32) {
 (nums.0 + nums.1, nums.0 * nums.1)
}

你可以在这里找到答案(在 solutions 路径下)

05-结构体

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/compound-types/struct.html

结构体

三种类型的结构体

🌟 对于结构体，我们必须为其中的每一个字段都指定具体的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19



// fix the error
struct Person {
 name: String,
 age: u8,
 hobby: String
}
fn main() {
 let age = 30;
 // let p = Person {
 // name: String::from("sunface"),
 // age,
 // };
 let _p = Person {
 name: String::from("sunface"),
 age,
 hobby: String::new()
 };
} 

🌟 单元结构体没有任何字段。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17



struct Unit;
trait SomeTrait {
 // ...定义一些行为
}

// 我们并不关心结构体中有什么数据( 字段 )，但我们关心它的行为。
// 因此这里我们使用没有任何字段的单元结构体，然后为它实现一些行为
impl SomeTrait for Unit { }
fn main() {
 let u = Unit;
 do_something_with_unit(u);
} 

// 填空，让代码工作
// fn do_something_with_unit(u: __) { }
fn do_something_with_unit(u: Unit) { }

🌟🌟🌟 元组结构体看起来跟元组很像，但是它拥有一个结构体的名称，该名称可以赋予它一定的意义。由于它并不关心内部数据到底是什么名称，因此此时元组结构体就非常适合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18



// 填空并修复错误
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {
 // let v = Point(__, __, __);
 let v = Point(0, 127, 255);
 check_color(v);
}

// fn check_color(p: Color) {
fn check_color(p: Point) {
 // let (x, _, _) = p;
 let Point(x, _, _) = p;
 assert_eq!(x, 0);
 assert_eq!(p.1, 127);
 assert_eq!(p.2, 255);
}

结构体上的一些操作

🌟 你可以在实例化一个结构体时将它整体标记为可变的，但是 Rust 不允许我们将结构体的某个字段专门指定为可变的.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24



// 填空并修复错误，不要增加或移除代码行
struct Person {
 name: String,
 age: u8,
}
fn main() {
 let age = 18;
 // let p = Person {
 // name: String::from("sunface"),
 // age,
 // };
 let mut p = Person {
 name: String::from("sunface"),
 age,
 };

 // how can you believe sunface is only 18?
 p.age = 30;

 // 填空
 // __ = String::from("sunfei");
 p.name = String::from("sunfei");
}

🌟 使用结构体字段初始化缩略语法可以减少一些重复代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 填空
struct Person {
 name: String,
 age: u8,
}
fn main() {}

fn build_person(name: String, age: u8) -> Person {
 Person {
 age,
 // __
 name
 }
}

🌟 你可以使用结构体更新语法基于一个结构体实例来构造另一个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 填空，让代码工作
struct User {
 active: bool,
 username: String,
 email: String,
 sign_in_count: u64,
}

fn main() {
 let u1 = User {
 email: String::from("someone@example.com"),
 username: String::from("sunface"),
 active: true,
 sign_in_count: 1,
 };

 let u2 = set_email(u1);
}

fn set_email(u: User) -> User {
 User {
 email: String::from("contact@im.dev"),
 // __
 ..u
 }
}

打印结构体

🌟🌟 我们可以使用 #[derive(Debug)] 让结构体变成可打印的.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 填空，让代码工作
// #[]
#[derive(Debug)]
struct Rectangle {
 width: u32,
 height: u32,
}

fn main() {
 let scale = 2;
 let rect1 = Rectangle {
 width: dbg!(30 * scale), // 打印 debug 信息到标准错误输出 stderr,并将 `30 * scale` 的值赋给 `width`
 height: 50,
 };

 dbg!(&rect1); // 打印 debug 信息到标准错误输出 stderr

 // println!(__, rect1); // 打印 debug 信息到标准输出 stdout
 println!("{:?}", rect1);
}

结构体的所有权

当解构一个变量时，可以同时使用 move 和引用模式绑定的方式。当这么做时，部分 move 就会发生：变量中一部分的所有权被转移给其它变量，而另一部分我们获取了它的引用。

06-枚举

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/compound-types/enum.html

枚举

🌟🌟 在创建枚举时，你可以使用显式的整数设定枚举成员的值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34



// 修复错误
enum Number {
 Zero,
 One,
 Two,
}

enum Number1 {
 Zero = 0,
 One,
 Two,
}

// C语言风格的枚举定义
// enum Number2 {
// Zero = 0.0,
// One = 1.0,
// Two = 2.0,
// }
enum Number2 {
 Zero = 0,
 One = 1,
 Two = 2,
}

fn main() {
 // 通过 `as` 可以将枚举值强转为整数类型
 // assert_eq!(Number::One, Number1::One);
 // assert_eq!(Number1::One, Number2::One);

 assert_eq!(Number::One as u8, Number1::One as u8);
 assert_eq!(Number1::One as u8, Number2::One as u8);
}

🌟 枚举成员可以持有各种类型的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 填空
enum Message {
 Quit,
 Move { x: i32, y: i32 },
 Write(String),
 ChangeColor(i32, i32, i32),
}

fn main() {
 // let msg1 = Message::Move{__}; // 使用x = 1, y = 2 来初始化
 let _msg1 = Message::Move { x: 1, y: 2 }; // 使用x = 1, y = 2 来初始化
 // let msg2 = Message::Write(__); // 使用 "hello, world!" 来初始化
 let _msg2 = Message::Write("hello, world!".to_string()); // 使用 "hello, world!" 来初始化
}

🌟🌟 枚举成员中的值可以使用模式匹配来获取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 仅填空并修复错误
enum Message {
 Quit,
 Move { x: i32, y: i32 },
 Write(String),
 ChangeColor(i32, i32, i32),
}

fn main() {
 let msg = Message::Move{x: 1, y: 2};

 // if let Message::Move{__} = msg {
 // assert_eq!(a, b);
 // } else {
 // panic!("不要让这行代码运行！");
 // }

 if let Message::Move{x: a, y: b} = msg {
 assert_eq!(a, b);
 } else {
 panic!("不要让这行代码运行！");
 }
}

🌟🌟 使用枚举对类型进行同一化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// 填空，并修复错误
#[derive(Debug)]
enum Message {
 Quit,
 Move { x: i32, y: i32 },
 Write(String),
 ChangeColor(i32, i32, i32),
}

fn main() {
 // let msgs: __ = [
 // Message::Quit,
 // Message::Move{x:1, y:3},
 // Message::ChangeColor(255,255,0)
 // ];
 let msgs: [Message; 3] = [
 Message::Quit,
 Message::Move{x:1, y:3},
 Message::ChangeColor(255,255,0)
 ];

 for msg in msgs {
 show_message(msg)
 }
}

fn show_message(msg: Message) {
 // println!("{}", msg);
 println!("{:?}", msg);
}

🌟🌟 Rust 中没有 null，我们通过 Option<T> 枚举来处理值为空的情况

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 填空让 `println` 输出，同时添加一些代码不要让最后一行的 `panic` 执行到
fn main() {
 let five = Some(5);
 let six = plus_one(five);
 let none = plus_one(None);

 // if let __ = six {
 // println!("{}", n)
 // }

 if let Some(n) = six {
 println!("{}", n);
 return
 }

 panic!("不要让这行代码运行！");
}

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

🌟🌟🌟🌟 使用枚举来实现链表.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65



// 填空，让代码运行
use crate::List::*;

enum List {
 // Cons: 链表中包含有值的节点，节点是元组类型，第一个元素是节点的值，第二个元素是指向下一个节点的指针
 Cons(u32, Box<List>),
 // Nil: 链表中的最后一个节点，用于说明链表的结束
 Nil,
}

// 为枚举实现一些方法
impl List {
 // 创建空的链表
 fn new() -> List {
 // 因为没有节点，所以直接返回 Nil 节点
 // 枚举成员 Nil 的类型是 List
 Nil
 }

 // 在老的链表前面新增一个节点，并返回新的链表
 // fn prepend(self, elem: u32) -> __ {
 fn prepend(self, elem: u32) -> List {
 Cons(elem, Box::new(self))
 }

 // 返回链表的长度
 fn len(&self) -> u32 {
 match *self {
 // 这里我们不能拿走 tail 的所有权，因此需要获取它的引用
 // Cons(_, __ tail) => 1 + tail.len(),
 Cons(_, ref tail) => 1 + tail.len(),
 // 空链表的长度为 0
 Nil => 0
 }
 }

 // 返回链表的字符串表现形式，用于打印输出
 fn stringify(&self) -> String {
 match *self {
 Cons(head, ref tail) => {
 // 递归生成字符串
 // format!("{}, {}", head, tail.__())
 format!("{}, {}", head, tail.stringify())
 },
 Nil => {
 format!("Nil")
 },
 }
 }
}

fn main() {
 // 创建一个新的链表(也是空的)
 let mut list = List::new();

 // 添加一些元素
 list = list.prepend(1);
 list = list.prepend(2);
 list = list.prepend(3);

 // 打印列表的当前状态
 println!("链表的长度是: {}", list.len());
 println!("{}", list.stringify());
}

你可以在这里找到答案(在 solutions 路径下)

第6章 复合类型 on 编程那些事儿

01-字符串

字符串

str 和 &str

String

02-数组

数组

03-切片

切片

04-元组

元组

05-结构体

结构体

三种类型的结构体

结构体上的一些操作

打印结构体

结构体的所有权

06-枚举

枚举

第6章复合类型 on 编程那些事儿

`str` 和 `&str`