【Rust入门知识点学与练】第24课：Trait 基础

知识点：定义和实现 Trait

Trait 定义了一组行为（方法），类型可以实现这些行为：

// 定义 trait
trait Speak {
fn speak(&self) -> String; // 必须实现的方法
fn greet(&self) -> String { // 带默认实现的方法
format!("你好！")
}
}

// 为不同类型实现 trait
struct Dog {
name: String,
}

struct Cat {
name: String,
}

impl Speak for Dog {
fn speak(&self) -> String {
format!("{}说：汪汪！", self.name)
}
// greet 使用默认实现
}

impl Speak for Cat {
fn speak(&self) -> String {
format!("{}说：喵~", self.name)
}

// 覆盖默认实现
fn greet(&self) -> String {
format!("{}懒洋洋地看了你一眼", self.name)
}
}

fn main() {
let dog = Dog { name: String::from("旺财") };
let cat = Cat { name: String::from("咪咪") };

println!("{}", dog.speak()); // 旺财说：汪汪！
println!("{}", dog.greet()); // 你好！
println!("{}", cat.speak()); // 咪咪说：喵~
println!("{}", cat.greet()); // 咪咪懒洋洋地看了你一眼
}

知识点：派生宏（derive）

标准库提供了很多可以自动实现的 trait：

// #[derive(…)] 自动实现常见 trait
#[derive(Debug, Clone, PartialEq)]
struct Point {
x: f64,
y: f64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Color {
r: u8,
g: u8,
b: u8,
}

// 常用可派生的 trait：
// Debug — {:?} 格式化
// Clone — .clone() 深拷贝
// Copy — 自动按位复制（不能和 Drop 共存）
// PartialEq — == 和 !=
// Eq — 完全等价关系（要求 PartialEq）
// PartialOrd — < > <= >=
// Ord — 全序关系
// Hash — 可作为 HashMap 的键
// Default — 默认值

fn main() {
let p1 = Point { x: 1.0, y: 2.0 };
let p2 = p1.clone();
println!("p1: {:?}", p1);
println!("相等? {}", p1 == p2);

let red = Color { r: 255, g: 0, b: 0 };
println!("颜色: {:?}", red);

// Default trait
let default_point = Point { x: 0.0, y: 0.0 };
// 也可以手动实现 Default
}

// 手动实现 Default
impl Default for Point {
fn default() -> Self {
Point { x: 0.0, y: 0.0 }
}
}

知识点：Trait 作为参数

trait Area {
fn area(&self) -> f64;
}

struct Circle { radius: f64 }
struct Rectangle { width: f64, height: f64 }

impl Area for Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * self.radius * self.radius
}
}

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

// 方式1：impl Trait 语法（简洁）
fn print_area(shape: &impl Area) {
println!("面积: {:.2}", shape.area());
}

// 方式2：泛型 + trait bound（更灵活）
fn print_area2<T: Area>(shape: &T) {
println!("面积: {:.2}", shape.area());
}

// 方式3：where 子句（多个 bound 时更清晰）
fn compare_areas<T: Area + std::fmt::Debug>(a: &T, b: &T) {
let area_a = a.area();
let area_b = b.area();
if area_a > area_b {
println!("{:?} 更大", a);
} else {
println!("{:?} 更大", b);
}
}

// 返回 trait 对象（动态分发）
fn create_shape(kind: &str) -> Box<dyn Area> {
match kind {
"circle" => Box::new(Circle { radius: 5.0 }),
"rectangle" => Box::new(Rectangle { width: 3.0, height: 4.0 }),
_ => panic!("未知形状"),
}
}

fn main() {
let circle = Circle { radius: 3.0 };
let rect = Rectangle { width: 4.0, height: 5.0 };

print_area(&circle); // 面积: 28.27
print_area(&rect); // 面积: 20.00

// 动态分发
let shape = create_shape("circle");
println!("动态面积: {:.2}", shape.area());
}

知识点：多个 Trait Bound

use std::fmt;

trait Drawable {
fn draw(&self);
}

trait Resizable {
fn resize(&mut self, factor: f64);
}

#[derive(Debug)]
struct Box {
size: f64,
}

impl Drawable for Box {
fn draw(&self) {
println!("绘制大小为 {} 的盒子", self.size);
}
}

impl Resizable for Box {
fn resize(&mut self, factor: f64) {
self.size *= factor;
}
}

impl fmt::Display for Box {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Box(size={})", self.size)
}
}

// 要求同时实现多个 trait
fn process<T: Drawable + Resizable + fmt::Display>(item: &mut T) {
println!("处理前: {}", item);
item.draw();
item.resize(2.0);
println!("处理后: {}", item);
item.draw();
}

// where 子句写法（更清晰）
fn process2<T>(item: &mut T)
where
T: Drawable + Resizable + fmt::Display,
{
println!("处理前: {}", item);
item.resize(0.5);
item.draw();
}

fn main() {
let mut b = Box { size: 10.0 };
process(&mut b);
}

知识点：trait 对象与 dyn

use std::fmt;

trait Animal: fmt::Display {
fn name(&self) -> &str;
fn sound(&self) -> &str;
}

struct Cow;
struct Sheep;

impl fmt::Display for Cow {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "牛")
}
}

impl fmt::Display for Sheep {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "羊")
}
}

impl Animal for Cow {
fn name(&self) -> &str { "牛" }
fn sound(&self) -> &str { "哞~" }
}

impl Animal for Sheep {
fn name(&self) -> &str { "羊" }
fn sound(&self) -> &str { "咩~" }
}

// 用 Box<dyn Trait> 存储不同类型的 trait 实现
fn make_noise(animal: &dyn Animal) {
println!("{}说：{}", animal.name(), animal.sound());
}

fn main() {
let animals: Vec<Box<dyn Animal>> = vec![
Box::new(Cow),
Box::new(Sheep),
Box::new(Cow),
];

// 动态分发：遍历不同类型的动物
for animal in &animals {
make_noise(animal.as_ref());
}

// 也可以用 &dyn Trait
let cow = Cow;
make_noise(&cow);
}

知识点：为泛型类型实现 Trait

use std::fmt;

// 泛型结构体
#[derive(Debug)]
struct Wrapper<T> {
value: T,
}

// 为泛型类型实现 trait
impl<T: fmt::Display> fmt::Display for Wrapper<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[{}]", self.value)
}
}

// 为泛型类型实现自定义 trait
trait Unwrap {
type Inner;
fn unwrap_value(self) -> Self::Inner;
}

impl<T> Unwrap for Wrapper<T> {
type Inner = T;
fn unwrap_value(self) -> T {
self.value
}
}

fn main() {
let w = Wrapper { value: 42 };
println!("{}", w); // [42]

let w2 = Wrapper { value: String::from("hello") };
println!("{}", w2); // [hello]

let val = w2.unwrap_value();
println!("解包: {}", val);
}

核心规则

概念 写法
定义 trait trait Name { fn method(&self); }
实现 trait impl Name for Type { … }
默认方法 fn method(&self) -> T { … }
派生宏 #[derive(Debug, Clone, PartialEq)]
impl Trait 参数 fn foo(x: &impl Trait)
泛型 + bound fn foo<T: Trait>(x: &T)
where 子句 fn foo(x: &T) where T: Trait
多个 bound T: Trait1 + Trait2
trait 对象 Box / &dyn Trait
返回 trait 对象 -> Box

动手试试

补全下面的代码：

use std::fmt;

// 补全：定义一个 trait Shape，包含以下方法：
// 1. area(&self) -> f64 计算面积
// 2. perimeter(&self) -> f64 计算周长
// 3. describe(&self) -> String 返回描述（有默认实现）
// 默认实现返回格式: "面积={:.2}, 周长={:.2}"

// 补全：定义结构体 Triangle，字段为 a, b, c（三边长度，f64）

// 补全：为 Triangle 实现 Shape trait
// 面积用海伦公式：s = (a+b+c)/2, area = sqrt(s*(s-a)*(s-b)*(s-c))
// 周长 = a + b + c

// 补全：为 Triangle 实现 Display trait
// 格式: "三角形({},{},{})", a, b, c

// 补全：定义结构体 RegularPolygon（正多边形）
// 字段：sides: usize（边数）, side_length: f64（边长）

// 补全：为 RegularPolygon 实现 Shape trait
// 面积 = (n * s²) / (4 * tan(π/n))
// 周长 = n * s

// 补全：为 RegularPolygon 实现 Display trait
// 格式: "正{n}边形(边长={})", sides, side_length

// 补全：实现函数 largest_shape
// 接受一个 &[Box<dyn Shape>]，返回面积最大的形状的索引
fn largest_shape(shapes: &[Box<dyn Shape>]) -> usize {
// 补全
todo!()
}

// 补全：实现函数 total_area
// 接受一个 &[Box<dyn Shape>]，返回所有形状的面积之和
fn total_area(shapes: &[Box<dyn Shape>]) -> f64 {
// 补全
todo!()
}

fn main() {
// 补全：创建形状列表
// 1. 三角形 (3, 4, 5)
// 2. 正方形（正4边形，边长 5）
// 3. 正六边形（边长 3）
// 4. 三角形 (5, 12, 13)

// 补全：遍历打印每个形状的描述
// 期望输出（每行一个）:
// 三角形(3,4,5): 面积=6.00, 周长=12.00
// 正4边形(边长=5): 面积=25.00, 周长=20.00
// 正6边形(边长=3): 面积=23.38, 周长=18.00
// 三角形(5,12,13): 面积=30.00, 周长=30.00

// 补全：打印最大面积的索引
// 期望: 最大面积索引: 3

// 补全：打印总面积
// 期望: 总面积: 84.38
}

期望输出：
三角形(3,4,5): 面积=6.00, 周长=12.00
正4边形(边长=5): 面积=25.00, 周长=20.00
正6边形(边长=3): 面积=23.38, 周长=18.00
三角形(5,12,13): 面积=30.00, 周长=30.00
最大面积索引: 3
总面积: 84.38

写好了贴过来，没问题就进入第25课：格式化输出与常用标准库 👋

贴代码

use std::fmt;
use std::f64::consts::PI;

// Shape trait，describe 提供默认实现
trait Shape {
fn area(&self) -> f64;
fn perimeter(&self) -> f64;

fn describe(&self) -> String {
format!("面积={:.2}, 周长={:.2}", self.area(), self.perimeter())
}
}

// 三角形结构体
struct Triangle {
a: f64,
b: f64,
c: f64,
}

impl Shape for Triangle {
fn area(&self) -> f64 {
let s = (self.a + self.b + self.c) / 2.0;
(s * (s – self.a) * (s – self.b) * (s – self.c)).sqrt()
}

fn perimeter(&self) -> f64 {
self.a + self.b + self.c
}
}

impl fmt::Display for Triangle {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "三角形({},{},{})", self.a, self.b, self.c)
}
}

// 正多边形
struct RegularPolygon {
sides: usize,
side_length: f64,
}

impl Shape for RegularPolygon {
fn area(&self) -> f64 {
let n = self.sides as f64;
let s = self.side_length;
(n * s * s) / (4.0 * (PI / n).tan())
}

fn perimeter(&self) -> f64 {
(self.sides as f64) * self.side_length
}
}

impl fmt::Display for RegularPolygon {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "正{}边形(边长={})", self.sides, self.side_length)
}
}

// 返回面积最大形状的索引
fn largest_shape(shapes: &[Box<dyn Shape>]) -> usize {
shapes
.iter()
.enumerate()
.max_by(|(_, s1), (_, s2)| s1.area().partial_cmp(&s2.area()).unwrap())
.map(|(idx, _)| idx)
.unwrap()
}

// 全部形状面积之和
fn total_area(shapes: &[Box<dyn Shape>]) -> f64 {
shapes.iter().map(|s| s.area()).sum()
}

fn main() {
// 创建动态形状数组
let shapes: Vec<Box<dyn Shape>> = vec![
Box::new(Triangle { a: 3.0, b: 4.0, c: 5.0 }),
Box::new(RegularPolygon { sides: 4, side_length: 5.0 }),
Box::new(RegularPolygon { sides: 6, side_length: 3.0 }),
Box::new(Triangle { a: 5.0, b: 12.0, c: 13.0 }),
];

// 遍历打印
for s in &shapes {
// 需要同时拿到Display和Shape，这里分开处理；为了方便我们重新包装
// 为了满足打印 "三角形(3,4,5): 面积=6.00, 周长=12.00"，
// dyn Shape 本身没有Display，所以我们改用模式匹配打印（练习版本）
// 下面主循环完整实现
}

// 方案：重建带打印的版本，完整main实现：
let tri1 = Triangle { a: 3.0, b: 4.0, c: 5.0 };
let sq = RegularPolygon { sides: 4, side_length: 5.0 };
let hex = RegularPolygon { sides: 6, side_length: 3.0 };
let tri2 = Triangle { a: 5.0, b: 12.0, c: 13.0 };

let shape_vec: Vec<Box<dyn Shape>> = vec![
Box::new(tri1),
Box::new(sq),
Box::new(hex),
Box::new(tri2),
];

// 注意：dyn Shape 不能直接Display；为了完成题目输出，下面把对象再存一份用于打印
// 完整版main（保存各个实体用于格式化输出）
let items = [
(&Triangle { a: 3.0, b: 4.0, c: 5.0 }) as &dyn fmt::Display,
&RegularPolygon { sides: 4, side_length: 5.0 } as &dyn fmt::Display,
&RegularPolygon { sides: 6, side_length: 3.0 } as &dyn fmt::Display,
&Triangle { a: 5.0, b: 12.0, c: 13.0 } as &dyn fmt::Display,
];

for i in 0..shape_vec.len() {
println!("{}: {}", items[i], shape_vec[i].describe());
}

let max_idx = largest_shape(&shape_vec);
println!("最大面积索引: {}", max_idx);

let sum = total_area(&shape_vec);
println!("总面积: {:.2}", sum);
}

运行输出

plaintext

三角形(3,4,5): 面积=6.00, 周长=12.00
正4边形(边长=5): 面积=25.00, 周长=20.00
正6边形(边长=3): 面积=23.38, 周长=18.00
三角形(5,12,13): 面积=30.00, 周长=30.00
最大面积索引: 3
总面积: 84.38

核心知识点

1. Trait 默认方法

fn describe(&self) -> String { … }

没有 &self 前面没有 dyn ，直接写在trait里面，不用每个实现者重复实现。

2. 海伦公式（三角形面积）

s=(a+b+c)/2,\\quad area=\\sqrt{s(s–a)(s–b)(s–c)}

3. 正多边形面积公式

A=\\dfrac{n\\cdot s^{2}}{4\\cdot\\tan(\\pi/n)}

需要 std::f64::consts::PI 。

**4. Trait 对象（动态分发） Box **

• Box ：堆分配，运行时动态调用 area/perimeter；
• 一个Vec里面存放不同类型（Triangle、RegularPolygon）的形状；
• 限制：一个trait对象不能同时拥有多个不同trait（Shape+Display），所以main中分开两份引用，一份做Shape运算，一份做Display打印，这是Rust经典坑点。

5. largest_shape

enumerate 带上索引， max_by ，f64比较用 partial_cmp （因为存在NaN）。

6. total_area

迭代器map + sum，一行代码完成求和。

Rust 面向对象（Trait对象）训练到此结束

现在Rust全套主线练习题：基础 → 所有权 → 生命周期 → 泛型 → trait（关联类型）→ 闭包迭代器 → 容器 → 宏 → 自定义迭代器 → trait对象动态多态 → 错误处理 → 多线程（Arc‑Mutex‑channel）全部通关。