Vetores de structs
Armazene dados complexos em um Vec.
Vetores de structs é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.
Por que usar vetores de structs
Os vetores podem armazenar qualquer tipo único, inclusive suas próprias structs. Um Vec<Person> armazena várias pessoas em ordem, o que é ótimo para listas de registros, como usuários, itens ou pontuações.
Isso combina formatos de dados personalizados com uma lista expansível.
Definindo uma struct
Primeiro, defina a struct que você quer armazenar. Esta Person tem um nome e uma idade.
A linha #[derive(Debug)] permite exibir uma pessoa com {:?}, o que é útil para vetores inteiros.
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}Construindo o vetor
Crie instâncias da struct e depois reúna-as em uma macro vec!. O tipo do vetor se torna automaticamente Vec<Person>.
Use {:?} para exibir todos os registros de uma só vez.
#[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);
}Adicionando structs
Você também pode começar com um vetor vazio e usar push para adicionar structs uma a uma. O vetor precisa ser mut para crescer.
Esse padrão é adequado quando os registros chegam ao longo do tempo, por exemplo, a partir de uma entrada do usuário.
#[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);
}Percorrendo registros
Percorra &people para ler cada struct sem assumir sua propriedade. Dentro do loop, você acessa os campos usando a notação de ponto, como em p.name.
Isso exibe uma linha clara para cada registro.
#[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);
}
}Lendo um campo
Use um índice no vetor para acessar uma struct e depois use a notação de ponto para acessar seu campo. Assim, people[0].name fornece o nome da primeira pessoa.
Lembre-se de que os índices começam em 0 e que um acesso fora do intervalo causa um pânico.
#[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);
}Alterando um campo
Para editar um registro, o vetor precisa ser mut. Depois, use um índice para acessar a struct e atribua um valor ao campo, como em people[0].age = 31.
Isso atualiza os dados armazenados no próprio vetor.
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);
}Somando um campo
Os iteradores podem extrair um campo de cada registro. Aqui, iter().map(|p| p.age).sum() soma todas as idades.
A etapa map transforma cada pessoa apenas em uma idade antes da soma.
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);
}Filtrando registros
Use iter().filter(...) para manter os registros que correspondem a uma regra. O fechamento retorna um bool para cada struct.
Aqui contamos quantas pessoas têm pelo menos 30 anos.
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);
}Ordenando por um campo
Ordene os registros por um campo com sort_by_key. Passe uma closure que retorne o valor pelo qual ordenar, como a idade.
O vetor deve ser mut, pois a ordenação o reorganiza.
#[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);
}Contando registros
A quantidade de structs armazenadas é simplesmente len(), assim como em qualquer vetor. Isso informa quantos registros você tem no momento.
Combine isso com is_empty() para fazer uma verificação antes de ler o primeiro registro.
struct Item { name: String }
fn main() {
let cart = vec![
Item { name: String::from("Pen") },
Item { name: String::from("Mug") },
];
println!("items: {}", cart.len());
}Verificação rápida
Teste sua compreensão sobre vetores de structs.
Recapitulação
Você armazenou structs em uma Vec, criou o vetor com vec! e push e leu ou editou campos por índice e em loops.
Você também calculou somas, filtrou, ordenou por um campo e contou registros. Agora você pode gerenciar listas de dados estruturados com vetores.
Perguntas Frequentes
A aula “Vetores de structs” é grátis?
Sim — o texto completo de “Vetores de structs” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.
O que vou aprender em “Vetores de structs”?
Armazene dados complexos em um Vec. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn Rust Coding?
Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Vetores de structs”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn Rust Coding?
Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Criando e preenchendo vetores
- Indexação e iteração
- Aumentando e diminuindo
- Vetores de structs