Methoden und impl-Blöcke

In Rust ähneln Methoden Funktionen, werden aber im Kontext einer Struct (oder eines Enums oder Traits) definiert, und ihr erster Parameter ist immer self, was die Instanz der Struct darstellt, auf der die Methode aufgerufen wird.

Methoden mit impl definieren

Um Methoden für eine Struct zu definieren, verwenden wir einen impl-Block (Implementation) mit dem Namen der 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());
}

Assoziierte Funktionen (Statische Methoden)

Funktionen, die in einem impl-Block definiert sind und self nicht als ersten Parameter akzeptieren, werden als assoziierte Funktionen bezeichnet (entspricht statischen Methoden in anderen Sprachen).

Sie werden oft als Konstruktoren verwendet, um neue Instanzen der Struct zurückzugeben. Zum Aufrufen wird die Syntax mit doppeltem Doppelpunkt :: verwendet:

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);
 }

Methoden, die den Zustand ändern: &mut self

Wenn eine Methode die Felder der Struct ändern muss, muss sie den ersten Parameter als &mut self deklarieren. Die Instanz selbst, auf der die Methode aufgerufen wird, muss als veränderlich deklariert werden (let mut):

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

Probiere es aus