C++ Exception Handling: Praktische Try, Catch, Throw Voorbeelden

Wat is Exception Handling in C++?

Exception handling laat C++‑programma's op een nette manier herstellen van onverwachte runtime‑fouten. Wanneer een fout optreedt, springt de controle naar een specifieke handler die kan beslissen hoe te reageren.

Door potentieel problematische code in een try-blok te plaatsen en dit te volgen met een of meer catch-clauses, geef je het programma een duidelijk pad om uitzonderlijke condities te beheren.

Als geen exception gegooid wordt, draait het try-blok normaal en worden de handlers overgeslagen.

In deze tutorial leer je:

• Wat exception handling is en waarom het belangrijk is
• De kern‑keywords: throw, catch, try
• Syntaxis en veelvoorkomende patronen
• Standaardexceptions gedefinieerd door de C++ Standard Library
• Hoe je user‑defined exceptions creëert en gebruikt

Waarom Exception Handling?

Exception handling biedt diverse concrete voordelen:

• Scheidt foutafhandelingslogica van reguliere code, wat leesbaarheid en onderhoudbaarheid verbetert.
• Stelt functies in staat om alleen de exceptions te exposen waar ze om geven; callers kunnen de rest afhandelen.

Belangrijkste Exception Handling Keywords

Drie keywords vormen de ruggengraat van C++ exception handling:

• throw – signaleert een foutconditie door een exception‑object aan te maken.
• catch – vangt een exception op en biedt code om erop te reageren.
• try – markeert het coderegio dat exceptions kan gooien.

Code binnen het try-blok heet beschermde code; als het gooit, wordt de bijbehorende catch-blok uitgevoerd.

Syntaxis

 try { // beschermde code } catch (Exception_Name exception1) { // handle exception1 } catch (Exception_Name exception2) { // handle exception2 } // ... meer catch‑blokken 

• Een enkel try kan gevolgd worden door meerdere catch-clauses.
• Het type in elke catch-clause specificeert de op te vangen exception.
• Binnen een catch kan de gevangen exception worden gerefereerd door de gekozen identificator.

Voorbeeld 1: Vector‑Element Buiten Bereik Benaderen

#include<iostream>
#include<vector>
using namespace std;
int main() {
    vector<int> vec;
    vec.push_back(0);
    vec.push_back(1);
    try {
        vec.at(2); // out of range
    } catch (exception& ex) {
        cout << "Exception occurred!" << endl;
    }
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑analyse:

1. Include iostream en vector voor I/O en container‑ondersteuning.
2. Gebruik de std-naamruimte om volledig‑gekwalificeerde namen te vermijden.
3. Instantieer een vector<int> en vul het.
4. Probeer een element buiten de grenzen van de vector te benaderen binnen een try-blok.
5. Vang de standaard std::exception en geef een bericht weer.
6. Return vanuit main.

Voorbeeld 2: Delen door Nul Afhandelen

#include <iostream>
using namespace std;
double zeroDivision(int x, int y) {
    if (y == 0) {
        throw "Division by Zero!";
    }
    return static_cast(x) / y;
}
int main() {
    int a = 11;
    int b = 0;
    double c = 0;
    try {
        c = zeroDivision(a, b);
        cout << c << endl;
    } catch (const char* message) {
        cerr << message << endl;
    }
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑analyse:

1. Definieer zeroDivision die een C‑string gooit bij deling door nul.
2. Roep de functie aan binnen een try-blok en print het resultaat.
3. Vang de string‑exception op en geef een foutmelding weer.

C++ Standaardexceptions

De Standard Library declareert een rijke hiërarchie van exceptions in <exception>. Hieronder de meest gebruikte:

User‑Defined Exceptions

De std::exception-basisklasse kan uitgebreid worden om domein‑specifieke fouttypen te creëren. Het overschrijven van what() levert een beschrijvend bericht.

Voorbeeld: Custom Exception

#include <iostream>
#include <exception>
using namespace std;
class NewException : public exception {
public:
    const char* what() const noexcept override {
        return "newException occurred";
    }
} newex;
int main() {
    try {
        throw newex;
    } catch (exception& ex) {
        cout << ex.what() << '\n';
    }
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑analyse:

1. Afleiden van NewException van std::exception en what() overschrijven.
2. Instantieer een object newex om te gooien.
3. Gooien newex binnen een try-blok.
4. Vangen per referentie naar std::exception en print het bericht via what().

Kernpunten

• Exception handling is essentieel voor robuuste C++‑applicaties die van runtime‑fouten moeten herstellen.
• Gebruik try om code te beschermen, catch om te reageren, en throw om problemen te signaleren.
• Profiteer van de rijke set standardexceptions, en breid std::exception uit wanneer custom fouttypen nodig zijn.
• Houd foutafhandelingslogica gescheiden van business‑logica voor schonere, onderhoudbare code.