Home-theater-designers
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.
struct Person {
name: String,
age: u8,
is_student: bool,
}
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.
Jeux ipad à 2 joueurs même appareil
let person = Person {
name: String::from("John"),
age: 27,
is_student: true,
};
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.
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 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.
comment se bloquer des sites Web
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.
// 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 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 :
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 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.
qu'est-ce qu'une mauvaise température du processeur
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.