Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Bezpečnost při výjimkách: záruky a copy-and-swap

Záruky bezpečnosti při výjimkách určují, jaký stav zůstane po selhání operace: platný, nezměněný, nebo bez propagované výjimky. Copy-and-swap může poskytnout silnou záruku tím, že před potvrzením změny připraví kopii.

Verze: C++23; repository compiler flag, production runtime not attested

Syntaxe

T& operator=(const T& other) { T temporary(other); swap(temporary); return *this; }
void swap(T& other) noexcept;

Bezpečnost při výjimkách popisuje smlouvu operace, nikoli pouze použití try a catch. Základní záruka (basic guarantee) zachovává invarianty objektů a brání únikům prostředků, ale připouští změnu hodnot po výjimce. Silná záruka (strong guarantee) navíc slibuje, že neúspěšná operace nemá v rozsahu své smlouvy žádné účinky: buď se dokončí celá, nebo ponechá tento stav beze změny.

Záruka bez výjimek (no-throw) znamená, že operace nepropaguje výjimky. Samotné noexcept nedokazuje správné zpracování chyb: pokus výjimky opustit takovou funkci vyvolá std::terminate místo vrácení změn zpět. Záruky se dokumentují pro každou operaci zvlášť; pouhá přítomnost catch je nezajišťuje.

Copy-and-swap zajišťuje silnou bezpečnost při přiřazení: nejprve vytvoří temporary a potom změnu potvrdí pomocí swap, který nevyvolává výjimky. Pokud kopírování selže, cíl ještě nebyl změněn. Po výměně obsahuje dočasný objekt původní stav a při zničení jej uvolní. Tato technika vyžaduje kopírování bez změny originálu, výměnu bez výjimek a bezpečné ničení. Náklady mohou zahrnovat kopii a alokaci navíc; vnější účinky, například zápis do souboru, se automaticky nevrátí.

RAII váže prostředky na dobu života objektů: při odvíjení zásobníku se ničí již vytvořené lokální objekty. Destruktory by měly uklízet bez propagace výjimek. Pokud výjimka opustí destruktor vyvolaný v rámci odvíjení zásobníku, zavolá se std::terminate. Pokud však úklidový kód při svém běžném vykonávání zavolá destruktor, který může vyvolat výjimku, může catch v témže úklidovém kódu výjimku z tohoto destruktoru zachytit, i když odvíjení zásobníku kvůli původní výjimce stále probíhá. Standard vyžaduje ve standardní knihovně destruktory, které nevyvolávají výjimky. Dodané zdroje jsou průběžně aktualizovaný návrh standardu, nikoli neměnný text C++23.

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

Pří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ýsledek

after failure: 7
after success: 42

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje