Introdução a Blocos de Implementação

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 1 de 61.

Em Rust, structs definem quais dados um tipo contém, mas elas não definem o que esse tipo pode fazer. Para dar comportamento a uma struct, usamos blocos de implementação com a palavra-chave impl.

Um bloco de implementação conecta funções (chamadas de métodos) a uma struct específica. Aqui está a estrutura básica:

struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    fn bark(&self) {
        println!("{} says woof!", self.name);
    }
}

O bloco impl Dog diz ao Rust que tudo o que está dentro pertence à struct Dog. Essa separação mantém a definição dos seus dados limpa, enquanto permite que você adicione quantos métodos forem necessários no bloco de implementação.

Para chamar um método, use a notação de ponto em uma instância:

fn main() {
    let my_dog = Dog {
        name: String::from("Rex"),
        age: 3,
    };
    
    my_dog.bark(); // Saída: Rex diz au au!
}

Este padrão de separar dados (a struct) do comportamento (o bloco impl) é fundamental para organizar o código Rust. Nas próximas lições, exploraremos como os métodos acessam os dados da struct através do parâmetro &self que você vê no exemplo acima.

Desafio

Fácil

Crie uma struct Cat com dois campos: name (String) e lives (u8).

Adicione um bloco de implementação para Cat com um método chamado meow que recebe &self e imprime o nome do gato seguido por " says meow!".

Você receberá duas entradas:

Primeira linha: o nome do gato (String)
Segunda linha: o número de vidas (u8)

Crie uma instância de Cat com os valores fornecidos e chame o método meow nela.

Formato de saída esperado:

{name} says meow!

Folha de consulta

Blocos de implementação conectam métodos a structs usando a palavra-chave impl:

struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    fn bark(&self) {
        println!("{} says woof!", self.name);
    }
}

O bloco impl separa a definição de dados (struct) do comportamento (métodos). Os métodos são chamados usando a notação de ponto:

let my_dog = Dog {
    name: String::from("Rex"),
    age: 3,
};

my_dog.bark(); // Saída: Rex says woof!

Os métodos usam o parâmetro &self para acessar os dados da struct.

Experimente você mesmo

use std::io;

// TODO: Defina a struct Cat com os campos 'name' (String) e 'lives' (u8)


// TODO: Adicione um bloco de implementação para Cat com um método 'meow'


fn main() {
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut lives_input = String::new();
    io::stdin().read_line(&mut lives_input).expect("Failed to read line");
    let lives: u8 = lives_input.trim().parse().expect("Failed to parse lives");
    
    // TODO: Crie uma instância de Cat e chame o método meow
    
}