CKTIS / C++
Uitzonderingsveiligheid: garanties en copy-and-swap
Garanties voor uitzonderingsveiligheid geven aan welke toestand overblijft als een bewerking mislukt: een geldige toestand, een ongewijzigde toestand of geen doorgegeven uitzondering. Copy-and-swap kan de sterke garantie bieden door een kopie voor te bereiden voordat een wijziging wordt vastgelegd.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
T& operator=(const T& other) { T temporary(other); swap(temporary); return *this; }
void swap(T& other) noexcept;Uitzonderingsveiligheid beschrijft het contract van een bewerking, niet alleen het gebruik van try en catch. De basale garantie (basic guarantee) behoudt objectinvarianten en voorkomt resourcelekken, maar staat toe dat waarden na een uitzondering veranderen. De sterke garantie (strong guarantee) belooft bovendien dat een mislukte bewerking geen gevolgen heeft binnen het bereik van haar contract: de bewerking wordt volledig uitgevoerd of laat die toestand ongewijzigd.
De no-throw-garantie betekent dat een bewerking geen uitzonderingen doorgeeft. Alleen noexcept opschrijven bewijst niet dat fouten correct worden afgehandeld: als een uitzondering uit zo’n functie probeert te ontsnappen, wordt std::terminate aangeroepen in plaats van wijzigingen terug te draaien. Garanties worden per bewerking vastgelegd; de aanwezigheid van een catch is op zichzelf geen garantie.
Copy-and-swap realiseert sterke uitzonderingsveiligheid bij toewijzing: eerst wordt temporary gemaakt, daarna wordt de wijziging vastgelegd via een swap die geen uitzondering werpt. Als het kopiëren mislukt, is het doel nog niet gewijzigd. Na het wisselen bevat het tijdelijke object de oude toestand en geeft het die vrij wanneer het wordt vernietigd. Deze techniek vereist kopiëren zonder het origineel te wijzigen, een niet-werpend wisselen en veilige vernietiging. De kosten kunnen een extra kopie en allocatie omvatten; externe gevolgen, zoals schrijven naar een bestand, worden niet automatisch ongedaan gemaakt.
RAII koppelt resources aan de levensduur van objecten: tijdens stack unwinding worden reeds geconstrueerde lokale objecten vernietigd. Destructors moeten opruimen zonder uitzonderingen door te geven. Als een uitzondering ontsnapt uit een destructor die als onderdeel van stack unwinding wordt aangeroepen, wordt std::terminate aangeroepen. Roept opruimcode daarentegen in haar normale uitvoeringsverloop een destructor aan die uitzonderingen kan werpen, dan kan een catch in diezelfde opruimcode een uitzondering uit die destructor opvangen, ook als de stack unwinding vanwege de oorspronkelijke uitzondering nog bezig is. De standaard vereist niet-werpende destructors in de standaardbibliotheek. De aangeleverde bronnen zijn een doorlopend bijgewerkt standaardontwerp, geen bevroren C++23-tekst.
Referentie-identificatoren die in dit item worden behandeld: Basic, strong and no-throw guarantees; copy-and-swap.
Voorbeelden
#include <iostream>
struct CopyFailure {};
class Value {
int number_;
public:
inline static bool fail_copy = false;
explicit Value(int number) noexcept : number_(number) {}
Value(const Value& other) : number_(other.number_) {
if (fail_copy) throw CopyFailure{};
}
void swap(Value& other) noexcept {
int old = number_;
number_ = other.number_;
other.number_ = old;
}
Value& operator=(const Value& other) {
Value temporary(other);
swap(temporary);
return *this;
}
int get() const noexcept { return number_; }
};
int main() {
Value target(7), source(42);
Value::fail_copy = true;
try {
target = source;
} catch (const CopyFailure&) {
std::cout << "after failure: " << target.get() << '\n';
}
Value::fail_copy = false;
target = source;
std::cout << "after success: " << target.get() << '\n';
}
Resultaat
after failure: 7 after success: 42
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.