Sniedziet piemērus situācijām, kad varētu notikt…

Dublētā izņēmuma (double exception) C++ rodas, kad izņēmuma apstrādes laikā (catch blokā) rodas jauns izņēmums pirms iepriekšējā apstrādes pabeigšanas. Tas noved pie std::terminate izsaukšanas.

Situāciju piemēri:

Jauna izņēmuma izsaukšana catch blokā:

#include <iostream>
#include <stdexcept>

void func() {
    throw std::runtime_error("Pirmā izņēmums");
}

int main() {
    try {
        func();
    } catch (const std::runtime_error& e) {
        std::cerr << "Noķerts: " << e.what() << std::endl;
        throw std::logic_error("Otrā izņēmums catch'ā"); // Jauna izņēmuma izsaukšana
    }
    return 0;
}

Šeit catch blokā, kas apstrādā std::runtime_error, tiek izsaukts jauns izņēmums std::logic_error.

Izņēmums resursu tīrīšanas laikā destruktora laikā, kad apstrādā citu izņēmumu:

#include <iostream>
#include <stdexcept>
#include <vector>

struct Resource {
    ~Resource() noexcept(false) { // Destruktors var izsaukt izņēmumu
        std::cerr << "Resource destruktors izsaukts" << std::endl;
        if (true) { // Nosacījums, kas izraisa izņēmumu
            throw std::runtime_error("Izņēmums Resource destruktora laikā");
        }
    }
};

void risky_func() {
    Resource r; // Objekts izveidots, kura destruktors var izsaukt izņēmumu
    throw std::runtime_error("Izņēmums no risky_func"); // Pirmā izņēmums
}

int main() {
    try {
        risky_func();
    } catch (const std::runtime_error& e) {
        std::cerr << "Noķerts: " << e.what() << std::endl;
        // Šeit var notikt izņēmums destruktora laikā 'r', kamēr apstrādā pirmo izņēmumu
    }
    return 0;
}

Kad risky_func izsauc izņēmumu, notiek steka izpakošana. Procesā tiks izsaukts objekta r destruktors. Ja šis destruktors pats izsauc izņēmumu, kamēr notiek pirmā izņēmuma apstrāde, tiks radīts dubultais izņēmums.

Izņēmums izņēmuma apstrādē, kas rodas iekšēju kļūdu vai funkciju izsaukumu dēļ, kas izsauc izņēmumu:

#include <iostream>
#include <stdexcept>
#include <vector>

void process_error(const std::exception& e) {
    std::cerr << "Kļūdas apstrāde: " << e.what() << std::endl;
    // Pieņemams, ka šī funkcija var izsaukt izņēmumu noteiktos apstākļos
    if (e.what() && std::string(e.what()).length() > 20) {
         throw std::logic_error("Pārāk garš kļūdas ziņojums"); // Otrā izņēmums
    }
}

int main() {
    try {
        throw std::runtime_error("Tas ir diezgan garš kļūdas ziņojums"); // Pirmā izņēmums
    } catch (const std::exception& e) {
        process_error(e); // Šis izsaukums var izsaukt otro izņēmumu
    }
    return 0;
}

Šajā gadījumā funkcija process_error, kas izsaukta catch blokā pirmās izņēmuma apstrādei, pati izraisa otro izņēmumu.

Visos šajos scenārijos, jo otrā izņēmuma izveide notiek pirms pirmās apstrādes pabeigšanas (vai tās laikā staka izpakošanas laikā), standarta C++ pieprasa izsaukt std::terminate. std::terminate pēc noklusējuma izsauc abort().

Sniedziet piemērus situācijām, kad varētu notikt atkārtota izņēmuma gadījums 'double exception' konstrukcijas izmantošanas kontekstā.