Methoden en impl-blokken

In Rust zijn methoden vergelijkbaar met functies, maar ze worden gedefinieerd binnen de context van een struct (of een enum of trait), en hun eerste parameter is altijd self, die de instantie vertegenwoordigt van de struct waarop de methode wordt aangeroepen.

Methoden definiëren met impl

Om methoden op een struct te definiëren, gebruiken we een impl (implementatie) blok met de naam van de struct:

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

impl Rectangle {
    // This is an instance method. It takes &self for reading.
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

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

    // Call the method using dot notation
    println!("The area is: {}", rect.area());
}

Bijbehorende (statische) functies

Functies gedefinieerd binnen een impl blok die niet self als hun eerste parameter accepteren, worden geassocieerde functies genoemd (equivalent aan statische methoden in andere talen).

Ze worden vaak gebruikt als constructors om nieuwe exemplaren van de struct te retourneren. Om ze op te roepen, gebruik je de dubbele dubbele punt :: syntaxis:

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

fn main() {
    // Call the associated function
    let sq = Rectangle::square(10);
}

Methoden die de status wijzigen: &mut self

Als een methode de velden van de struct moet wijzigen, moet deze de eerste parameter declareren als &mut self. De instantie zelf waarop de methode wordt aangeroepen, moet als veranderlijk worden gedeclareerd (let mut):

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

Probeer het zelf