Vettori di struct
Conservi dati complessi in un Vec.
Vettori di struct è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
Perché usare vettori di struct
I vettori possono contenere un solo tipo qualsiasi, incluse le proprie struct. Un Vec<Person> memorizza molte persone in ordine, il che è ideale per elenchi di record come utenti, articoli o punteggi.
In questo modo si combinano strutture dati personalizzate con un elenco espandibile.
Definizione di una Struct
Per prima cosa definite la struct da memorizzare. Questa Person contiene un nome e un'età.
La riga #[derive(Debug)] consente di stampare una persona con {:?}, utile per visualizzare vettori interi.
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}Creazione del vettore
Create le istanze della struct, quindi raccoglietele in una macro vec!. Il tipo del vettore diventa automaticamente Vec<Person>.
Usate {:?} per stampare tutti i record contemporaneamente.
#[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);
}Aggiunta di struct
Potete anche iniziare con un vettore vuoto e aggiungere le struct una alla volta con push. Il vettore deve essere mut per poter crescere.
Questo schema è adatto quando i record arrivano nel tempo, ad esempio tramite l'input dell'utente.
#[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);
}Scorrimento dei record
Scorrete &people per leggere ogni struct senza trasferirne la proprietà. All'interno del ciclo, accedete ai campi con la notazione a punto, ad esempio p.name.
In questo modo viene stampata una riga descrittiva per ogni record.
#[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);
}
}Lettura di un campo
Usate l'indice del vettore per raggiungere una struct, quindi accedete al suo campo con la notazione a punto. Pertanto, people[0].name restituisce il nome della prima persona.
Ricordate che gli indici iniziano da 0 e che l'accesso oltre i limiti provoca un panic.
#[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);
}Modifica di un campo
Per modificare un record, il vettore deve essere mut. Quindi raggiungete la struct tramite l'indice e assegnate un valore al suo campo, ad esempio people[0].age = 31.
In questo modo i dati memorizzati vengono aggiornati direttamente.
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);
}Somma di un campo
Gli iteratori possono estrarre un campo da ogni record. Qui iter().map(|p| p.age).sum() somma tutte le età.
Il passaggio map trasforma ogni persona nella sola età prima della somma.
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);
}Filtro dei record
Usate iter().filter(...) per mantenere i record che soddisfano una regola. La closure restituisce un bool per ogni struct.
Qui contiamo quante persone hanno almeno 30 anni.
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);
}Ordinamento per campo
Ordinate i record in base a un campo con sort_by_key. Passate una closure che restituisca il valore in base al quale ordinare, ad esempio l'età.
Il vettore deve essere mut perché l'ordinamento ne modifica la disposizione.
#[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);
}Conteggio dei record
Il numero di struct memorizzate si ottiene semplicemente con len(), proprio come per qualsiasi vettore. Questo indica quanti record contiene attualmente il vettore.
Usatelo insieme a is_empty() per verificare che il vettore non sia vuoto prima di leggere il primo record.
struct Item { name: String }
fn main() {
let cart = vec![
Item { name: String::from("Pen") },
Item { name: String::from("Mug") },
];
println!("items: {}", cart.len());
}Verifica rapida
Verificate la vostra comprensione dei vettori di struct.
Riepilogo
Avete memorizzato struct in un Vec, lo avete creato con vec! e push, e avete letto o modificato i campi tramite indici e cicli.
Avete anche sommato, filtrato, ordinato per campo e contato i record. Ora potete gestire elenchi di dati strutturati con i vettori.
Domande Frequenti
La lezione «Vettori di struct» è gratuita?
Sì — il testo completo di «Vettori di struct» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Vettori di struct»?
Conservi dati complessi in un Vec. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Vettori di struct»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Creare e riempire vettori
- Indicizzazione e iterazione
- Aumentare e ridurre le dimensioni
- Vettori di struct