第10章泛型和特征 on 编程那些事儿

01-泛型

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

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

原文链接: https://practice-rust-zh.beatai.org/generics-traits/generics.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



// 填空
struct A; // 具体的类型 `A`.
struct S(A); // 具体的类型 `S`.
struct SGen<T>(T); // 泛型 `SGen`.

fn reg_fn(_s: S) {}

fn gen_spec_t(_s: SGen<A>) {}

fn gen_spec_i32(_s: SGen<i32>) {}

fn generic<T>(_s: SGen<T>) {}

fn main() {
 // 使用非泛型函数
 reg_fn(__); // 具体的类型
 gen_spec_t(__); // 隐式地指定类型参数 `A`.
 gen_spec_i32(__); // 隐式地指定类型参数`i32`.

 // 显式地指定类型参数 `char`
 generic::<char>(__);

 // 隐式地指定类型参数 `char`.
 generic(__);
}

🌟🌟

1
2
3
4
5
6
7
8
9



// 实现下面的泛型函数 sum
fn sum

fn main() {
 assert_eq!(5, sum(2i8, 3i8));
 assert_eq!(50, sum(20, 30));
 assert_eq!(2.46, sum(1.23, 1.23));
}

结构体和 `impl`

🌟

1
2
3
4
5
6
7
8



// 实现一个结构体 Point 让代码工作


fn main() {
 let integer = Point { x: 5, y: 10 };
 let float = Point { x: 1.0, y: 4.0 };
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11



// 修改以下结构体让代码工作
struct Point<T> {
 x: T,
 y: T,
}

fn main() {
 // 不要修改这行代码！
 let p = Point{x: 5, y : "hello".to_string()};
}

🌟🌟

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



// 为 Val 增加泛型参数，不要修改 `main` 中的代码
struct Val {
 val: f64,
}

impl Val {
 fn value(&self) -> &f64 {
 &self.val
 }
}


fn main() {
 let x = Val{ val: 3.0 };
 let y = Val{ val: "hello".to_string()};
 println!("{}, {}", x.value(), y.value());
}

方法

🌟🌟🌟

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


struct Point<T, U> {
 x: T,
 y: U,
}

impl<T, U> Point<T, U> {
 // 实现 mixup，不要修改其它代码！
 fn mixup
}

fn main() {
 let p1 = Point { x: 5, y: 10 };
 let p2 = Point { x: "Hello", y: '中'};

 let p3 = p1.mixup(p2);

 assert_eq!(p3.x, 5);
 assert_eq!(p3.y, '中');
}

🌟🌟

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



// 修复错误，让代码工作
struct Point<T> {
 x: T,
 y: T,
}

impl Point<f32> {
 fn distance_from_origin(&self) -> f32 {
 (self.x.powi(2) + self.y.powi(2)).sqrt()
 }
}

fn main() {
 let p = Point{x: 5, y: 10};
 println!("{}",p.distance_from_origin())
}

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

02-Const 泛型

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

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

原文链接: https://practice-rust-zh.beatai.org/generics-traits/const-generics.html

Const 泛型

在之前的泛型中，可以抽象为一句话：针对类型实现的泛型，所有的泛型都是为了抽象不同的类型，那有没有针对值的泛型？答案就是 Const 泛型。

03-特征 Traits

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

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

原文链接: https://practice-rust-zh.beatai.org/generics-traits/traits.html

特征 Traits

特征 Trait 可以告诉编译器一个特定的类型所具有的、且能跟其它类型共享的特性。我们可以使用特征通过抽象的方式来定义这种共享行为，还可以使用特征约束来限定一个泛型类型必须要具有某个特定的行为。

04-特征对象

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

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

原文链接: https://practice-rust-zh.beatai.org/generics-traits/trait-object.html

特征对象

在特征练习中我们已经知道当函数返回多个类型时，impl Trait 是无法使用的。

对于数组而言，其中一个限制就是无法存储不同类型的元素，但是通过之前的学习，大家应该知道枚举可以在部分场景解决这种问题，但是这种方法局限性较大。此时就需要我们的主角登场了。

05-进一步深入特征

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

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

原文链接: https://practice-rust-zh.beatai.org/generics-traits/advanced-traits.html

进一步深入特征

关联类型

关联类型主要用于提升代码的可读性，例如以下代码 :

1
2
3
4


pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable {
 type Address: AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash;
 fn is_null(&self) -> bool;
}

相比 AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash， Address 的使用可以极大的减少其它类型在实现该特征时所需的模版代码.

第10章 泛型和特征 on 编程那些事儿

01-泛型

泛型

函数

结构体和 impl

方法

02-Const 泛型

Const 泛型

03-特征 Traits

特征 Traits

04-特征对象

特征对象

05-进一步深入特征

进一步深入特征

关联类型

第10章泛型和特征 on 编程那些事儿

结构体和 `impl`