Was wissen Sie über Sicherheitsgarantien bei…

Die Sicherheitsgarantien für Ausnahmen bestimmen das Verhalten einer Funktion im Falle einer Ausnahme. Es werden vier Garantiestufen unterschieden:

Grundgarantie (Basic guarantee): Wenn die Funktion eine Ausnahme auslöst, bleibt das Programm in einem gültigen Zustand. Ressourcen gehen nicht verloren (z.B. wird Speicher freigegeben), aber der genaue Zustand der Objekte kann unbekannt sein. Es besteht die Möglichkeit, weiter mit der Anwendung zu arbeiten.

// Beispiel für Grundgarantie
void basic_guarantee_function(std::vector<int>& vec, int value) {
    // Bei Einfügeoperationen können Ausnahmen auftreten
    vec.push_back(value); 
    // Tritt eine Ausnahme auf, kann vec in einem unvorhersehbaren Zustand sein (teilweise geändert),
    // aber der für vec reservierte Speicher wird beim Verlassen des Gültigkeitsbereichs korrekt freigegeben.
}

Strenge Garantie (Strong guarantee): Wenn die Funktion eine Ausnahme auslöst, bleibt der Zustand des Programms unverändert im Vergleich zum Zustand vor dem Aufruf. Alle Änderungen werden rückgängig gemacht.

// Beispiel für strenge Garantie
// Verwendung der Copy-and-Swap-Idiome zur Gewährleistung der strengen Garantie
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); // Kann eine Ausnahme auslösen
    }
    Resource& operator=(Resource other) // Übergabe per Wert, die Kopie verursacht
    {
        swap(*this, other); // Löst keine Ausnahmen aus
        return *this;
    }
    friend void swap(Resource& first, Resource& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.size, second.size);
    }
    // ... andere Mitglieder
};

void strong_guarantee_function(Resource& res, size_t new_size) {
    Resource temp(new_size); // Wenn hier eine Ausnahme auftritt, ändert res sich nicht
    res = temp;               // Verwendung des überladenen Operators=, der die strenge Garantie gewährleistet
}

Garantie, keine Ausnahmen zu werfen (No-throw guarantee): Die Funktion garantiert, keine Ausnahmen zu werfen. Solche Funktionen werden mit dem noexcept-Spezifikator gekennzeichnet.

// Beispiel für keine Ausnahmen
void no_throw_function() noexcept {
    // Keine Operationen, die eine Ausnahme auslösen könnten
    int a = 5;
    int b = 10;
    int c = a + b;
}

Fehlergarantie (Failure guarantee): Im Kontext der Ausnahme-Sicherheit wird manchmal diese Ebene erwähnt, was bedeutet, dass die Funktion das Programm in einen undefinierten Zustand versetzen kann, mit möglichen Ressourcenlecks oder Fehlern. Dies ist im Wesentlichen das Fehlen von Garantien. Solches Verhalten sollte vermieden werden.

Die Bedeutung der Ausnahme-Sicherheitsgarantien liegt darin, zuverlässigen und vorhersehbaren Code zu erstellen, der Fehler und Ressourcen auch bei Ausnahmen korrekt behandelt. Die Wahl der Garantiestufe hängt von der Kritikalität der Operation, den Kosten des Rollbacks und der Wahrscheinlichkeit des Auftretens einer Ausnahme ab.

Vergleichstabelle der Garantien:

Garantie	Zustand bei Ausnahme	Datenintegrität	Ressourcenlecks
Grundlegend	Gültig, aber undefiniert	Nicht garantiert	Nein
Streng	Nicht verändert (wie vor dem Aufruf)	Bleibt erhalten	Nein
Keine Garantien	Tritt nie auf (keine Ausnahmen)	N/A	N/A
Fehler (keine Garantie)	Undefiniert, mögliche Schäden oder Fehler	Nicht garantiert	Möglicherweise

Was wissen Sie über Sicherheitsgarantien bei Ausnahmen?