Čo viete o zárukách bezpečnosti výnimiek?

Garancie bezpečnosti výnimiek určujú správanie funkcie v prípade výskytu výnimky. Rozlišujú sa štyri úrovne záruk:

Základná záruka (Basic guarantee): Ak funkcia vyvolá výnimku, program zostáva v platnom stave. Zdroje nie sú stratené (napríklad, pamäť je uvoľnená), ale presný stav objektov môže byť neznámy. Je možné s aplikáciou ďalej pracovať.

// Príklad základnej záruky
void basic_guarantee_function(std::vector<int>& vec, int value) {
    // Môžu nastať výnimky pri vkladaní
    vec.push_back(value); 
    // Ak dôjde k výnimke, vec môže byť v nepredvídateľnom stave (čiastočne zmenené),
    // ale pamäť pridelená pre vec bude správne uvoľnená pri opustení oblasti viditeľnosti.
}

Silná záruka (Strong guarantee): Ak funkcia vyvolá výnimku, stav programu zostáva rovnaký ako pred volaním. Všetky zmeny sú vrátené späť.

// Príklad silnej záruky
// Používame idiom Copy-and-Swap na zabezpečenie silnej záruky
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); // Môže vyvolať výnimku
    }
    Resource& operator=(Resource other) // Prenos hodnotou
    {
        swap(*this, other); // Nevyvoláva výnimky
        return *this;
    }
    friend void swap(Resource& first, Resource& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.size, second.size);
    }
    // ... ďalšie členovia
};

void strong_guarantee_function(Resource& res, size_t new_size) {
    Resource temp(new_size); // Ak tu dôjde k výnimke, res sa nezmení
    res = temp;               // Používame preťažený operátor =, ktorý zabezpečuje silnú záruku
}

Záruka bez výnimiek (No-throw guarantee): Funkcia garantovane nevyvolá výnimku. Takéto funkcie sú označené špecifikátorom noexcept.

// Príklad bez výnimiek
void no_throw_function() noexcept {
    // Neexistujú operácie, ktoré by mohli vyvolať výnimku
    int a = 5;
    int b = 10;
    int c = a + b;
}

Záruka zlyhania (Failure guarantee): V kontexte bezpečnosti výnimiek sa niekedy spomína tento stupeň, čo znamená, že funkcia môže nechať program v neurčitom stave, možný únik zdrojov alebo chyby. Ide o praktickú absenciu záruk. Takéto správanie je potrebné sa vyvarovať.

Význam záruk bezpečnosti výnimiek spočíva v tvorbe spoľahlivého a predvídateľného kódu, ktorý správne spracováva chyby a správu zdrojov aj pri výskyte výnimiek. Úroveň záruky závisí od kritickosti operácie, nákladov na vrátenie a pravdepodobnosti výskytu výnimky.

Tabuľka porovnania záruk:

Záruka	Stav pri výskyte výnimky	Integrita dát	Úniky zdrojov
Základná	Platný, ale neurčitý	Nie je garantované	Nie
Silná	Nemenná (ako pred volaním)	Zachováva sa	Nie
Bez výnimiek	Nikdy nenastáva (žiadne výnimky)	N/A	N/A
Zlyhanie (ne)	Neurčitý, môže dôjsť k poškodeniu alebo chybám	Nie je garantované	Môže byť