C++ Exception Handling Beheersen: Een Uitgebreide Gids

Een exception (uitzondering) is een probleem dat ontstaat tijdens de uitvoering van een programma. Een C++ exception is een reactie op een uitzonderlijke omstandigheid die ontstaat tijdens een programma draait, zoals een poging om door nul te delen.

Exceptions bieden een manier om controle over te dragen van een deel van een programma naar een ander. C++ exception handling is gebaseerd op drie trefwoorden: try, catch, en throw.

• throw – Een programma gooit een exception wanneer een probleem opduikt. Dit wordt gedaan met het throw trefwoord.

• catch – Een programma vangt een exception op met een exception handler op de plek in een programma waar u het probleem wilt afhandelen. Het catch trefwoord duidt het vangen van een exception aan.

• try – Een try blok identificeert een blok code waarvoor bepaalde exceptions geactiveerd zullen worden. Het wordt gevolgd door één of meer catch blokken.

Aannemend dat een blok een exception zal opwerpen, vangt een methode een exception op met een combinatie van de try en catch trefwoorden. Een try/catch blok wordt geplaatst rond de code die een exception kan genereren. Code binnen een try/catch blok wordt aangeduid als beschermde code, en de syntax voor het gebruik van try/catch is als volgt:

 try {
  // beschermde code
} catch( ExceptionName e1 ) {
  // catch blok
} catch( ExceptionName e2 ) {
  // catch blok
} catch( ExceptionName eN ) {
  // catch blok
} 

U kunt meerdere catch statements opsommen om verschillende typen exceptions te vangen voor het geval uw try blok meer dan één exception in verschillende situaties opwerpt.

Exceptions Gooien (Throwing Exceptions)

Exceptions kunnen overal binnen een codeblok gegooid worden met een throw statement. De operand van de throw statement bepaalt een type voor de exception en kan elke expressie zijn en het type van het resultaat van de expressie bepaalt het type exception dat gegooid wordt.

Hier volgt een voorbeeld van het gooien van een exception wanneer een deling door nul conditie optreedt:

 double division(int a, int b) {
  if( b == 0 ) {
    throw "Division by zero condition!";
  }
  return (a/b);
} 

Exceptions Vangen (Catching Exceptions)

Het catch blok na het try blok vangt elke exception op. U kunt specificeren welk type exception u wilt vangen en dit wordt bepaald door de exception declaratie die verschijnt tussen haakjes na het trefwoord catch.

 try {
  // beschermde code
} catch( ExceptionName e ) {
  // code om ExceptionName exception af te handelen
} 

Bovenstaande code vangt een exception van ExceptionName type op. Als u wilt specificeren dat een catch blok elk type exception moet afhandelen dat in een try blok gegooid wordt, moet u een ellipsis, ..., tussen de haakjes die de exception declaratie omsluiten plaatsen als volgt:

 try {
  // beschermde code
} catch(...) {
  // code om elke exception af te handelen
} 

Het volgende is een voorbeeld, dat een deling door nul exception gooit en we vangen het in het catch blok.

 #include <iostream>
using namespace std;
double division(int a, int b) {
  if( b == 0 ) {
    throw "Division by zero condition!";
  }
  return (a/b);
}
int main () {
  int x = 50;
  int y = 0;
  double z = 0;
  try {
    z = division(x, y);
    cout << z << endl;
  } catch (const char* msg) {
    cerr << msg << endl;
  }
  return 0;
} 

Omdat we een exception van type const char* opwerpen, moeten we const char* in het catch blok gebruiken tijdens het vangen van deze exception. Als we de bovenstaande code compileren en draaien, zou dit het volgende resultaat produceren:

 Division by zero condition! 

C++ Standaard Exceptions

C++ biedt een lijst van standaard exceptions gedefinieerd in <exception> die we in onze programma's kunnen gebruiken. Deze zijn gerangschikt in een parent-child klasse hiërarchie zoals hieronder getoond:

Hier is de kleine beschrijving van elke exception vermeld in de bovenstaande hiërarchie:

Nieuwe Exceptions Definiëren (Define New Exceptions)

U kunt uw eigen exceptions definiëren door exception klasse te overerven en te overriden. Hier volgt het voorbeeld, dat laat zien hoe u std::exception klasse kunt gebruiken om uw eigen exception op standaard manier te implementeren:

 #include <iostream>
#include <exception>
using namespace std;
struct MyException : public exception {
  const char * what () const throw () {
    return "C++ Exception";
  }
};
int main() {
  try {
    throw MyException();
  } catch(MyException& e) {
    std::cout << "MyException caught" << std::endl;
    std::cout << e.what() << std::endl;
  } catch(std::exception& e) {
    // Andere fouten
  }
} 

Dit zou het volgende resultaat produceren:

 MyException caught
 C++ Exception 

Hier is what() een publieke methode geleverd door exception klasse en het is geoverride door alle child exception klassen. Dit retourneert de oorzaak van een exception.