Introduction aux blocs d'implémentation

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy — leçon 1 sur 61.

En Rust, les structs définissent les données qu'un type contient, mais elles ne définissent pas ce que ce type peut faire. Pour donner un comportement à une struct, nous utilisons des blocs d'implémentation avec le mot-clé impl.

Un bloc d'implémentation connecte des fonctions (appelées méthodes) à une structure spécifique. Voici la structure de base :

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

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

Le bloc impl Dog indique à Rust que tout ce qui se trouve à l'intérieur appartient à la struct Dog. Cette séparation permet de garder la définition de vos données propre tout en vous permettant d'ajouter autant de méthodes que nécessaire dans le bloc d'implémentation.

Pour appeler une méthode, utilisez la notation par point sur une instance :

fn main() {
    let my_dog = Dog {
        name: String::from("Rex"),
        age: 3,
    };
    
    my_dog.bark(); // Sortie : Rex dit woof !
}

Ce modèle consistant à séparer les données (la structure struct) du comportement (le bloc impl) est fondamental pour organiser le code Rust. Dans les prochaines leçons, nous explorerons comment les méthodes accèdent aux données de la structure via le paramètre &self que vous voyez dans l'exemple ci-dessus.

Défi

Facile

Créez une structure Cat avec deux champs : name (String) et lives (u8).

Ajoutez un bloc d'implémentation pour Cat avec une méthode appelée meow qui prend &self et affiche le nom du chat suivi de " says meow!".

Vous recevrez deux entrées :

Première ligne : le nom du chat (String)
Deuxième ligne : le nombre de vies (u8)

Créez une instance de Cat avec les valeurs fournies et appelez la méthode meow sur celle-ci.

Format de sortie attendu :

{name} says meow!

Aide-mémoire

Les blocs d'implémentation connectent les méthodes aux structures en utilisant le mot-clé impl :

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

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

Le bloc impl sépare la définition des données (structure) du comportement (méthodes). Les méthodes sont appelées en utilisant la notation par point :

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

my_dog.bark(); // Résultat : Rex says woof!

Les méthodes utilisent le paramètre &self pour accéder aux données de la structure.

Essayez vous-même

use std::io;

// TODO: Définir la structure Cat avec les champs 'name' (String) et 'lives' (u8)


// TODO: Ajouter un bloc d'implémentation pour Cat avec une méthode '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: Créer une instance de Cat et appeler la méthode meow
    
}