Comment faire correspondre les valeurs enum avec un entier?

Je peux obtenir une valeur entière d'un énumérations comme ceci:

enum MyEnum {
    A = 1,
    B,
    C,
}

let x = MyEnum::C as i32;

mais je n'arrive pas à le faire:

match x {
    MyEnum::A => {}
    MyEnum::B => {}
    MyEnum::C => {}
    _ => {}
}

Comment puis-je correspondre à l'encontre des valeurs de l'enum ou d'essayer de convertir les x retour à un MyEnum?

Je peux voir une fonction comme ceci étant utile pour les énumérations, mais il n'existe pas:

impl MyEnum {
    fn from<T>(val: &T) -> Option<MyEnum>;
}

source d'informationauteur dhardy

  1. 11

    std::nombre::FromPrimitive est marqué comme instable et ne sera pas inclus dans la Rouille 1.0. Comme solution de contournement, j'ai écrit le enum_primitive caissequi exporte une macro enum_from_primitive! qui encapsule une enum déclaration et l'ajoute automatiquement à une mise en œuvre de num::FromPrimitive (à partir de la num caisse). Exemple:

    #[macro_use]
extern crate enum_primitive;
extern crate num;

use num::FromPrimitive;

enum_from_primitive! {
    #[derive(Debug, PartialEq)]
    enum FooBar {
        Foo = 17,
        Bar = 42,
        Baz,
    }
}

fn main() {
    assert_eq!(FooBar::from_i32(17), Some(FooBar::Foo));
    assert_eq!(FooBar::from_i32(42), Some(FooBar::Bar));
    assert_eq!(FooBar::from_i32(43), Some(FooBar::Baz));
    assert_eq!(FooBar::from_i32(91), None);
}
  2. 10

    Vous pouvez prendre avantage de correspondre à des gardes à écrire un équivalent, mais moins agiles, construction:

    match x {
    x if x == MyEnum::A as i32 => ...,
    x if x == MyEnum::B as i32 => ...,
    x if x == MyEnum::C as i32 => ...,
    _ => ...
}

    std::mem::transmute peut également être utilisé:

    let y: MyEnum = unsafe { transmute(x as i8) };

    Mais cela nécessite que vous connaissez la taille de l'enum, de sorte que vous pouvez lancer à un scalaire premier, et va également produire un comportement indéfini si x n'est pas une valeur valide pour l'enum.

  3. 7

    Vous pouvez dériver FromPrimitive:

    #[macro_use]
extern crate num_derive;
extern crate num_traits;

use num_traits::FromPrimitive;

#[derive(FromPrimitive)]
enum MyEnum {
    A = 1,
    B,
    C,
}

fn main() {
    let x = 2;

    match FromPrimitive::from_i32(x) {
        Some(MyEnum::A) => println!("Got A"),
        Some(MyEnum::B) => println!("Got B"),
        Some(MyEnum::C) => println!("Got C"),
        None            => println!("Couldn't convert {}", x),
    }
}
  4. 3

    Si vous êtes sûr que les valeurs de l'entier sont inclus dans l'enum, vous pouvez utiliser std::mem::transmuter.

    Cela doit être utilisé avec #[repr(..)] pour contrôler le type sous-jacent.

    Exemple Complet:

    #[repr(i32)]
enum MyEnum {
    A = 1, B, C
}

fn main() {
    let x = MyEnum::C;
    let y = x as i32;
    let z: MyEnum = unsafe { ::std::mem::transmute(y) };

    //match the enum that came from an int
    match z {
        MyEnum::A => { println!("Found A"); }
        MyEnum::B => { println!("Found B"); }
        MyEnum::C => { println!("Found C"); }
    }
}

    Noter que, contrairement à certains des autres réponses, cela nécessite seulement de la Rouille de la bibliothèque standard.

  5. 0

    Si l'entier vous correspondant est basé sur la ordre des variantes de l'enum, vous pouvez utiliser gratter pour générer un itérateur de la enums et prendre le bon:

    #[macro_use]
extern crate strum_macros; //0.9.0
extern crate strum;        //0.9.0

use strum::IntoEnumIterator;

#[derive(Debug, PartialEq, EnumIter)]
enum MyEnum {
    A = 1,
    B,
    C,
}

fn main() {
    let e = MyEnum::iter().nth(2);
    assert_eq!(e, Some(MyEnum::C));
}