Vecteurs de structures
Stockez des données complexes dans un Vec.
Vecteurs de structures est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Pourquoi utiliser des vecteurs de structures ?
Les vecteurs peuvent contenir n’importe quel type unique, y compris vos propres structures. Un Vec<Person> stocke plusieurs personnes dans un ordre donné, ce qui est idéal pour des listes d’enregistrements tels que des utilisateurs, des éléments ou des scores.
Cela associe des formes de données personnalisées à une liste extensible.
Définir une structure
Commencez par définir la structure que vous souhaitez stocker. Cette Person possède un nom et un âge.
La ligne #[derive(Debug)] nous permet d’afficher une personne avec {:?}, ce qui est utile pour afficher des vecteurs entiers.
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}Construire le vecteur
Créez des instances de la structure, puis rassemblez-les dans une macro vec!. Le type du vecteur devient automatiquement Vec<Person>.
Utilisez {:?} pour afficher tous les enregistrements en une seule fois.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 25 },
];
println!("{:?}", people);
}Ajouter des structures
Vous pouvez également commencer avec un vecteur vide et ajouter des structures une par une avec push. Le vecteur doit être mut pour pouvoir grandir.
Ce schéma convient lorsque les enregistrements arrivent au fil du temps, par exemple depuis une saisie utilisateur.
#[derive(Debug)]
struct Item { name: String }
fn main() {
let mut cart = Vec::new();
cart.push(Item { name: String::from("Pen") });
cart.push(Item { name: String::from("Mug") });
println!("{:?}", cart);
}Parcourir les enregistrements
Parcourez &people pour lire chaque structure sans en prendre la propriété. Dans la boucle, vous accédez aux champs avec la notation pointée, comme dans p.name.
Cela affiche une ligne conviviale pour chaque enregistrement.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 25 },
];
for p in &people {
println!("{} is {}", p.name, p.age);
}
}Lire un champ
Accédez à une structure du vecteur par son indice, puis utilisez la notation pointée pour accéder à son champ. Ainsi, people[0].name donne le nom de la première personne.
N’oubliez pas que les indices commencent à 0 et qu’un accès hors limites provoque une panique.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
];
println!("name: {}", people[0].name);
}Modifier un champ
Pour modifier un enregistrement, le vecteur doit être mut. Accédez ensuite à la structure par son indice et affectez une valeur à son champ, comme dans people[0].age = 31.
Les données stockées sont ainsi mises à jour sur place.
struct Person { name: String, age: u32 }
fn main() {
let mut people = vec![
Person { name: String::from("Ann"), age: 30 },
];
people[0].age = 31;
println!("{}", people[0].age);
}Additionner un champ
Les itérateurs peuvent extraire un champ de chaque enregistrement. Ici, iter().map(|p| p.age).sum() additionne tous les âges.
L’étape map transforme chaque personne en un simple âge avant l’addition.
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
let total: u32 = people.iter().map(|p| p.age).sum();
println!("total age = {}", total);
}Filtrer les enregistrements
Utilisez iter().filter(...) pour conserver les enregistrements qui correspondent à une règle. La fermeture renvoie un booléen pour chaque structure.
Ici, nous comptons combien de personnes ont au moins 30 ans.
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
let adults = people.iter().filter(|p| p.age >= 30).count();
println!("adults: {}", adults);
}Trier selon un champ
Triez les enregistrements selon un champ avec sort_by_key. Fournissez-lui une fermeture qui renvoie la valeur servant au tri, comme l’âge.
Le vecteur doit être mut, car le tri le réorganise.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let mut people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
people.sort_by_key(|p| p.age);
println!("{:?}", people);
}Compter les enregistrements
Le nombre de structures stockées est simplement len(), comme pour tout vecteur. Cela vous indique combien d’enregistrements vous détenez actuellement.
Associez-le à is_empty() pour effectuer une vérification avant de lire le premier enregistrement.
struct Item { name: String }
fn main() {
let cart = vec![
Item { name: String::from("Pen") },
Item { name: String::from("Mug") },
];
println!("items: {}", cart.len());
}Vérification rapide
Vérifiez votre compréhension des vecteurs de structures.
Récapitulatif
Vous avez stocké des structures dans un Vec, l’avez construit avec vec! et push, puis lu ou modifié des champs par index et dans des boucles.
Vous avez également calculé des sommes, filtré, trié selon un champ et compté des enregistrements. Vous pouvez maintenant gérer des listes de données structurées avec des vecteurs.
Questions Fréquemment Posées
La leçon « Vecteurs de structures » est-elle gratuite ?
Oui — le texte complet de « Vecteurs de structures » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Vecteurs de structures » ?
Stockez des données complexes dans un Vec. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Vecteurs de structures » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Créer et remplir des vecteurs
- Indexer et parcourir
- Agrandir et réduire
- Vecteurs de structures