Rost - Aufzählungen

Wenn wir in der Rust-Programmierung einen Wert aus einer Liste möglicher Varianten auswählen müssen, verwenden wir Aufzählungsdatentypen. Ein Aufzählungstyp wird mit dem Schlüsselwort enum deklariert. Es folgt die Syntax von enum -

enum enum_name {
   variant1,
   variant2,
   variant3
}

Abbildung: Verwenden einer Aufzählung

Das Beispiel deklariert eine Aufzählung - GenderCategory , die Varianten als männlich und weiblich hat. Der Druck! Makro zeigt den Wert der Aufzählung an. Der Compiler gibt einen Fehler aus. Das Merkmal std :: fmt :: Debug ist für GenderCategory nicht implementiert . Das Attribut # [ableiten (Debuggen)] wird verwendet, um diesen Fehler zu unterdrücken.

// The `derive` attribute automatically creates the implementation
// required to make this `enum` printable with `fmt::Debug`.
#[derive(Debug)]
enum GenderCategory {
   Male,Female
}
fn main() {
   let male = GenderCategory::Male;
   let female = GenderCategory::Female;

   println!("{:?}",male);
   println!("{:?}",female);
}

Ausgabe

Male
Female

Struktur und Aufzählung

Das folgende Beispiel definiert eine Struktur Person. Das Feld Geschlecht ist vom Typ GenderCategory (eine Aufzählung) und kann als Wert entweder männlich oder weiblich zugewiesen werden.

// The `derive` attribute automatically creates the 
implementation
// required to make this `enum` printable with 
`fmt::Debug`.

#[derive(Debug)]
enum GenderCategory {
   Male,Female
}

// The `derive` attribute automatically creates the implementation
// required to make this `struct` printable with `fmt::Debug`.
#[derive(Debug)]
struct Person {
   name:String,
   gender:GenderCategory
}

fn main() {
   let p1 = Person {
      name:String::from("Mohtashim"),
      gender:GenderCategory::Male
   };
   let p2 = Person {
      name:String::from("Amy"),
      gender:GenderCategory::Female
   };
   println!("{:?}",p1);
   println!("{:?}",p2);
}

Im Beispiel werden die Objekte p1 und p2 vom Typ Person erstellt und die Attribute, der Name und das Geschlecht für jedes dieser Objekte initialisiert.

Ausgabe

Person { name: "Mohtashim", gender: Male }
Person { name: "Amy", gender: Female }

Option Enum

Option ist eine vordefinierte Aufzählung in der Rust-Standardbibliothek. Diese Aufzählung hat zwei Werte - Einige (Daten) und Keine.

Syntax

enum Option<T> {
   Some(T),      //used to return a value
   None          // used to return null, as Rust doesn't support 
   the null keyword
}

Hier repräsentiert der Typ T einen Wert eines beliebigen Typs.

Rust unterstützt das Schlüsselwort null nicht . Der Wert None in enumOption kann von einer Funktion verwendet werden, um einen Nullwert zurückzugeben. Wenn Daten zurückgegeben werden müssen, kann die Funktion Some (Daten) zurückgeben .

Lassen Sie uns dies anhand eines Beispiels verstehen -

Das Programm definiert eine Funktion is_even () mit einem Rückgabetyp Option. Die Funktion überprüft, ob der übergebene Wert eine gerade Zahl ist. Wenn die Eingabe gerade ist, wird ein Wert true zurückgegeben, andernfalls gibt die Funktion None zurück .

fn main() {
   let result = is_even(3);
   println!("{:?}",result);
   println!("{:?}",is_even(30));
}
fn is_even(no:i32)->Option<bool> {
   if no%2 == 0 {
      Some(true)
   } else {
      None
   }
}

Ausgabe

None
Some(true)

Match Statement und Enum

Die match- Anweisung kann verwendet werden, um in einer Aufzählung gespeicherte Werte zu vergleichen. Das folgende Beispiel definiert eine Funktion, print_size , die die CarType-Enumeration als Parameter verwendet. Die Funktion vergleicht die Parameterwerte mit einem vordefinierten Satz von Konstanten und zeigt die entsprechende Meldung an.

enum CarType {
   Hatch,
   Sedan,
   SUV
}
fn print_size(car:CarType) {
   match car {
      CarType::Hatch => {
         println!("Small sized car");
      },
      CarType::Sedan => {
         println!("medium sized car");
      },
      CarType::SUV =>{
         println!("Large sized Sports Utility car");
      }
   }
}
fn main(){
   print_size(CarType::SUV);
   print_size(CarType::Hatch);
   print_size(CarType::Sedan);
}

Ausgabe

Large sized Sports Utility car
Small sized car
medium sized car

Mit Option abgleichen

Das Beispiel der Funktion is_even , die den Optionstyp zurückgibt, kann auch mit der Anweisung match implementiert werden, wie unten gezeigt -

fn main() {
   match is_even(5) {
      Some(data) => {
         if data==true {
            println!("Even no");
         }
      },
      None => {
         println!("not even");
      }
   }
}
fn is_even(no:i32)->Option<bool> {
   if no%2 == 0 {
      Some(true)
   } else {
      None
   }
}

Ausgabe

not even

Match & Enum mit Datentyp

Es ist möglich, jeder Variante einer Aufzählung einen Datentyp hinzuzufügen. Im folgenden Beispiel sind die Varianten Name und Usr_ID der Aufzählung vom Typ String bzw. Integer. Das folgende Beispiel zeigt die Verwendung einer Übereinstimmungsanweisung mit einer Aufzählung mit einem Datentyp.

// The `derive` attribute automatically creates the implementation
// required to make this `enum` printable with `fmt::Debug`.
#[derive(Debug)]
enum GenderCategory {
   Name(String),Usr_ID(i32)
}
fn main() {
   let p1 = GenderCategory::Name(String::from("Mohtashim"));
   let p2 = GenderCategory::Usr_ID(100);
   println!("{:?}",p1);
   println!("{:?}",p2);

   match p1 {
      GenderCategory::Name(val)=> {
         println!("{}",val);
      }
      GenderCategory::Usr_ID(val)=> {
         println!("{}",val);
      }
   }
}

Ausgabe

Name("Mohtashim")
Usr_ID(100)
Mohtashim