Afhandeling van C++-uitzonderingen

Een uitzondering is een probleem dat zich voordoet tijdens de uitvoering van een programma. Een C++-uitzondering is een reactie op een uitzonderlijke omstandigheid die zich voordoet terwijl een programma draait, zoals een poging om te delen door nul.

Uitzonderingen bieden een manier om de controle over te dragen van het ene deel van een programma naar het andere. De afhandeling van C++-uitzonderingen is gebaseerd op drie sleutelwoorden:try, catch, en gooi .

• gooi − Een programma genereert een uitzondering wanneer zich een probleem voordoet. Dit doe je met een worp zoekwoord.

• vang − Een programma vangt een uitzondering op met een uitzonderingshandler op de plaats in een programma waar u het probleem wilt oplossen. De vangst trefwoord geeft het opvangen van een uitzondering aan.

• probeer − Een probeer blok identificeert een codeblok waarvoor bepaalde uitzonderingen worden geactiveerd. Het wordt gevolgd door een of meer vangblokken.

Ervan uitgaande dat een blok een uitzondering genereert, vangt een methode een uitzondering op met een combinatie van de try en vang trefwoorden. Om de code wordt een try/catch-blok geplaatst dat een uitzondering zou kunnen genereren. Code binnen een try/catch-blok wordt beschermde code genoemd, en de syntaxis voor het gebruik van try/catch is als volgt −

try {
   // protected code
} catch( ExceptionName e1 ) {
   // catch block
} catch( ExceptionName e2 ) {
   // catch block
} catch( ExceptionName eN ) {
   // catch block
}

U kunt meerdere vangsten opsommen instructies om verschillende soorten uitzonderingen op te vangen voor het geval uw probeert blok genereert meer dan één uitzondering in verschillende situaties.

Uitzonderingen gooien

Uitzonderingen kunnen overal binnen een codeblok worden gegooid met throw uitspraak. De operand van de throw-instructie bepaalt een type voor de uitzondering en kan elke expressie zijn en het type van het resultaat van de expressie bepaalt het type exception dat wordt gegenereerd.

Hieronder volgt een voorbeeld van het genereren van een uitzondering wanneer de voorwaarde wordt gedeeld door nul −

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

Uitzonderingen opvangen

De vangst blokkeren na de probeer blok vangt elke uitzondering. U kunt specificeren welk type uitzondering u wilt opvangen en dit wordt bepaald door de uitzonderingsverklaring die tussen haakjes wordt weergegeven na het trefwoord catch.

try {
   // protected code
} catch( ExceptionName e ) {
  // code to handle ExceptionName exception
}

Bovenstaande code ondervangt een uitzondering van ExceptionName type. Als u wilt specificeren dat een catch-blok elk type uitzondering moet verwerken dat in een try-blok wordt gegooid, moet u een ellips, ..., tussen de haakjes plaatsen die de uitzonderingsdeclaratie als volgt omsluiten −

try {
   // protected code
} catch(...) {
  // code to handle any exception
}

Het volgende is een voorbeeld, waarbij een uitzondering door deling door nul wordt gegenereerd en we vangen het op 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 uitzondering maken van het type const char* , dus terwijl we deze uitzondering opvangen, moeten we const char * gebruiken in het catch-blok. Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

Division by zero condition!

C++ standaard uitzonderingen

C++ biedt een lijst met standaarduitzonderingen gedefinieerd in die we kunnen gebruiken in onze programma's. Deze zijn gerangschikt in een hiërarchie van ouder-kindklassen die hieronder wordt weergegeven −

Hier is de kleine beschrijving van elke uitzondering die in de bovenstaande hiërarchie wordt genoemd −

Nieuwe uitzonderingen definiëren

U kunt uw eigen uitzonderingen definiëren door uitzondering . over te nemen en te negeren klasse functionaliteit. Hieronder volgt het voorbeeld, dat laat zien hoe u std::exception class kunt gebruiken om uw eigen exception op een 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) {
      //Other errors
   }
}

Dit zou het volgende resultaat opleveren −

MyException caught
C++ Exception

Hier, wat() is een openbare methode die wordt geleverd door een uitzonderingsklasse en is overschreven door alle onderliggende uitzonderingsklassen. Dit retourneert de oorzaak van een uitzondering.