Pular para o conteúdo
Rust em Português

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 ser mut.
  • 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.
  • ..outra preenche 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 impl e recebem &self, &mut self ou self.
  • Funções associadas, como new, não recebem self e 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());
}
Salvo só neste navegador.