Structs de rouille

Une structure fait référence à un type personnalisé ou défini par l'utilisateur. Les structures sont très utiles car elles nous permettent de stocker des attributs de différents types. La meilleure façon de penser aux structures est les plans contenant des attributs globaux qui peuvent être personnalisés pour créer des objets uniques.

Par exemple, nous pouvons créer une structure qui représente les utilisateurs. Chaque utilisateur aura un nom d'utilisateur, un e-mail et un statut. Nous pouvons alors modéliser chaque entité pour chacune de cette structure.

Laissez-nous savoir comment nous pouvons travailler avec des structures en rouille.

Rust Define Struct

Dans Rust, nous pouvons définir une structure en utilisant le mot-clé struct traîné par le nom de la structure. Ensuite, nous créons le corps de structure à l'intérieur d'une paire de bretelles bouclées.

Nous pouvons définir des propriétés uniques avec leurs types de données correspondants à l'intérieur de la structure.

La syntaxe peut être illustrée comme indiqué:

structStRUCTNAME
// Corps de structure
attribut_name: type,
attribut_name: type

Considérez l'exemple ci-dessous qui crée une structure utilisateur.

Structureurs
Nom d'utilisateur: chaîne,
Email: chaîne,
actif: bool,

fnmain ()
//

Le code ci-dessus crée une structure utilisateur avec le nom d'utilisateur, les e-mails et les propriétés actives.

Rust Initialiser la structure

Une fois que nous avons une structure définie, nous pouvons en créer des objets. La création d'un objet à partir d'une structure est connue comme créant une instance d'une structure.

Nous pouvons créer une instance d'une structure en créant une variable du type de structure. Un exemple est comme indiqué ci-dessous:

Utilisateurs de structure
Nom d'utilisateur: chaîne,
Email: chaîne,
actif: bool,

fnmain ()
Laissez user1 = utilisateurs
Nom d'utilisateur: "Z3RODAY".to_string (),
Courriel: "Zero @ Day.io ".to_string (),
actif: vrai
;

Dans la fonction principale ci-dessus, nous créons une instance de la structure appelée user1. Nous définissons ensuite des valeurs uniques pour les propriétés spécifiées de la structure.

Notez que nous utilisons un côlon au lieu de l'opérateur d'affectation pour définir les valeurs de l'instance struct.

Récupérer les valeurs de structure

Nous pouvons récupérer les membres d'une structure en utilisant la notation de points. Nous commençons par appeler le nom de la structure, suivi d'un point et du nom de la propriété struct auquel nous souhaitons accéder.

Un exemple est comme indiqué:

Utilisateurs de structure
Nom d'utilisateur: chaîne,
Email: chaîne,
actif: bool,

fn main ()
Laissez user1 = utilisateurs
Nom d'utilisateur: "Z3RODAY".to_string (),
Courriel: "Zero @ Day.io ".to_string (),
actif: vrai
;
Si l'utilisateur1.actif
println!("Détails du compte: \ n \ tusername: \ n \ temail: ", user1.Nom d'utilisateur, User1.e-mail);

L'exemple de code ci-dessus montre comment accéder aux valeurs d'une structure en utilisant la notation de points. Le code ci-dessus doit renvoyer la sortie comme:

Détails du compte:

Nom d'utilisateur: Z3Roday
Email: zéro @ jour.Io

Valeurs de structure de mise à jour de la rouille

Pour mettre à jour la valeur d'une instance de structure, nous devons nous assurer que la structure est mutable. La rouille ne vous permet pas de définir des champs spécifiques comme mutables.

Prenez l'instance user1. Nous pouvons modifier la valeur de l'e-mail comme indiqué ci-dessous:

Laissez mut user1 = utilisateurs
Nom d'utilisateur: "Z3RODAY".to_string (),
Courriel: "Zero @ Day.io ".to_string (),
actif: vrai
;
User1.email = "newmail @ zéro.io ".to_string ();

Le code ci-dessus définit l'instance user1 sur mutable à l'aide du mot clé Mut. Nous pouvons ensuite accéder aux propriétés d'un struct A définir une nouvelle valeur à l'aide de l'opérateur d'affectation.

Méthodes de structure

Nous pouvons créer des méthodes pour une structure en utilisant le mot-clé ILT. Les fonctions de structure, également appelées méthodes, sont disponibles pour les cas d'une structure.

Un exemple est comme indiqué:

Utilisateurs de structure
Nom d'utilisateur: chaîne,
Email: chaîne,
actif: bool,

Utilisateurs implants
fnread_mail (self)
si-même.actif
println!("Vous avez un courrier");



fn main ()
Laissez mut user1 = utilisateurs
Nom d'utilisateur: "Z3RODAY".to_string (),
Courriel: "Zero @ Day.io ".to_string (),
actif: vrai
;
User1.lire le courrier();

Dans le programme ci-dessus, nous définissons une méthode appelée read_mail qui accepte soi. Le mot à soi-même de Rust nous permet de nous référer à l'instance du struct appelant cette méthode.

Nous pouvons ensuite accéder aux propriétés de la structure en utilisant l'auto-paramètre, comme indiqué dans l'exemple ci-dessus.

Nous vérifions si l'utilisateur est actif et renvoie un message si cela est vrai pour notre exemple.

Nous pouvons appeler la méthode en utilisant l'instance_of_struct.Method_name ();

Conclusion

Cet article a exploré comment nous pouvons créer et utiliser Struct in Rust. Les structures nous permettent de définir des types personnalisés et de créer des objets uniques à partir des types de structures définies.

Merci d'avoir lu!