Lição 11 de 18 · 25 min
Structs
Agrupe dados relacionados em um tipo seu, com campos nomeados, métodos e funções associadas, e imprima tudo com #[derive(Debug)].
Ao terminar, você vai saber:
- Definir e instanciar uma struct com campos nomeados
- Criar uma struct a partir de outra com a sintaxe de atualização
- Escrever métodos com &self e &mut self dentro de um bloco impl
- Criar uma função associada new para montar instâncias
- Imprimir uma struct com #[derive(Debug)]
Até aqui você guardou dados em variáveis soltas e em tuplas. Funciona, mas logo fica confuso. Um cliente tem nome, CPF e saldo. Se cada coisa estiver numa variável diferente, nada diz que elas andam juntas.
A struct resolve isso. Ela é um tipo criado por você que agrupa vários campos com nome, como uma ficha de cadastro.
Definindo e criando
struct Cliente {
nome: String,
cpf: String,
saldo: f64,
ativo: bool,
}
fn main() {
let cliente = Cliente {
nome: String::from("Ana Souza"),
cpf: String::from("123.456.789-09"),
saldo: 150.0,
ativo: true,
};
println!("{} tem R$ {:.2}", cliente.nome, cliente.saldo);
println!("CPF: {}, ativo: {}", cliente.cpf, cliente.ativo);
}
A definição diz o nome de cada campo e o tipo dele. Para criar uma instância, você escreve o nome da struct e preenche todos os campos, em qualquer ordem. Para ler um campo, use o ponto: cliente.nome.
Para mudar um campo, a variável inteira precisa ser mut. O Rust não deixa marcar só um campo como mutável.
struct Cliente {
nome: String,
saldo: f64,
}
fn main() {
let mut cliente = Cliente {
nome: String::from("Ana Souza"),
saldo: 150.0,
};
cliente.saldo += 50.0; // recebeu um Pix
println!("{}: R$ {:.2}", cliente.nome, cliente.saldo);
}
Atalho de campo e atualização com ..
Quando a variável tem o mesmo nome do campo, dá para escrever só uma vez. E quando você quer uma instância parecida com outra, a sintaxe .. copia o resto.
struct Produto {
nome: String,
preco: f64,
estoque: u32,
categoria: String,
}
fn novo_produto(nome: String, preco: f64) -> Produto {
Produto {
nome, // mesmo que nome: nome
preco, // mesmo que preco: preco
estoque: 0,
categoria: String::from("padaria"),
}
}
fn main() {
let pao = novo_produto(String::from("Pão francês"), 0.75);
// Igual ao pão, só muda nome e preço
let sonho = Produto {
nome: String::from("Sonho"),
preco: 6.50,
..pao
};
println!("{} custa R$ {:.2} ({})", sonho.nome, sonho.preco, sonho.categoria);
println!("{} custa R$ {:.2}, estoque: {}", pao.nome, pao.preco, pao.estoque);
}
Cuidado com a posse. O ..pao moveu o campo categoria (uma String) para o sonho. Depois disso, pao.categoria não pode mais ser usado. Os outros campos de pao continuam válidos, por isso o último println! funciona. Números como preco e estoque são copiados, não movidos, como você viu em Ownership.
Tuple structs
Às vezes os campos não precisam de nome, mas você quer um tipo próprio. Para isso existe a tuple struct.
struct Reais(f64);
struct Coordenada(f64, f64);
fn main() {
let preco = Reais(19.90);
let sao_paulo = Coordenada(-23.55, -46.63);
println!("Preço: R$ {:.2}", preco.0);
println!("Latitude {}, longitude {}", sao_paulo.0, sao_paulo.1);
}
O ganho aqui é segurança. Uma função que recebe Reais não aceita um f64 qualquer por engano. O tipo deixa claro o que aquele número significa.
Métodos com impl
Uma struct guarda dados. Para dar comportamento a ela, você escreve um bloco impl com funções dentro. Funções que recebem self como primeiro parâmetro são métodos.
struct Conta {
titular: String,
saldo: f64,
}
impl Conta {
// &self: só lê a conta
fn mostrar_saldo(&self) {
println!("{}: R$ {:.2}", self.titular, self.saldo);
}
// &mut self: altera a conta
fn depositar(&mut self, valor: f64) {
self.saldo += valor;
}
fn sacar(&mut self, valor: f64) -> bool {
if valor > self.saldo {
return false;
}
self.saldo -= valor;
true
}
}
fn main() {
let mut conta = Conta {
titular: String::from("Carlos"),
saldo: 100.0,
};
conta.depositar(250.0);
if !conta.sacar(1000.0) {
println!("Saldo insuficiente");
}
conta.mostrar_saldo();
}
As três formas de receber self seguem as regras de empréstimo que você já conhece:
&self: empresta a struct só para leitura. É a mais comum.&mut self: empresta para alterar. A variável precisa sermut.self: toma a posse. Depois da chamada, a variável original não pode mais ser usada. Útil quando o método transforma a struct em outra coisa.
Você chama conta.depositar(250.0), e o Rust cria o &mut conta sozinho.
Funções associadas e o new
Uma função dentro do impl que não recebe self é uma função associada. Ela pertence ao tipo, não a uma instância. Você chama com ::, como em String::from.
O uso mais comum é um construtor chamado new. Não é palavra reservada, é só um costume da comunidade.
struct Conta {
titular: String,
saldo: f64,
}
impl Conta {
fn new(titular: &str) -> Self {
Self {
titular: String::from(titular),
saldo: 0.0,
}
}
fn saldo(&self) -> f64 {
self.saldo
}
}
fn main() {
let conta = Conta::new("Beatriz");
println!("Conta de {} criada com R$ {:.2}", conta.titular, conta.saldo());
}
Self, com S maiúsculo, é um apelido para o tipo do impl. Aqui, Self é o mesmo que Conta.
Imprimindo com #[derive(Debug)]
Tente imprimir uma struct direto:
struct Aluno {
nome: String,
nota: f64,
}
fn main() {
let aluno = Aluno { nome: String::from("João"), nota: 8.5 };
println!("{:?}", aluno);
}
error[E0277]: `Aluno` doesn't implement `Debug`
| println!("{:?}", aluno);
| ^^^^ `Aluno` cannot be formatted using `{:?}`
= help: the trait `Debug` is not implemented for `Aluno`
= note: add `#[derive(Debug)]` to `Aluno` or manually `impl Debug for Aluno`
O Rust não sabe como mostrar o seu tipo. A própria mensagem dá a saída: acrescente #[derive(Debug)] em cima da struct.
#[derive(Debug)]
struct Aluno {
nome: String,
nota: f64,
}
fn main() {
let aluno = Aluno { nome: String::from("João"), nota: 8.5 };
println!("{:?}", aluno); // tudo numa linha
println!("{:#?}", aluno); // um campo por linha
}
O derive pede para o compilador escrever o código de impressão por você. Ele serve para depurar, não para mostrar ao usuário final. Na lição Traits e genéricos você vai ver como fazer uma impressão bonita com Display.
Resumo
- Struct agrupa campos com nome num tipo seu. Leia campos com o ponto.
- Para alterar qualquer campo, a variável inteira precisa ser
mut. ..outrapreenche os campos que faltam, movendo o que não é cópia.- Tuple struct cria um tipo novo sem nomes de campo, como
Reais(f64). - Métodos ficam em
imple recebem&self,&mut selfouself. - Funções associadas, como
new, não recebemselfe são chamadas com::. #[derive(Debug)]permite imprimir com{:?}e{:#?}.
Desafio
Crie uma struct Retangulo com largura e altura (em metros, f64). Dê a ela uma função new, um método area, um método eh_quadrado e um método dobrar que dobra os dois lados. Imprima o retângulo com {:?} antes e depois de dobrar.
Ver uma resposta
#[derive(Debug)]
struct Retangulo {
largura: f64,
altura: f64,
}
impl Retangulo {
fn new(largura: f64, altura: f64) -> Self {
Self { largura, altura }
}
fn area(&self) -> f64 {
self.largura * self.altura
}
fn eh_quadrado(&self) -> bool {
self.largura == self.altura
}
fn dobrar(&mut self) {
self.largura *= 2.0;
self.altura *= 2.0;
}
}
fn main() {
let mut sala = Retangulo::new(4.0, 3.0);
println!("{:?}, área {} m², quadrado? {}", sala, sala.area(), sala.eh_quadrado());
sala.dobrar();
println!("{:?}, área {} m²", sala, sala.area());
}