第4章基本类型 on 编程那些事儿

01-数值类型

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

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

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

数值类型

整数

🌟

Tips: 如果我们没有显式的给予变量一个类型，那编译器会自动帮我们推导一个类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



// 移除某个部分让代码工作
fn main() {
 let x: i32 = 5;
 let mut y: u32 = 5;

 y = x;
 
 let z = 10; // 这里 z 的类型是? i32
}

🌟

1
2
3
4
5
6



// 填空
fn main() {
 // let v: u16 = 38_u8 as __;
 let v: u16 = 38_u8 as u16;
}

🌟🌟🌟

Tips: 如果我们没有显式的给予变量一个类型，那编译器会自动帮我们推导一个类型

02-字符、布尔、单元类型

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

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

原文链接: https://practice-rust-zh.beatai.org/basic-types/char-bool-unit.html

字符、布尔、单元类型

字符

🌟

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


// 修改2处 `assert_eq!` 让代码工作

use std::mem::size_of_val;
fn main() {
 let c1 = 'a';
 // assert_eq!(size_of_val(&c1),1); 
 assert_eq!(size_of_val(&c1),4); 

 let c2 = '中';
 // assert_eq!(size_of_val(&c2),3); 
 assert_eq!(size_of_val(&c2),4); 

 println!("Success!")
} 

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 修改一行让代码正常打印
fn main() {
 // let c1 = "中";
 let c1 = '中';
 print_char(c1);
} 

fn print_char(c : char) {
 println!("{}", c);
}

布尔

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11



// 使成功打印
fn main() {
 let _f: bool = false;

 // let t = true;
 let t = false;
 if !t {
 println!("Success!")
 }
} 

🌟

1
2
3
4
5
6
7
8



fn main() {
 let f = true;
 let t = true || false;
 assert_eq!(t, f);

 println!("Success!")
}

单元类型

🌟🌟

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



// 让代码工作，但不要修改 `implicitly_ret_unit` !
fn main() {
 // let _v: () = ();
 let v0: () = ();

 let v = (2, 3);
 // assert_eq!(_v, implicitly_ret_unit());
 assert_eq!(v0, implicitly_ret_unit());

 println!("Success!")
}

fn implicitly_ret_unit() {
 println!("I will return a ()")
}

// 不要使用下面的函数，它只用于演示！
fn explicitly_ret_unit() -> () {
 println!("I will return a ()")
}

🌟🌟 单元类型占用的内存大小是多少？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



// 让代码工作：修改 `assert!` 中的 `4` 
use std::mem::size_of_val;
fn main() {
 let unit: () = ();
 // assert!(size_of_val(&unit) == 4);
	assert!(size_of_val(&unit) == 0);
 
 println!("Success!")
}

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

03-语句与表达式

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

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

原文链接: https://practice-rust-zh.beatai.org/basic-types/statements-expressions.html

语句与表达式

示例

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


fn main() {
 let x = 5u32;

 let y = {
 let x_squared = x * x;
 let x_cube = x_squared * x;

 // 下面表达式的值将被赋给 `y`
 x_cube + x_squared + x
 };

 let z = {
 // 分号让表达式变成了语句，因此返回的不再是表达式 `2 * x` 的值，而是语句的值 `()`
 2 * x;
 };

 println!("x is {:?}", x);
 println!("y is {:?}", y);
 println!("z is {:?}", z);
}

练习

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 使用两种方法让代码工作起来
fn main() {
 let v = {
 let mut x = 1;
 x += 2
 };

 // assert_eq!(v, 3);
 assert_eq!(v, ());
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



fn main() {
 // let v = (let x = 3);
 let v = {
 let x = 3;
 x
 };

 assert!(v == 3);
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



fn main() {
 let s = sum(1 , 2);
 assert_eq!(s, 3);
}

fn sum(x: i32, y: i32) -> i32 {
	// x + y;
 x + y
}

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

04-函数

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

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

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

函数

🌟🌟🌟

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



fn main() {
 // 不要修改下面两行代码!
 let (x, y) = (1, 2);
 let s = sum(x, y);

 assert_eq!(s, 3);
}

// fn sum(x, y: i32) {
// x + y;
// }
fn sum(x: i32, y: i32) -> i32 {
 x + y
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


fn main() {
 print();
}

// 使用另一个类型来替代 i32
// fn print() -> i32 {
// println!("hello,world");
// }
fn print() -> () {
 println!("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
24
25
26


// 用两种方法求解
fn main() {
 never_return();
}

fn never_return() -> ! {
 // 实现这个函数，不要修改函数签名!
 panic!("I return nothing!")
}

// ---
fn main() {
 never_return();
}

use std::thread;
use std::time;

fn never_return() -> ! {
 // implement this function, don't modify fn signatures
 loop {
 println!("I return nothing");
 // sleeping for 1 second to avoid exhausting the cpu resource
 thread::sleep(time::Duration::from_secs(1))
 }
}

🌟🌟 发散函数( Diverging function )不会返回任何值，因此它们可以用于替代需要返回任何值的地方

 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



fn main() {
 println!("Success!");
}

fn get_option(tp: u8) -> Option<i32> {
 match tp {
 1 => {
 // TODO
 }
 _ => {
 // TODO
 }
 };
 
 // 这里与其返回一个 None，不如使用发散函数替代
 never_return_fn()
}

// 使用三种方法实现以下发散函数
fn never_return_fn() -> ! {
 unimplemented!()
}

fn never_return_fn() -> ! {
 panic!()
}

fn never_return_fn() -> ! {
 todo!();
}

fn never_return_fn() -> ! {
 loop {
 std::thread::sleep(std::time::Duration::from_secs(1))
 }
}

🌟🌟

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



fn main() {
 // 填空
 // let b = __;
 let b = false;
 let _v = match b {
 true => 1,
 // 发散函数也可以用于 `match` 表达式，用于替代任何类型的值
 false => {
 println!("Success!");
 panic!("we have no value for `false`, but we can panic")
 }
 };

 println!("Exercise Failed if printing out this line!");
}

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

第4章 基本类型 on 编程那些事儿

01-数值类型

数值类型

整数

02-字符、布尔、单元类型

字符、布尔、单元类型

字符

布尔

单元类型

03-语句与表达式

语句与表达式

示例

练习

04-函数

函数

第4章基本类型 on 编程那些事儿