Enumerationen, die mit Konstanten Werten in Rust

Kann ich dies tun:

enum MyEnum {
    A(i32),
    B(i32),
}

aber nicht dieses:

enum MyEnum {
    A(123), //123 is a constant
    B(456), //456 is a constant
}

Kann ich die Schaffung von Strukturen für A und B mit einem einzigen Feld und implementieren Sie dann das Feld, aber ich denke, es könnte einen einfacheren Weg. Gibt es eine?

InformationsquelleAutor | 2016-04-29
  1. 35

    Der beste Weg zur Beantwortung dieser arbeitet heraus, warum Sie wollen, Konstanten in einem enum: Sie sind nur assoziieren einen Wert mit jeder Variante, oder willst du jede Variante zu werden, dass der Wert (wie ein enum in C oder C++)?

    Für den ersten Fall, ist es wahrscheinlich mehr Sinn macht, lassen Sie einfach den enum-Varianten mit keine Daten, und eine Funktion:

    enum MyEnum {
    A,
    B,
}

impl MyEnum {
    fn value(&self) -> i32 {
        match *self {
            MyEnum::A => 123,
            MyEnum::B => 456,
        }
    }
}
//call like some_myenum_value.value()

    Dieser Ansatz angewendet werden kann viele Male, zu assoziieren viele separate Stücke von Informationen, die mit jeder Variante, z.B. möchten Sie vielleicht eine .name() -> &'static str Methode zu.

    Alternativ, für den zweiten Fall, können Sie explizite Werte für tag wie C/C++:

    enum MyEnum {
    A = 123,
    B = 456,
}

    Dies kann matched in allen die gleichen Möglichkeiten, kann aber auch umgewandelt werden in eine Ganzzahl MyEnum::A as i32. (Beachten Sie, dass Rechnungen wie MyEnum::A | MyEnum::B sind nicht automatisch legal in Rust: enums haben bestimmte Werte, Sie sind nicht bit-flags.)

    • Wie kann ich auf die Werte (implementiert in value - Funktion)?
    InformationsquelleAutor huon
  2. 3

    Menschen, die sich auf diese möglicherweise stolpern die Einführung und Streichung von FromPrimitive. Ein Austausch möglich, das kann auch hilfreich sein hier ist enum_primitive. Es ermöglicht die Verwendung von C-wie enums und haben Sie gewirkt, die zwischen der numerischen und logischen Darstellung:

    #[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);
}
    InformationsquelleAutor user2722968
  3. 1

    Andere alternative ist die enum-Karte Kiste. Dies bietet die Möglichkeit, einen Wert zuweisen, die enum-Eintrag. Was mehr ist, Sie können verwenden Sie dieses makro mit unterschiedlichen Wert-Typen.

    #[macro_use]
extern crate enum_map;

use enum_map::EnumMap;

#[derive(Debug, Enum)]
enum Example {
    A,
    B,
    C,
}

fn main() {
    let mut map = enum_map! {
        Example::A => 1,
        Example::B => 2,
        Example::C => 3,
    };
    map[Example::C] = 4;

    assert_eq!(map[Example::A], 1);

    for (key, &value) in &map {
        println!("{:?} has {} as value.", key, value);
    }
}
    InformationsquelleAutor sireliah
Schreibe einen Kommentar