Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Bezpečnosť pri výnimkách: záruky a copy-and-swap

Záruky bezpečnosti pri výnimkách určujú, aký stav zostane po zlyhaní operácie: platný, nezmenený alebo bez propagovanej výnimky. Copy-and-swap môže poskytnúť silnú záruku tým, že pred potvrdením zmeny pripraví kópiu.

Verzia: 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;

Bezpečnosť pri výnimkách opisuje zmluvu operácie, nie iba použitie try a catch. Základná záruka (basic guarantee) zachováva invarianty objektov a bráni únikom prostriedkov, ale pripúšťa zmenu hodnôt po výnimke. Silná záruka (strong guarantee) navyše sľubuje, že neúspešná operácia nemá v rozsahu svojej zmluvy žiadne účinky: buď sa dokončí celá, alebo ponechá tento stav nezmenený.

Záruka bez výnimiek (no-throw) znamená, že operácia nepropaguje výnimky. Samotné noexcept nedokazuje správne spracovanie chýb: pokus výnimky opustiť takúto funkciu vyvolá std::terminate namiesto vrátenia zmien späť. Záruky sa dokumentujú pre každú operáciu osobitne; samotná prítomnosť catch ich nezaručuje.

Copy-and-swap zabezpečuje silnú bezpečnosť pri priradení: najprv vytvorí temporary a potom zmenu potvrdí pomocou swap, ktorý nevyvoláva výnimky. Ak kopírovanie zlyhá, cieľ ešte nebol zmenený. Po výmene obsahuje dočasný objekt pôvodný stav a pri zničení ho uvoľní. Táto technika vyžaduje kopírovanie bez zmeny originálu, výmenu bez výnimiek a bezpečné ničenie. Náklady môžu zahŕňať kópiu a alokáciu navyše; vonkajšie účinky, napríklad zápis do súboru, sa automaticky nevrátia.

RAII viaže prostriedky na životnosť objektov: počas odvíjania zásobníka sa ničia už vytvorené lokálne objekty. Destruktory by mali upratovať bez propagácie výnimiek. Ak výnimka opustí deštruktor vyvolaný v rámci odvíjania zásobníka, zavolá sa std::terminate. Ak však kód na uvoľňovanie prostriedkov pri svojom bežnom vykonávaní zavolá deštruktor, ktorý môže vyvolať výnimku, catch v tom istom kóde môže výnimku z tohto deštruktora zachytiť, aj keď odvíjanie zásobníka v dôsledku pôvodnej výnimky stále prebieha. Štandard vyžaduje v štandardnej knižnici destruktory, ktoré nevyvolávajú výnimky. Dodané zdroje sú priebežne aktualizovaný návrh štandardu, nie nemenný text C++23.

Referenčné identifikátory zahrnuté v tomto hesle: Basic, strong and no-throw guarantees; copy-and-swap.

Príklady

#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';
}

Výsledok

after failure: 7
after success: 42

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje