Méthodes et blocs impl

En Rust, les méthodes sont similaires aux fonctions, mais elles sont définies dans le contexte d'une struct (ou d'un enum ou trait) et leur premier paramètre est toujours self, qui représente l'instance de la struct sur laquelle la méthode est appelée.

Définir les Méthodes avec impl

Pour définir des méthodes sur une struct, on utilise un bloc impl (implementation) avec le nom de la struct :

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Questo è un metodo d'istanza. Prende &self in lettura.
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };

    // Chiamata al metodo tramite notazione con punto
    println!("L'area è: {}", rect.area());
}

Fonctions Associées (Statiques)

Les fonctions définies dans un bloc impl qui n'acceptent pas self comme premier paramètre sont appelées fonctions associées (équivalentes aux méthodes statiques dans d'autres langages).

Elles sont souvent utilisées comme constructeurs pour renvoyer de nouvelles instances de la struct. Pour les appeler, on utilise la syntaxe à double deux-points :: :

impl Rectangle {
    // Funzione associata
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    // Chiamata alla funzione associata
     let sq = Rectangle::square(10);
 }

Méthodes qui Modifient l'État : &mut self

Si une méthode doit modifier les champs de la struct, elle doit déclarer son premier paramètre comme &mut self. L'instance elle-même sur laquelle la méthode est appelée doit être déclarée comme mutable (let mut) :

impl Rectangle {
    fn double_size(&mut self) {
        self.width *= 2;
        self.height *= 2;
    }
}

À toi de jouer