详解Rust枚举类型(enum)的用法

基本枚举类型

//这些成员本质上是没有任何额外数据的  
enum Direction {
    Up,
    Down,
    Left,
    Right,
}
//使用枚举  
let move_up = Direction::Up;

带数据的枚举

Rust枚举的一个强大特性是每个枚举成员可以携带数据。这些数据可以是不同类型的，因此你可以将枚举用于更复杂的场景。任何类型的数据都可以放入枚举成员中: 例如字符串、数值、结构体甚至另一个枚举。某个函数它的功能是接受消息并进行发送，那么用枚举的方式，就可以接收不同的消息，但是用结构体，该函数无法接受4个不同的结构体作为参数。

//使用枚举作为参数 
#[derive(Debug)] 
enum PokerSuit {
  Clubs,
  Spades,
  Diamonds,
  Hearts,
}

let heart = PokerSuit::Hearts;
let diamond = PokerSuit::Diamonds;  
print_suit(heart);
print_suit(diamond);

fn print_suit(card: PokerSuit) {
    println!("{:?}",card);
}


//给每个枚举值类型 指定对应的基本类型  
enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(char),
    Hearts(char),
}

//给枚举类型添加复杂的数据类型  
enum Message {
    Quit,
    //类结构体数据  
    Move { x: i32, y: i32 },
    //存储字符串  
    Write(String),
    //元组结构的枚举成员
    ChangeColor(i32, i32, i32),
}

let move_message = Message::Move { x: 10, y: 20 };
let color_message = Message::ChangeColor(255, 0, 0);

//进行模式匹配  
match move_message {
    Message::Move { x, y } => println!("Moving to ({}, {})", x, y),
    _ => println!("Not a move message"),
}

枚举的Option和Result

Rust中有两个广泛使用的枚举类型: Option和Result，它们分别用于表示可能不存在的值和可能出错的计算结果。
Option 枚举用于表示可能的值是Some(T)或None。
Result<T, E>枚举用于表示一个操作的结果是Ok(T)(成功)还是Err(E)(错误)。

//这两个枚举类型广泛应用于Rust的标准库和错误处理  
enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

//手动指定None值 指定模版化  
enum Option<T> {
    Some(T),
    None,
}
let some_number = Some(5);
let some_string = Some("a string");
let absent_number: Option<i32> = None;

添加自定义函数

在Rust中，可以为枚举定义与之相关联的方法和函数。这些方法通常是通过impl块来定义的，就像为结构体定义方法一样。这样可以让枚举类型具有更丰富的行为。

// 定义一个枚举类型 Message
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

//使用impl块为枚举定义方法
impl Message {
    // 定义一个方法describe来描述消息
    fn describe(&self) -> String {
        match self {
            Message::Quit => String::from("Quit the program"),
            Message::Move { x, y } => format!("Move to position ({}, {})", x, y),
            Message::Write(text) => format!("Write the message: {}", text),
            Message::ChangeColor(r, g, b) => format!("Change color to RGB({},{},{})", r, g, b),
        }
    }

    // 定义一个方法is_move，判断当前消息是否是"Move"
    fn is_move(&self) -> bool {
       match self {
            Message::Move { x, y } => true,
            _ => false,
        }
    }
}

fn main() {
    let msg1 = Message::Move { x: 10, y: 20 };
    let msg2 = Message::Write(String::from("Hello"));

    println!("msg1 description: {}", msg1.describe());
    println!("msg2 description: {}", msg2.describe());

    // 调用is_move方法
    println!("msg1 is Move: {}", msg1.is_move());
    println!("msg2 is Move: {}", msg2.is_move());
}

除了实例方法，我们还可以为枚举定义静态方法。这些方法没有self参数，因此不能直接访问实例的内部数据。静态方法通常用于创建新的枚举实例或进行某些不依赖于实例的操作。

enum Shape {
    Circle(f64),         // 半径
    Rectangle(f64, f64), // 长宽
}

impl Shape {
    fn new_circle(radius: f64) -> Self {
        Shape::Circle(radius)
    }
    fn new_rectangle(width: f64, height: f64) -> Self {
        Shape::Rectangle(width, height)
    }
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
            Shape::Rectangle(width, height) => width * height,
        }
    }
}

fn main() {
    // 使用静态方法创建枚举实例
    let circle = Shape::new_circle(5.0);
    let rectangle = Shape::new_rectangle(10.0, 4.0);
    println!("Circle area: {}", circle.area());
    println!("Rectangle area: {}", rectangle.area());
}

枚举和泛型

Rust的枚举也可以和关联类型结合使用，提供更加复杂的泛型和多态功能。比如，你可以为某个枚举定义一个泛型，然后根据不同的变体实现不同的行为。

enum Option<T> {
    Some(T),
    None,
}
impl<T> Option<T> {
    // 自定义方法：返回是否包含某个值
    fn is_some(&self) -> bool {
        match self {
            Option::Some(_) => true,
            Option::None => false,
        }
    }
}

fn main() {
    let some_value = Option::Some(42);
    let no_value: Option<i32> = Option::None;
    println!("Some value is_some: {}", some_value.is_some());
    println!("No value is_some: {}", no_value.is_some());
}

与C++枚举的区别

C++和Rust都支持枚举类型，但它们的实现和使用方式有很大不同。

1.C++ 枚举的基本特性
C++的传统枚举定义比较简单，成员的值默认是从0开始的，后续值递增。

enum Direction {
    Up,    // 默认值 0
    Down,  // 默认值 1
    Left,  // 默认值 2
    Right  // 默认值 3
};
//为枚举成员显式指定值
enum Direction {
    Up = 1,
    Down = 2,
    Left = 3,
    Right = 4
};

2.C++中的强类型枚举(enum class)
C++11引入了强类型枚举(enum class)，它避免了传统枚举的隐式转换问题。

//强类型枚举的成员不会自动转换为整数，因此需要显式地进行转换  
enum class Direction {
    Up,
    Down,
    Left,
    Right
};

Direction dir = Direction::Up;
int val = static_cast<int>(dir);  // 显式转换

3.数据关联
C++的枚举没有直接支持在枚举成员中关联数据(例如元组或结构体)。如果需要这种功能C++通常使用结构体和类来模拟:

struct Move {
    int x, y;
};

enum class Message {
    Quit,
    Move,
    Write,
    ChangeColor
};
//要传递数据，需要单独定义结构体或类来保存枚举的相关信息。

4.Rust枚举的灵活性
Rust的枚举与C++的传统枚举相比更为灵活。Rust的enum可以包含任意类型和数量的数据这是C++枚举无法直接做到的。这种设计使得Rust的枚举在表达复杂数据结构时更加方便，并且支持模式匹配，能够非常直观地处理不同枚举变种。

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

5.自动推导和模式匹配
Rust的match语句非常强大，可以用来匹配枚举的各种变体，并从中提取数据。而C++没有类似的直接支持，通常需要使用switch语句配合额外的逻辑.

let message = Message::Move { x: 10, y: 20 };
match message {
    Message::Move { x, y } => println!("Moving to ({}, {})", x, y),
    Message::Quit => println!("Quitting"),
    _ => println!("Other message"),
}

在C++中 类似写法如下:

Message message = Message::Move;
switch (message) {
    case Message::Move:
        // 处理
        break;
    case Message::Quit:
        // 处理
        break;
    default:
        // 处理
}