06-rust基础 枚举-Enum

在 Rust 中,enum 是一种非常强大的类型,它允许定义一组具有关联性的可能值。与许多编程语言中的枚举不同,Rust 的枚举不仅可以是简单的枚举值,还可以包含数据,甚至可以和结构体一样复杂。

以下是对 enum 的全面学习和总结:


1. 基本枚举

枚举的基本形式是定义一组可能的值:

enum Direction {
North,
South,
East,
West,
}
fn move_direction(direction: Direction) {
match direction {
Direction::North => println!("Going North"),
Direction::South => println!("Going South"),
Direction::East => println!("Going East"),
Direction::West => println!("Going West"),
}
}
fn main() {
let direction = Direction::North;
move_direction(direction);
}

特点:

  • 每个变体可以直接被匹配和使用。
  • 使用 match 是处理枚举的主要方式。

2. 枚举变体可以携带数据

与普通的枚举不同,Rust 的 enum 允许为每个变体附加数据。

enum Shape {
Circle(f64), // 半径
Rectangle(f64, f64), // 宽度和高度
Triangle { base: f64, height: f64 }, // 使用结构体样式的字段
}
fn area(shape: Shape) -> f64 {
match shape {
Shape::Circle(radius) => 3.14 * radius * radius,
Shape::Rectangle(width, height) => width * height,
Shape::Triangle { base, height } => 0.5 * base * height,
}
}
fn main() {
let circle = Shape::Circle(5.0);
let rectangle = Shape::Rectangle(3.0, 4.0);
let triangle = Shape::Triangle { base: 6.0, height: 4.0 };
println!("Circle area: {}", area(circle));
println!("Rectangle area: {}", area(rectangle));
println!("Triangle area: {}", area(triangle));
}

特点:

  • 每个变体可以携带不同类型和数量的数据。
  • 可使用结构体风格来定义字段以增加可读性。

3. Option 和 Result 是枚举

OptionResult 是 Rust 标准库中定义的两个非常常见的枚举。

Option

Option 表示一个值可能存在,也可能不存在:

fn divide(a: f64, b: f64) -> Option<f64> {
if b != 0.0 {
Some(a / b)
} else {
None
}
}
fn main() {
let result = divide(4.0, 2.0);
match result {
Some(value) => println!("Result is: {}", value),
None => println!("Cannot divide by zero!"),
}
}

Result

Result 表示一个操作可能成功,也可能失败:

fn divide(a: f64, b: f64) -> Result<f64, String> {
if b != 0.0 {
Ok(a / b)
} else {
Err(String::from("Cannot divide by zero"))
}
}
fn main() {
match divide(4.0, 0.0) {
Ok(value) => println!("Result is: {}", value),
Err(err) => println!("Error: {}", err),
}
}

特点:

  • OptionResult 都是枚举,使用非常广泛。
  • 通过 match 或者 .unwrap() 等方法处理其值。

4. 方法实现

可以为枚举实现方法,增强其实用性。

enum TrafficLight {
Red,
Yellow,
Green,
}
impl TrafficLight {
fn action(&self) {
match self {
TrafficLight::Red => println!("Stop!"),
TrafficLight::Yellow => println!("Prepare to stop."),
TrafficLight::Green => println!("Go!"),
}
}
}
fn main() {
let light = TrafficLight::Green;
light.action();
}

5. 使用 #[derive] 自动生成功能

可以为枚举派生一些常见的特性,如 DebugClonePartialEq 等。

#[derive(Debug, PartialEq)]
enum Status {
Active,
Inactive,
Suspended,
}
fn main() {
let status = Status::Active;
println!("{:?}", status);
if status == Status::Active {
println!("The status is active!");
}
}

6. 枚举的泛型支持

枚举可以使用泛型来增加灵活性:

enum Container<T> {
Some(T),
None,
}
fn main() {
let number: Container<i32> = Container::Some(42);
let text: Container<&str> = Container::Some("Hello");
match number {
Container::Some(value) => println!("Number: {}", value),
Container::None => println!("No number"),
}
match text {
Container::Some(value) => println!("Text: {}", value),
Container::None => println!("No text"),
}
}

7. matchif let 的使用

处理枚举时,if let 是一种简洁的方式:

enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let coin = Coin::Quarter;
// 使用 match
match coin {
Coin::Penny => println!("It's a penny."),
Coin::Nickel => println!("It's a nickel."),
Coin::Dime => println!("It's a dime."),
Coin::Quarter => println!("It's a quarter."),
}
// 使用 if let
if let Coin::Quarter = coin {
println!("It's a quarter.");
}
}

8. 总结

Rust 中的枚举是一个非常强大的工具,用于表示有限的、可能的状态。以下是关键点:

  1. 基本枚举:类似于其他语言的枚举,表示一组常量值。
  2. 携带数据的枚举:每个变体可以包含数据,类似于结构体。
  3. 泛型枚举:可以使用泛型定义更灵活的枚举类型。
  4. 标准库中的枚举:如 OptionResult 是枚举的典型例子。
  5. matchif let:主要用于处理枚举的匹配逻辑。
  6. 方法实现:为枚举定义行为。

Rust 的枚举比传统编程语言中功能更强大,非常适合表达复杂的逻辑状态和数据流。

posted @   代码世界faq  阅读(15)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· NetPad:一个.NET开源、跨平台的C#编辑器
· PowerShell开发游戏 · 打蜜蜂
· 凌晨三点救火实录:Java内存泄漏的七个神坑,你至少踩过三个!
点击右上角即可分享
微信分享提示