Exception handling

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken

Exception handling is een constructie of een mechanisme die een programmeertaal biedt om op een abnormale of uitzonderlijke gebeurtenis (excepties) te kunnen reageren en af te handelen tijdens het uitvoeren (run time) van software. De normale afloop van het programma wordt gewijzigd in tijdelijke onderbreking of een totale afbreking. Als er geen aandacht in het programma aan de mogelijke exceptie is besteed meldt het systeem onelegant een "unexpected exception" meestal gevolgd door voor de gebruiker onbegrijpelijke rapportage.

Voorbeelden van excepties[bewerken]

Excepties kunnen optreden bij:

  • lees- of schrijffouten met input/output periferie;
  • bij schrijven naar of lezen uit geheugen, dat niet voor het programma is bestemd;
  • bij delen door nul;
  • een of andere overflow;
  • door de softwareontwikkelaar bedachte excepties;
  • en nog vele andere.

Veel programmeertalen geven de programmeur de mogelijkheid om eigen excepties te definiëren.
De meest voorbeeldige exceptie is de rekenkundige deling door het getal 0. Het is bijna ondoenlijk om in het programma bij elke deling de deler te controleren op de waarde nul. En de aantal malen dat de programmeur dit zo moeten doen staat in geen verhouding met het geringe aantal dat dit feitelijk gebeurd. Daarom biedt het exceptie mechanisme een mogelijkheid om deze fout meer centraler af te handelden, meestal zodanig dat de verwerking minimaal wordt gestoord.

Doel van de excepties[bewerken]

Excepties zijn bedoeld om de programmeur een praktisch mechanisme te geven om fout- en uitzonderingssituaties af te vangen die in software kunnen voorkomen. Zo kunnen op een hoger niveau fouten worden afgevangen die op een lager niveau worden veroorzaakt, zonder dat in enige tussenliggend niveau hier speciale code voor hoeft te worden toegevoegd.

Werking[bewerken]

De sleutel van de exceptieconstructie in een programmeertaal is het groeperen van statements in blokken, zoals ingevoerd is bij het gestructureerd programmeren. Een code-blok wordt aangemerkt dat het een exceptie kan verwerken en bovendien wordt het uitgebreid met een gedeelte die de exceptie verwerkt, de zogenaamde exception-handler. Blokken kunnen genest zijn en daarom hoeft het het (binnenste) blok waar de exceptie ontstaat niet een handler te hebben. Zolang de exceptie niet behandeld is zoekt het mechanisme van binnen naar buiten naar het blok wat het vorige blok heeft aangeroepen op een toepasselijke handler. Ondertussen is de verdere uitvoering in de blokken waar geen passende handler is gevonden, geforceerd afgebroken en zijn de variabelen verloren. Uiteindelijk vind het mechanisme een blok met een handler en wordt de code in het handler gedeelte uitgevoerd. Het vinden van een handler is gegarandeerd omdat het systeem wat het programma start als het ware het buitenste omhullend blok is met algemene handlers. Deze "unexpected exception" handlers zijn echter niet voor een eindgebruiker bedoeld en breken het programma in zijn geheel af.

Exceptie-robuustheid[bewerken]

Een stuk software wordt Exceptieveilig (exception-safe) genoemd als run time fouten binnen de code niet leiden tot geheugenlekken, corrupte data of onjuiste uitvoer. Er zijn een aantal niveaus van exceptieveiligheid:

  1. Fout-transparant (best): alle stappen van het programma slagen altijd en voldoen aan alle eisen, zelfs in aanwezigheid van uitzonderlijke situaties;
  2. Vastleg- of terugdraaitechniek: enkele stappen van het programma kunnen ontbreken, maar de ontbrekende stappen hebben geen neveneffecten;
  3. Basis exceptieveiligheid: de ontbrekende stappen kunnen bijwerkingen veroorzaken, maar de juiste toestand wordt bewaard (dus alle opgeslagen informatie is correct);
  4. Minimale exceptieveiligheid: gedeeltelijke uitvoering van het programma kan onjuiste data opleveren, maar zal geen crash veroorzaken;
  5. Geen exceptieveiligheid (slechtst): het programma het heeft geen passende afhandeling en crashed met gebruikersonvriendelijke systeemmeldingen.

Normaal is een basis exceptieveiligheid vereist. Fout-transparantie is moeilijk, zo niet onmogelijk te implementeren

Exceptie-ondersteuning in programmeertalen[bewerken]

Vele programmeertalen, die blokgestructureerd zijn, zoals onder meer Ada, C#, C++, Common Lisp, D, Delphi, Eiffel, Java, Objective-C, PHP, PL/SQL, Python, Scala, hebben ondersteuning voor excepties en exception handling. In deze talen wordt bij het optreden van een exceptie de stack van functieaanroepen afgewikkeld totdat een exception handler voor deze exceptie is gevonden.

ActionScript 3[bewerken]

 try
 {
   // Code die een exceptie kan opleveren
 }
 catch(e:Error)
 {
   //Verwerk een systeemexceptie.
 }
 finally
 {
   // (optioneel) code die altijd uitgevoerd wordt
 }

C#[bewerken]

 public static void Main()
 {
    try {
       // Code die een exceptie kan opleveren
    } catch(System.Exception) {
       //Verwerk een systeemexceptie.
    } catch {
       //Verwerk een andere exceptie.
    } finally {
       // (optioneel) code die altijd uitgevoerd wordt
    }
 }

C++[bewerken]

 #include <exception>
 
 int main() {
    try {
       // Code die een exceptie kan opleveren
    }
    catch (const std::exception& e) {
       //Verwerk een standaardexceptie.
    }
    catch (...) {
         // onbekende exceptie
    }
 }

Delphi[bewerken]

 try
   try
       // Code die een exceptie kan opleveren
   finally
     // Code die uitgevoerd zal worden ongeacht of er een exceptie opgetreden is
   end;
 except
   on E:Exception do
     //Verwerk een Exceptie
 end;

Java[bewerken]

 try {
       // Code die een exceptie kan opleveren
 } catch (VoorbeeldExceptie ee) {
       //Verwerk een voorbeeldexceptie
 } catch (Exception b) {
    // Verwerk de overige excepties
 } finally {
       // (optioneel) code die altijd uitgevoerd wordt
 }

PHP[bewerken]

 try {
       // Code die een exceptie kan opleveren
 } catch (ExceptieClass $exceptie) {
       //Verwerk een ExceptieClass exceptie
 }

Python[bewerken]

  try:
    //Code die een exceptie op kan leveren
  except exceptie1:
    //Code die uitgevoerd moet worden wanneer exceptie1 optreedt
 //optioneel:
  except exceptie2: 
    //Code die uitgevoerd moet worden wanneer exceptie2 optreedt
  else: 
    //Code die uitgevoerd moet worden wanneer geen van de vorige excepties zijn opgetreden
  finally: 
    //Code die altijd uitgevoerd moet worden ongeacht of er een exceptie is opgetreden

PowerBuilder[bewerken]

 TRY
    // Code die een exceptie kan opleveren
 CATCH (n_exc_myexception le_myexception) {
    //Verwerk de exceptie van type n_exc_myexception
 CATCH (exception le_exception) {
    //Verwerk de overige excepties
 FINALLY
   // (optioneel) code die altijd uitgevoerd wordt vóór de code na het END TRY statement
 END TRY