Wat zijn uitzonderingen in C++?

Mechanisme voor het afhandelen van abnormale situaties (fouten) die optreden tijdens de uitvoering van een programma. Het maakt het mogelijk om de code die verantwoordelijk is voor de logica van het programma te scheiden van de foutafhandelingscode.

Trefwoorden:

• try: Definieert een codeblok waarin uitzonderingen kunnen optreden.
• catch: Definieert een codeblok dat wordt uitgevoerd wanneer een bepaald type uitzondering optreedt.
• throw: Genereert (maakt) een uitzondering. Het type uitzondering kan elk object zijn.

Werking:

1. De code die een fout kan veroorzaken, wordt in het try-blok geplaatst.
2. Als er een uitzondering optreedt in het try-blok (gegenereerd door throw), wordt de normale uitvoering van het programma onderbroken.
3. Het systeem zoekt een geschikt catch-blok dat de gegenereerde uitzondering kan afhandelen (per type).
4. Als een passend catch wordt gevonden, wordt de code ervan uitgevoerd.
5. Als er geen passend catch op het huidige niveau van de aanroep wordt gevonden, wordt de uitzondering "gepropageerd" naar boven in de aanroepstapel totdat een geschikte afhandelingsfunctie wordt gevonden (of het programma wordt onjuist beëindigd).

Voorbeeld:

#include <iostream>
#include <stdexcept> // Voor standaard uitzonderings types

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Delen door nul!"); // Genereer een uitzondering
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0); // Roep een functie op die een uitzondering kan werpen
        std::cout << "Resultaat: " << result << std::endl; // Deze regel wordt niet uitgevoerd
    } catch (const std::runtime_error& e) { // Vang de uitzondering van type std::runtime_error
        std::cerr << "Fout: " << e.what() << std::endl; // Verwerk de uitzondering
    } catch (...) { // Vang alle andere uitzonderingen (punten)
        std::cerr << "Er is een onbekende fout opgetreden." << std::endl;
    }

    std::cout << "Programma gaat verder na foutafhandeling." << std::endl;
    return 0;
}

Voordelen:

• Scheiding van logica en foutafhandeling.
• Vereenvoudigt de hoofdcode.
• Mogelijkheid om fouten op verschillende niveaus van de hiërarchie af te handelen.

Nadelen:

• Kan de prestaties beïnvloeden (door stack-propagatie).
• Moeilijkheid om de uitvoeringstroom te begrijpen bij meerdere uitzonderingen.
• Onjuist gebruik kan leiden tot resource leaks (als resources niet correct worden vrijgegeven bij een uitzondering).

Om veilig met resources te werken in aanwezigheid van uitzonderingen, worden vaak RAII (Resource Acquisition Is Initialization) en slimme pointers gebruikt.