Rust Enum

Dans cet article, nous en apprendre davantage sur les énumérations ou les énumérations pour faire court. Les énumérations nous permettent de définir un type personnalisé composé de variantes. Ils sont étroitement similaires à une structure et chaque structure valide est une énumération valide.

Route Déclarer l'énumération

Nous pouvons définir une énumération de rouille en utilisant le mot-clé enum, suivi du nom de l'énumération. Nous créons ensuite le corps de l'énumération à l'intérieur d'une paire de bretelles bouclées.

Le corps en énumération est composé de variantes possibles séparées par des virgules.

La syntaxe est comme indiqué:

enummenum_name
une variante(),
variant2
variante3
…

La rouille recommande d'utiliser un acte.

Prenons un cas où les énumérations peuvent être utiles. Un exemple qui vient à l'esprit est les types de charge. Il existe deux types de charge:

1. Négatif
2. Positif

Puisqu'il ne peut y avoir qu'un seul type de charge à un moment donné, il est logique d'utiliser une enum. Un exemple est comme indiqué ci-dessous:

EnumCharge
Négatif,
Positif

Rust Initialize Enum

Une fois que nous avons défini une énumération, nous pouvons créer des instances de chacune des variantes. Un exemple est comme indiqué:

fnmain ()
Laissez p = charger :: positif;
Soit n = charger :: négatif;

Utilisation d'énumérations avec des structures

Une façon d'étendre une énumération est de la combiner avec une structure. Considérez l'exemple de code ci-dessous:

Structelement
nom: chaîne,
Valeur: i32,
Frais de charge,

Une fois que nous avons une structure, nous pouvons créer une instance de la structure et passer les propriétés de l'énumération comme indiqué dans l'exemple ci-dessous:

Enum Charge
Négatif,
Positif

élément struct
nom: chaîne,
Valeur: i32,
Frais de charge,

fn main ()
Soit elem1 = élément
Nom: "Sodium".to_string (),
Valeur: 1,
Charge: charge :: positif
;
Soit Elem2 = élément
Nom: "Chlorure".to_string (),
Valeur: 1,
Charge: charge :: négatif
;

Dans l'exemple de code ci-dessus, nous définissons deux instances de l'élément structure. Nous passons ensuite la propriété de charge comme valeur de l'énumération de charge.

Rust Derive Trait

Si vous essayez d'imprimer les instances de la structure ci-dessus, le compilateur renvoie une erreur. Pour imprimer la structure, nous devons «importer» le trait de débogage.

Cela se fait en utilisant l'attribut dérivé. Cela nous permet d'obtenir diverses implémentations de traits telles que:

1. Trait de débogage
2. Eq, Partialeq, Ord, Partialord
3. Trait de hachage,
4. Trait par défaut
5. Etc.

La syntaxe pour dériver un trait est comme indiqué:

# [dérive (trait_name)]

Puisque nous devons imprimer la structure à la console, nous pouvons dériver le trait de débogage comme indiqué:

# [dériver (débogage)]
EnumCharge
Négatif,
Positif

# [dériver (débogage)]
Structelement
nom: chaîne,
Valeur: i32,
Frais de charge,

Nous pouvons ensuite utiliser ce trait pour imprimer la structure sur la console comme:

println!(": #? ", elem1);

Cela devrait imprimer la structure à la console comme:

Vous pouvez vérifier la documentation de dérive dans la ressource fournie ci-dessous:

https: // doc.chanteur de la rouille.org / référence / attributs / dériver.html

Conclusion

Dans cet article, nous avons exploré comment créer, utiliser et travailler avec des types d'énumération à Rust. Nous avons également couvert comment utiliser les énumérations avec des structures et comment dériver des traits.

Merci d'avoir lu!!