Antwoord.

Achtergrond

In Rust zijn er geen klassieke constructeurs zoals in OOP-talen, maar er zijn geassocieerde functies (meestal new) die de constructormethode met expliciete initiatie implementeren. Geassocieerde functies maken het mogelijk om structuren te maken met vooraf ingestelde waarden of ze te creëren met aanvullende logica (bijvoorbeeld met geheugenreservatie).

Probleem

Veel mensen beginnen alleen new te gebruiken en vergeten andere patronen van fabrieksmethoden (zoals with_capacity), of implementeren het initialiseren van structuren verkeerd (vooral met private/publieke velden), wat kan leiden tot invariantiefouten.

Oplossing

Een geassocieerde functie zoals new wordt geïmplementeerd via impl, en kan de enige toegangspunt zijn voor het creëren van objecten met invarianten. Functies zoals with_capacity bieden extra mogelijkheden, zoals het vooraf toewijzen van geheugen.

Voorbeeldcode:

pub struct MyBuffer {
    data: Vec<u8>,
}

impl MyBuffer {
    pub fn new() -> Self {
        MyBuffer { data: Vec::new() }
    }

    pub fn with_capacity(cap: usize) -> Self {
        MyBuffer { data: Vec::with_capacity(cap) }
    }
}

Belangrijke kenmerken:

Geassocieerde functies ontvangen geen self en werken als statische methoden.
Publieke fabrieksmethoden helpen bij het instellen van invarianten.
Het is mogelijk om verschillende "constructeurs" te implementeren voor verschillende scenario's.

Vragen met een val.

Als je new niet implementeert, creëert Rust deze dan standaard?

Nee. Er is geen automatische generatie van new. Als de methode niet expliciet is geïmplementeerd, is deze er niet, zelfs als de structuur alleen publieke velden heeft.

Wat is het fundamentele verschil tussen new en Default?

Default is een trait-constructor die alleen kan worden aangeroepen waar het type Default implementeert of expliciet heeft geërfd. Het is standaard voor generieke algoritmen, maar komt niet altijd overeen met new.

Kan je de methoden new en with_capacity gebruiken voor private structuren?

Ja, methoden kunnen publiek of privé worden gemaakt, maar het maken van een publieke constructeur voor een private structuur stelt gebruikers niet in staat om instanties van deze structuur buiten de module te maken.

Typische fouten en anti-patronen

Alle velden van de structuur openbaar maken, waardoor ongeldige waarden buiten de constructeur kunnen worden gemaakt.
with_capacity niet implementeren voor collecties waar geheugenbesparing essentieel is.
new implementeren die niet alle velden correct initialiseert.

Voorbeeld uit het leven

Negatief geval

Open structuur zonder invarianten, alle velden zijn publiek:

pub struct User {
    pub login: String,
    pub active: bool
}

Voordelen:

Eenvoudig om objecten te maken.

Nadelen:

Mogelijk om ongeldige waarden te creëren (bijvoorbeeld een lege login, niet-geïnitialiseerde velden).

Positief geval

Velden zijn privé, creatie alleen via new, invarianten zijn gewaarborgd:

pub struct User {
    login: String,
    active: bool
}
impl User {
    pub fn new(login: String) -> User {
        User { login, active: true }
    }
}