Antwoord.

Achtergrond van de vraag:

In Rust is het beheer van middelen zonder garbage collector mogelijk gemaakt door strikte eigendoms- en levenscyclusregels van objecten. Voor de automatisering van het vrijgeven van middelen (zoals bestandsdescriptors, sockets, geheugen van externe libraries) is de Drop trait vanaf het begin van de ontwikkeling van de taal geïntroduceerd. Dit is de belangrijkste manier om te reageren op het einde van de levensduur van een object, wat wordt toegepast voor het finaliseren en teruggeven van middelen aan het besturingssysteem of voor het vrijgeven van geheugen.

Probleem:

Gewone types in Rust maken automatisch hun eigen middelen schoon, maar wanneer een structuur een bron opslaat die handmatig moet worden vrijgegeven (bijvoorbeeld een geopend bestand of een onveilige pointer), kunnen de onwil of vergeetachtigheid van de ontwikkelaar leiden tot lekken of race condities. Als Drop verkeerd is geïmplementeerd (bijvoorbeeld, er is geen rekening gehouden met de mogelijkheid van dubbele vrijgave van geheugen), kan dit leiden tot runtime-fouten.

Oplossing:

De Drop trait maakt het mogelijk om een speciale methode drop(&mut self) te definiëren, die automatisch wordt aangeroepen bij het vernietigen van een waarde. Het is geschikt voor het vrijgeven van middelen precies op het moment dat het object uit het zicht verdwijnt. Het is belangrijk om te onthouden dat middelen (zoals het sluiten van een bestand) alleen hier moeten worden vrijgegeven.

Code voorbeeld:

struct RawFile {
    handle: *mut libc::FILE,
}

impl Drop for RawFile {
    fn drop(&mut self) {
        if !self.handle.is_null() {
            unsafe {
                libc::fclose(self.handle);
            }
        }
    }
}

Belangrijke kenmerken:

De drop-methode wordt niet expliciet aangeroepen — alleen door de compiler.
Drop wordt alleen geïmplementeerd voor structuren die een niet-Rust bron bezitten.
Drop wordt niet aangeroepen bij een lek via mem::forget of panic! standaard (buiten unwinding).

Misleidende vragen.

Kan drop expliciet voor een object worden aangeroepen om het middel eerder vrij te geven?

Nee, het is verboden om de drop-methode direct aan te roepen (&obj.drop()) — alleen via de functie std::mem::drop(obj), die het eigendom van het object accepteert en drop automatisch aanroept. Een directe aanroep van drop() compileert niet.

Code voorbeeld:

fn main() {
    let f = File::open("foo.txt").unwrap();
    // drop(&mut f); // Compilatiefout!
    std::mem::drop(f); // Correct: bestand sluiten
}

Wat gebeurt er als een structuur met Drop onder memcpy of move valt? Wordt de destructor dan niet twee keer aangeroepen?

Nee, de destructor wordt altijd precies één keer aangeroepen gedurende de hele levenscyclus van het object, en de compiler houdt hier toezicht op. Maar als je onveilige kopieën van "rauwe" bytes van een structuur maakt of mem::forget gebruikt, kan drop helemaal niet worden aangeroepen — vandaar het gevaar.

Kan Drop en Copy tegelijkertijd worden geïmplementeerd voor hetzelfde type?

Nee, de compiler staat deze combinatie niet toe: een type dat Drop implementeert, kan niet Copy zijn, om een eenmalige aanroep van de destructor te garanderen en dubbele vrijgave van middelen uit te sluiten.

Typische fouten en anti-patronen

Directe aanroep van de drop-methode (niet toegestaan)
Niet-vrijgegeven bron of niet-gesloten bestand door vergeten Drop
Gebruik na vrijgave (use after free) door onvoorzichtige pointer
Implementatie van Drop tegelijk met Copy (Compileerfout)
Complexe eigendomsstructuren, waarbij de volgorde van drop kritiek is

Levensvoorbeeld

Negatieve case

Een programmeur heeft een eenvoudige wrapper geschreven voor het werken met een geopend bestand, maar vergat Drop te implementeren en de descriptor te sluiten bij verwijdering van het object.

Voordelen:

Geen overbodige code, structuur eenvoudig te begrijpen

Nadelen:

Na het verlaten van de scope blijft de descriptor open
Dit kan leiden tot uitputting van descriptors en een mislukking van het besturingssysteem

Positieve case

Een ontwikkelaar heeft Drop geïmplementeerd voor de wrapper van de bestandsdescriptor, waarbij het bestand expliciet wordt gesloten in drop. Nu worden middelen gegarandeerd vrijgegeven wanneer een variabele van deze structuur de functie of panic verlaat.