Une caractéristique clé qui rend Rust puissant et plus attrayant est son support des structs. Les structs sont des types de données composites permettant de regrouper des données connexes. 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 les structs pour représenter divers objets, y compris des types de données et des configurations définis par l’utilisateur. Les structs 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 des objets du monde réel.
Définition des structures et des champs de structure
Vous définirez un struct en utilisant la fonction struct suivi d’un nom pour la structure. Ensuite, spécifiez les noms des champs de la structure et leurs types de données Rust à l’intérieur d’une paire d’accolades.
struct Person {
name: String,
age: u8,
is_student: bool,
}
Ce site Personne struct a trois champs. Le champ nom est une chaîne de caractères, le champ âge est un entier de 8 bits non signé, et le champ est_étudiant Le champ est un booléen.
Vous pouvez utiliser les littéraux de structure pour créer des instances de structure après la définition de la structure. Les littéraux de structure spécifient les valeurs des champs d’une structure.
let person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
Le site personne est une instance de la variable Personne struct, créé avec un littéral struct. Ce littéral instancie tous les champs de la structure avec les valeurs de leur type de données correspondant.
Utilisation de constructeurs pour créer des structures
Vous pouvez également utiliser une fonction constructeur pour créer une instance d’une structure.
impl Person {
// Define a constructor function `new` that takes `name`, `age` and
// `is_student` parameters
fn new(name: String, age: u8, is_student: bool) -> Self {
// Create a new instance of `Person` struct and initialize its fields
// with the provided values
Self {
name,
age,
is_student,
}
}
}
// Call the `new` constructor function of the `Person` struct and assign the
// resulting instance to `person`
let person = Person::new(String::from("John"), 27, true);
Le programme ci-dessus définit un constructeur pour la structure Personne struct avec le impl mot-clé. L’adresse nouveau Le constructeur prend les champs de la structure comme arguments et retourne une nouvelle instance de la structure avec les valeurs initialisées.
Vous pouvez créer un Personne avec l’instance 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 en utilisant la notation par points. Il suffit d’utiliser le point (.) suivi du nom du champ pour accéder à sa valeur ou la modifier.
// declare a Person struct
struct Person {
name: String,
age: u8,
is_student: bool,
}
fn main() {
// instantiate a struct
let mut person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
// print the name and age fields of the struct
println!("Name: {}", person.name);
println!("Age: {}", person.age);
// modifiy the is_student field
person.is_student = false;
println!("Is student: {}", person.is_student);
}
Le programme crée une structure, instancie cette structure, imprime le fichier nom, et âge et modifie les champs is_student avant d’imprimer le champ.
Déclarer des méthodes pour les structures
Contrairement aux structs en C, vous pouvez définir des méthodes sur les structs Rust qui opèrent sur une instance. Les méthodes sont des fonctions qui prennent une référence à une structure pour y accéder et la modifier. Vous pouvez également utiliser la notation point pour appeler les méthodes d’une structure et accéder à leur fonctionnalité.
Voici comment vous pouvez déclarer des méthodes pour les structs et utiliser ces méthodes pour effectuer des opérations :
struct Person {
name: String,
age: u8,
is_student: bool,
}
impl Person {
fn say_hello(&self) {
println!("Hello, my name is {} and I'm {} years old.", self.name,
self.age);
}
fn have_birthday(&mut self) {
self.age += 1;
}
}
fn main() {
let mut person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
person.say_hello();
person.have_birthday();
println!("New age: {}", person.age);
}
Le programme définit deux méthodes pour la structure Personne struct. Le site say_hello La méthode prend une référence à self et imprime un message d’accueil comprenant le nom et l’âge de la personne. Le site avoir_anniversaire prend une référence mutable à self et incrémente l’âge de la personne.
Le modèle de propriété de Rust optimise la gestion de la mémoire
Les Structs sont des structures de données polyvalentes, agissant comme une sorte d’équivalent minimal de classe.
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 struct. Le modèle de propriété assure que vous gérez efficacement la mémoire dans vos programmes, en évitant des problèmes communs comme les pointeurs nuls et dangling.
