Wat weet u over de beveiligingsgaranties van…

De exception safety garanties bepalen het gedrag van een functie in het geval van een uitzondering. Er worden vier niveaus van garanties onderscheiden:

Basis garantie (Basic guarantee): Als de functie een uitzondering gooit, blijft het programma in een geldige staat. Resources lekken niet (bijvoorbeeld, geheugen wordt vrijgegeven), maar de exacte toestand van de objecten kan onbekend zijn. Het is mogelijk om verder te werken met de applicatie.

// Voorbeeld van basis garantie
void basic_guarantee_function(std::vector<int>& vec, int value) {
    // Er kunnen uitzonderingen optreden bij het toevoegen
    vec.push_back(value); 
    // Als er een uitzondering optreedt, kan vec in een onvoorspelbare toestand zijn (gedeeltelijk gewijzigd),
    // maar het geheugen dat voor vec is toegewezen, wordt correct vrijgegeven bij het verlaten van de scope.
}

Sterke garantie (Strong guarantee): Als de functie een uitzondering gooit, blijft de toestand van het programma hetzelfde als vóór de aanroep. Alle wijzigingen worden teruggedraaid.

// Voorbeeld van sterke garantie
// Gebruik van de Copy-and-Swap idiom om sterke garantie te garanderen
class Resource {
    int* data;
    size_t size;
public:
    Resource(size_t s) : size(s), data(new int[s]) {}
    ~Resource() { delete[] data; }
    Resource(const Resource& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data); // Kan een uitzondering werpen
    }
    Resource& operator=(Resource other) {
        swap(*this, other); // Werpt geen uitzonderingen
        return *this;
    }
    friend void swap(Resource& first, Resource& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.size, second.size);
    }
    // ... andere leden
};

void strong_guarantee_function(Resource& res, size_t new_size) {
    Resource temp(new_size); // Als hier een uitzondering optreedt, verandert res niet
    res = temp; // Gebruikt de overloaded operator= die sterke garantie biedt
}

No-throw garantie: De functie gooit gegarandeerd geen uitzonderingen. Dergelijke functies worden gemarkeerd met de noexcept specificator.

// Voorbeeld van geen uitzonderingen
void no_throw_function() noexcept {
    // Geen operaties die een uitzondering kunnen werpen
    int a = 5;
    int b = 10;
    int c = a + b;
}

Faalgarantie (Failure guarantee): In de context van uitzonderingbeveiliging wordt soms deze niveau genoemd, wat betekent dat de functie het programma in een ongedefinieerde toestand kan achterlaten, met mogelijk resource leaks of fouten. Dit is in feite het ontbreken van garanties. Dit gedrag moet worden vermeden.

Het belang van uitzonderingbeveiligingsgaranties ligt in het creëren van betrouwbare en voorspelbare code die fouten en resources correct afhandelt, zelfs bij het optreden van uitzonderingen. De keuze van het garantieniveau hangt af van de kriticiteit van de operatie, de kosten van rollback en de waarschijnlijkheid van het optreden van een uitzondering.

Vergelijkingstabel van garanties:

Garantie	Toestand bij uitzondering	Gegevensintegriteit	Resource leaks
Basis	Geldig, maar ongedefinieerd	Wordt niet gegarandeerd	Nee
Sterk	Onveranderd (zoals vóór de aanroep)	Wordt behouden	Nee
Geen garanties	Nooit gebeurt (geen uitzonderingen)	N/A	N/A
Faal (geen garantie)	Ongedefined, mogelijk schade of fouten	Wordt niet gegarandeerd	Mogelijk

Wat weet u over de beveiligingsgaranties van uitzonderingen?