自定义类型
上一章讲了 Rust 的基础语法——变量、函数、控制流。这些都是"标量数据 + 简单函数"级别的。实际写代码时,你几乎立刻会想到自己定义类型——比如"我要一个 Point 表示点"、"我要一个 Result 表示成功或失败"。
Rust 里自定义类型主要靠三种东西:结构体 struct、枚举 enum、类型别名 type。这一章讲这三个,重点是枚举——Rust 里最好的抽象工具之一。
1. 结构体(struct)
基本形式:
struct Point {
x: f64,
y: f64,
}
let p = Point { x: 1.0, y: 2.0 };
println!("{}, {}", p.x, p.y);
几个细节:
- 字段必须都初始化——不能
Point { x: 1.0 },会报错; - 字段访问:
.x、.y; mut在变量上:let mut p = ...后可以改字段。
字段初始化简写:变量名和字段名一样时可以省略:
fn new(x: f64, y: f64) -> Point {
Point { x, y } // 等价于 Point { x: x, y: y }
}
结构体更新语法:从另一个结构体复制大部分字段:
let p1 = Point { x: 1.0, y: 2.0 };
let p2 = Point { x: 10.0, ..p1 }; // y 从 p1 复制
2. 元组结构体
只有类型没有字段名:
struct Color(u8, u8, u8);
struct Meters(f64);
let red = Color(255, 0, 0);
let dist = Meters(10.5);
let r = red.0; // 用索引访问
用途:
- 单字段的 wrapper:
Meters(f64)让"米"和"英尺"在类型层面区分——类型安全; - 短小的一次性类型:像 RGB 这种字段名多此一举的。
别滥用——大多数场景普通 struct 更清晰。
3. 单元结构体(Unit Struct)
没有任何 字段:
struct AlwaysEqual;
let a = AlwaysEqual;
看起来没用?其实有用——Marker types:你要一个只承担类型功能的东西(比如 trait 的实现载体),Unit Struct 是零开销的选择。
4. 方法:给类型加行为
impl 块:
struct Rectangle {
width: f64,
height: f64,
}
impl Rectangle {
// 关联函数(类似静态方法,不用 self)
fn new(w: f64, h: f64) -> Self {
Self { width: w, height: h }
}
fn square(size: f64) -> Self {
Self { width: size, height: size }
}
// 方法(第一个参数是 self)
fn area(&self) -> f64 {
self.width * self.height
}
fn scale(&mut self, factor: f64) {
self.width *= factor;
self.height *= factor;
}
fn consume(self) -> f64 {
// 这个方法拿走了 self 的所有权
self.width + self.height
}
}
let mut r = Rectangle::new(3.0, 4.0);
let a = r.area(); // &self
r.scale(2.0); // &mut self
let sum = r.consume(); // self(r 被移走了,不能再用)
三种 self:
&self:只读借用——大部分只读方法用它;&mut self:可变借用——需要修改字段;self:拿走所有权——通常用在"消费自己产生一个新东西"的场景(比如 builder pattern)。
关联函数 vs 方法:
- 用
::调用关联函数:Rectangle::new(1.0, 2.0); - 用
.调用方法:r.area()。
多个 impl 块:一个类型可以有多个 impl 块(同文件或分散在多个文件),编译器合并:
impl Rectangle {
fn area(&self) -> f64 { ... }
}
impl Rectangle {
fn perimeter(&self) -> f64 { ... }
}
5. 枚举(enum):Rust 的秘密武器
这是 Rust 最重要的类型工具之一。它比 C 的 enum 或 Java 的 enum 强大得多——每个变体可以带自己的数据。
最简单的形式:
enum Direction {
North,
South,
East,
West,
}
let d = Direction::North;
看起来和 C 一样。但 Rust 的 enum 允许每个变体带数据:
enum Shape {
Circle(f64), // 半径
Rectangle(f64, f64), // 宽、高
Triangle { a: f64, b: f64, c: f64 }, // 三边(命名字段)
}
let c = Shape::Circle(5.0);
let r = Shape::Rectangle(3.0, 4.0);
let t = Shape::Triangle { a: 3.0, b: 4.0, c: 5.0 };
每个变体的"内部数据"不一样——但它们都是 Shape 类型。这个能力叫做**"和类型(sum type)"或"tagged union"**——是函数式语言的核心概念,C/Java 没有。
6. match 处理枚举
match 是使用 enum 的核心工具:
fn area(shape: &Shape) -> f64 {
match shape {
Shape::Circle(r) => 3.14 * r * r,
Shape::Rectangle(w, h) => w * h,
Shape::Triangle { a, b, c } => {
let s = (a + b + c) / 2.0;
(s * (s - a) * (s - b) * (s - c)).sqrt()
}
}
}
关键点:
- 必须穷尽所有变体(或者用
_); - 每个 arm 里可以直接取出变体的数据(
r、w、h); - 加了新变体,所有
match都会编译错误——这是好事,保证你不会漏掉处理。
7. Option:处理"可能没有值"
Option 是 Rust 标准库里的一个 enum,替代了很多语言里的 null:
enum Option<T> {
None,
Some(T),
}
用来表达"这个值可能存在也可能不存在"。Rust 没有 null——所有可能不存在的值都必须用 Option:
fn find_user(id: u32) -> Option<String> {
if id == 1 {
Some(String::from("Alice"))
} else {
None
}
}
let user = find_user(1);
match user {
Some(name) => println!("Found: {}", name),
None => println!("Not found"),
}
这是 Rust 一个绝妙的设计——编译期强 制你处理"可能为空"的情况。C/Java 里 NullPointerException 是常见 bug,Rust 里根本不可能——编译器会拒绝你把 Option<T> 当 T 用。
Option 的常用方法:
let x: Option<i32> = Some(5);
x.unwrap(); // 拿出值,None 时 panic
x.unwrap_or(0); // None 时用默认值
x.expect("shouldn't be None"); // 带自定义 panic 消息
x.map(|v| v * 2); // 转换 Some 里的值
x.is_some();
x.is_none();