Rust Tipos Básico
Structs
Em Rust, uma struct é uma forma de agrupar valores relacionados em um único tipo personalizado. Diferente de tuplas, cada campo tem um nome, o que torna o código mais legível e seguro. Structs são a base para modelar dados do mundo real, como um ponto no plano cartesiano ou um usuário com nome e idade.
Para adicionar comportamento a uma struct, usamos blocos impl. Dentro deles, definimos métodos (funções que recebem self como primeiro parâmetro) e funções associadas (funções que não recebem self e geralmente são usadas como construtoras, como Ponto::new(x, y)).
Além das structs com campos nomeados, Rust oferece tuple structs, que são úteis quando os nomes dos campos não são essenciais, mas ainda queremos um tipo distinto. Por exemplo, struct Cor(u8, u8, u8); cria um tipo Cor que não pode ser confundido com uma tupla comum.
Neste card, vamos explorar a definição de structs, como implementar métodos e funções associadas, e quando usar tuple structs. Tudo isso com exemplos práticos e exercícios para fixar.
Pontos-chave
- Structs agrupam dados relacionados com campos nomeados, melhorando a legibilidade.
- Blocos
implpermitem adicionar métodos e funções associadas a uma struct. - Métodos recebem
&self(ou&mut self) e são chamados cominstancia.metodo(). - Funções associadas não recebem
selfe são chamadas comTipo::funcao(). - Tuple structs são úteis para criar tipos distintos sem nomear campos.
// Definição de uma struct com campos nomeados
struct Ponto {
x: f64,
y: f64,
}
// Bloco impl: métodos e funções associadas
impl Ponto {
// Função associada (construtora)
fn new(x: f64, y: f64) -> Self {
Ponto { x, y }
}
// Método que calcula a distância à origem
fn distancia_origem(&self) -> f64 {
(self.x * self.x + self.y * self.y).sqrt()
}
// Método que move o ponto
fn mover(&mut self, dx: f64, dy: f64) {
self.x += dx;
self.y += dy;
}
}
// Tuple struct para representar uma cor RGB
struct Cor(u8, u8, u8);
fn main() {
// Criando instância com função associada
let mut p = Ponto::new(3.0, 4.0);
println!("Ponto: ({}, {})", p.x, p.y);
println!("Distância à origem: {:.2}", p.distancia_origem());
p.mover(1.0, -2.0);
println!("Após mover: ({}, {})", p.x, p.y);
// Usando tuple struct
let vermelho = Cor(255, 0, 0);
println!("Vermelho: R={}, G={}, B={}", vermelho.0, vermelho.1, vermelho.2);
}