Si lors de l’exécution d’une fonction, un événement pouvant conduire à l’interruption de l’exécution se produit, cet événement est une exception.

Selon cette définition :

• Tout dysfonctionnement est constitutif d’une exception.
• Toute exception n’entraîne pas systématiquement un dysfonctionnement.

En effet, quand une exception se produit, il est possible de procéder à des opérations palliatives qui permettront au programme de continuer de fonctionner.

En fait, l'exception doit être vu comme un élément initiateur qui s'il n'est pas gérer conduira à l'échec de la fonction ou du programme. Cependant, une exception peut-être capturée (ie. détectée et traitée) et dans ce cas, la fonction ou le programme pourront éventuellement continuer à effectuer leur tâche.

Avant l'apparition du concept des exceptions, la conception d'un programme “sûr” et “robuste” imposait que l'on vérifier avant d'exécuter une opération si les paramètres étaient corrects et après que l'opération se soit réalisée, si l'opération n'a pas connu d'erreur. Ainsi pour l'ouverture d'un fichier en lecture en C, nous effectuions les opérations suivantes :

  if(filename == NULL){
    perror ( "Empty file name" );
    exit ( EXIT_FAILURE );
  }
 
  FILE *fp = fopen (filename, mode );
 
  if ( fp == NULL ) {
    perror ( "Unable to open file" );
    exit ( EXIT_FAILURE );
  }

Nous voyons que nous mélangeons le code relatif aux opérations et le code relatif à la vérification des opérations. D'ailleurs au passage, il y a plus de code pour les vérifications que réaliser l'opération. En plus, est-ce que c'est bien exit qu'il fallait appeller si un échec se produit ? Cela dépend typiquement du contexte d'utilisation. Peut-être que cela est sans conséquence et que le programme peut continuer en essayant de lire un fichier de sauvegarde.

L'idée des exceptions, c'est de séparer le traitement des fautes de la survenance de la faute. Reprenons l'exemple précédent avec l'idée de faire une fonction générique de lecture d'un fichier texte :

readFile(file_name)
    si file_name est NULL
        => signale que le nom du fichier est NULL et arrête la fonction.
    appelle fopen pour ouvrir le fichier.
    si fopen n'a pas pu ouvrir le fichier
        => récupère le code d'erreur 
           signale l'erreur qui s'est produite.
    lit le contenu du fichier
    si une erreur se produit durant la lecture
        => arrête la lecture
           signale l'erreur qui s'est produite
    ferme le fichier
    si une erreur se produit durant la fermeture
           signale l'erreur qui s'est produite
    retourne le contenu du fichier.

Dans l'écriture de la fonction, nous nous concentrons sur deux aspects :

• la réalisation de la fonction,
• la détection des erreurs.

Quand une erreur se produit, nous indiquons seulement l'erreur qui s'est produite et nous arrêtons d'exécuter la fonction. Nous ne faisons pas d'autres traitements. C'est au code qui a appellé ce code de lecture qui devra s'en charger.

Faire ainsi permet de :

1. simplifier l'écriture de code, en rendant le code beaucoup plus lisible
2. séparer la partie exécution et traitement des erreurs.

Cependant, il faut mettre en place un mécanisme qui :

• permette de notifier la survenance d'une erreur
• arrête l'exécution d'une fonction ou d'un code.

C'est ce mécanisme que l'on appelle support des exceptions.

C++ ajoute le mot clé throw pour déclencher une exception. En fait à une exception est associée une valeur ou un objet quelconque.

  int divrem(int numerator, int denominator, int& remainder)
  {
      if(denominator == 0)
        throw 0;
      remainder = numerator % denominator;
      return numerator / denominator;
  }

Dans le code précédent, si le dénominateur est égal à 0, une exception sera levée et à cette exception sera associée un entier ayant la valeur 0.

Quand l'exception est levée, l'exécution du programme s'arrête tant que l'exécution n'est pas capturée. Si l'exécution n'est pas capturée, le programme plante, ie. il s'arrête et indique le type de l'objet associé à l'exécution.

Il est donc nécessaire d'introduire un mécanisme permettrant de capturer les exceptions :

  try
  {
      divrem(2, 0);
  }
  catch(...)
  {
      std::cout << "Error: Try to divide by zero" << std::endl;
  }

Le bloc try{}catch(…){} fonctionne comme suit :

• toute exception se produisant entre les deux accolades du bloc try{} est capturée par le bloc catch(…) et le code entre les deux accolades du bloc catch(…){} est exécuté.

Dans le cas précédent, la sortie du programme serait l'affichage du message :

Error: Try to divide by zero