C++ Academy · Les

try, catch, throw

Verwerk fouten met exceptions

Les 1 van 413 stappen

try, catch, throw is een gratis C++ Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Fouten signaleren met throw

De instructie throw werpt een uitzondering, verlaat het huidige pad en zoekt een afhandelaar hoger in de aanroepstack.

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::runtime_error("boom");
    } catch (const std::exception& e) {
        std::cout << e.what() << "\n";
    }
}

try en catch

Code die mogelijk een uitzondering werpt, staat in een try-blok; bijbehorende afhandelaars volgen in catch-blokken.

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) throw std::invalid_argument("divide by zero");
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 0) << "\n";
    } catch (const std::invalid_argument& e) {
        std::cout << "error: " << e.what() << "\n";
    }
}

Opvangen via een const-referentie

Vang uitzonderingen altijd op via const&. Opvangen op waarde snijdt afgeleide uitzonderingen af en maakt onnodige kopieën.

Meerdere catch-blokken

Vermeld afhandelaars van specifiek naar algemeen. Het eerste overeenkomende blok wordt uitgevoerd.

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::out_of_range("bad index");
    } catch (const std::out_of_range& e) {
        std::cout << "range: " << e.what() << "\n";
    } catch (const std::exception& e) {
        std::cout << "other: " << e.what() << "\n";
    }
}

Afwikkeling van de stack

Wanneer een uitzondering wordt geworpen, wordt de stack afgewikkeld: elk lokaal object tussen de werpinstructie en de afhandelaar wordt in omgekeerde volgorde vernietigd.

#include <iostream>
#include <stdexcept>

struct Trace {
    ~Trace() { std::cout << "unwound\n"; }
};

void f() {
    Trace t;
    throw std::runtime_error("x");
}

int main() {
    try { f(); } catch (...) { std::cout << "caught\n"; }
}

Algemene afhandelaar

Een blok catch (...) vangt elk type uitzondering op. Gebruik dit spaarzaam, meestal om de uitzondering te loggen en opnieuw te werpen.

Opnieuw werpen

In een afhandelaar werpt een kale throw; de huidige uitzondering opnieuw, waarbij het type behouden blijft, zodat een buitenste afhandelaar die kan verwerken.

#include <iostream>
#include <stdexcept>

void inner() { throw std::runtime_error("deep"); }

void middle() {
    try { inner(); }
    catch (...) { std::cout << "logged\n"; throw; }   // rethrow
}

int main() {
    try { middle(); } catch (const std::exception& e) { std::cout << e.what() << "\n"; }
}

Standaardhiërarchie voor uitzonderingen

De meeste standaarduitzonderingen zijn afgeleid van std::exception, die what() beschikbaar maakt. Door std::exception op te vangen, verwerk je ze allemaal.

Op waarde werpen, via een referentie opvangen

Werp tijdelijke uitzonderingsobjecten op waarde; de runtime kopieert ze naar een veilige opslaglocatie. Vang ze op via een referentie om afsnijden te voorkomen.

Uitzonderingen versus foutcodes

Uitzonderingen scheiden het foutpad van het normale pad en kunnen niet stilzwijgend worden genegeerd — anders dan retourcodes. Reserveer ze voor situaties die echt uitzonderlijk zijn.

Onbehandelde uitzonderingen beëindigen het programma

Als geen enkele afhandelaar overeenkomt, wordt std::terminate aangeroepen en breekt het programma af. Handel uitzonderingen die je verwacht altijd af.

Korte controle

Toets je begrip van het afhandelen van uitzonderingen.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd fouten te signaleren met throw, ze af te handelen met try/catch en hoe de stackafwikkeling lokale objecten onderweg vernietigt. Vang op via const&, rangschik afhandelaars van specifiek naar algemeen en werp opnieuw met een kale throw;.

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “try, catch, throw” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “try, catch, throw”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “try, catch, throw”?

Verwerk fouten met exceptions Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “try, catch, throw”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy