Une caractéristique clé qui rend Rust puissant et plus attrayant est sa prise en charge des structures. Les structures sont des types de données composites permettant de regrouper des données associées. Ils vous permettent de définir des types de données personnalisés avec des champs nommés qui améliorent l'organisation du code et facilitent la manipulation des données.
Vous pouvez utiliser des structures pour représenter divers objets, notamment des types de données et des configurations définis par l'utilisateur. Les structures sont plus flexibles que de nombreuses autres structures de données. Leur capacité à encapsuler des données connexes les rend utiles car ils créent un modèle plus logique d'objets du monde réel.
Définition des structures et des champs de structure
Vous allez définir une structure en utilisant la
structure mot-clé suivi d'un nom pour la structure. Suivez ceci en spécifiant les noms de champ de la structure et leur Types de données de rouille à l'intérieur d'une paire d'accolades.structurePersonne {
nom: Chaîne,
âge: u8,
est_étudiant: bourdonner,
}
Ce Personne struct a trois champs. Le nom champ est une chaîne, le âge champ est un entier non signé de 8 bits, et le est_étudiant champ est un booléen.
Vous pouvez utiliser des littéraux de structure pour créer des instances de structure après la définition de structure. Les littéraux de structure spécifient les valeurs des champs d'une structure.
laisser personne = Personne {
nom: Chaîne::depuis("John"),
âge: 27,
est_étudiant: vrai,
};
Le personne variable est une instance de Personne struct, créé avec un littéral de struct. Ce littéral instancie tous les champs de la structure avec des valeurs de leur type de données correspondant.
Utiliser des constructeurs pour créer des structures
Vous pouvez également utiliser une fonction constructeur pour créer une instance d'une structure.
mettre en œuvre Personne {
// Définit une fonction constructeur `new` qui prend `name`, `age` et
// Paramètres `is_student`
fnnouveau(nom: Chaîne, âge: u8, est_étudiant: bourdonner) -> Soi {
// Crée une nouvelle instance de la structure `Person` et initialise ses champs
// avec les valeurs fournies
Soi {
nom,
âge,
est_étudiant,
}
}
}
// Appelez la fonction constructeur `new` de la structure `Person` et affectez la
// instance résultante vers `person`
laisser personne = Personne:: nouveau(Chaîne::depuis("John"), 27, vrai);
Le programme ci-dessus définit un constructeur pour le Personne structure avec le mettre en œuvre mot-clé. Le nouveau Le constructeur prend les champs de structure comme arguments et renvoie une nouvelle instance de la structure avec les valeurs initialisées.
Vous pouvez créer un Personne exemple avec le nouveau constructeur, en lui passant les arguments appropriés.
Accès et modification des champs de structure
Vous pouvez accéder aux champs struct et les modifier à l'aide d'une notation par points. Vous utilisez simplement le point (.) suivi du nom du champ pour accéder ou modifier sa valeur.
// déclarer une structure Person
structurePersonne {
nom: Chaîne,
âge: u8,
est_étudiant: bourdonner,
}fnprincipal() {
// instancie une structure
laissermuet personne = Personne {
nom: Chaîne::depuis("John"),
âge: 27,
est_étudiant: vrai,
};// affiche les champs name et age de la structure
imprimez !("Nom: {}", nom d'une personne);
imprimez !("Âge: {}", personne.age);// modifie le champ is_student
personne.is_student = FAUX;
imprimez !("Est étudiant: {}", personne.is_student);
}
Le programme crée une structure, instancie la structure, imprime le nom, et âge champs, et modifie les est_étudiant champ avant d'imprimer le champ.
Déclarer des méthodes pour les structures
Contrairement à structures en C, vous pouvez définir des méthodes sur des structures Rust qui fonctionnent sur une instance. Les méthodes sont des fonctions qui prennent une référence à une structure pour l'accès et la modification. Vous pouvez également utiliser la notation par points pour appeler les méthodes d'un struct et accéder à leurs fonctionnalités.
Voici comment vous pouvez déclarer des méthodes pour les structures et utiliser ces méthodes pour effectuer des opérations :
structurePersonne {
nom: Chaîne,
âge: u8,
est_étudiant: bourdonner,
}mettre en œuvre Personne {
fndis bonjour(&soi) {
imprimez !("Bonjour, je m'appelle {} et j'ai {} ans.", soi.nom,
soi.âge);
}fnavoir_anniversaire(&muetsoi) {
soi.age += 1;
}
}fnprincipal() {
laissermuet personne = Personne {
nom: Chaîne::depuis("John"),
âge: 27,
est_étudiant: vrai,
};personne.say_hello();
person.have_birthday();
imprimez !("Nouvel Age: {}", personne.age);
}
Le programme définit deux méthodes pour la Personne structure. Le dis bonjour méthode prend une référence à soi et imprime un message d'accueil comprenant le nom et l'âge de la personne. Le avoir_anniversaire la méthode prend une référence mutable à soi et augmente l'âge de la personne.
Le modèle de propriété de Rust optimise la gestion de la mémoire
Les structures sont des structures de données polyvalentes, agissant comme une sorte d'équivalent de classe minimal.
Comme pour les autres structures de données Rust, vous devez suivre les règles de propriété de Rust lorsque vous travaillez avec des variables de structure. Le modèle de propriété garantit que vous gérez efficacement la mémoire dans vos programmes, en évitant les problèmes courants tels que les pointeurs nuls et pendants.
