Cours complet pour apprendre à programmer en D

Seuls les types qui sont hérités de la classe Throwable peuvent être levés. Throwable n'est quasiment jamais directement utilisée dans les programmes. En pratique, les types qui sont levés sont des types qui héritent d'Exception ou d'Error, qui sont eux-mêmes des types qui héritent de Throwable. Par exemple, toutes les exceptions que Phobos lève sont héritées de Exception ou Error.

Error représente des situations irrécupérables qu'il n'est pas recommandé d'attraper. Pour cette raison, la plupart des exceptions qu'un programme lève sont d'un type hérité de Exception. L'héritage est un concept relatif aux classes. Nous verrons les classes dans un chapitre ultérieur.

Les objets de type Exception sont construits à partir d'une valeur string qui représente un message d'erreur. Vous pouvez éventuellement utiliser la fonction format du module std.string pour créer ce message :

import std.stdio;
import std.random;
import std.string;
 
int[] ValeursDeDesAleatoires(int nombre)
{
  if (nombre < 0) {
    throw new Exception(
        format("Nombre de dés invalide : %s", nombre));
  }
 
  int[] valeurs;
 
  foreach (i; 0 .. nombre) {
    valeurs ~= uniform(1, 7);
  }
 
  return valeurs;
}
 
void main()
{
  writeln(ValeursDeDesAleatoires(-5));
}

Sortie :

object.Exception...: Nombre de dés invalide : -5

Dans la plupart des cas, au lieu de créer un objet Exception explicitement avec new et lever l'exception avec throw, la fonction enforce() est appelée. Par exemple, l'équivalent de la vérification d'erreur précédente est l'appel suivant à enforce() :

enforce(nombre  >= 0, format("Nombre de dés invalide : %s", nombre));

Nous verrons les différences entre enforce() et assert() dans un chapitre ultérieur.

Nous avons vu que l'exécution du programme commence par la fonction main et entre dans les autres fonctions à partir de là. Cette exécution par étapes, entrant progressivement en profondeur dans les fonctions et en ressortant, peut être vue comme les branches d'un arbre.

Par exemple, main() peut appeler une fonction nommée faireOmelette(), qui peut à son tour appeler une autre fonction nommée toutPreparer(), qui peut à son tour appeler une autre fonction nommée preparerOeufs(), etc. En supposant que les flèches indiquent des appels, l'arborescence d'un tel programme peut être représentée comme dans cet arbre d'appels de fonctions :

Le programme suivant montre son arborescence en utilisant différents niveaux d'indentation dans sa sortie. Le programme n'a d'autre utilité que de produire une sortie qui correspond à ce que nous voulons illustrer :

import std.stdio;
 
void indenter(in int niveau)
{
   foreach (i; 0 .. niveau * 2) {
      write(' ');
   }
}
 
void entrant(in char[] nomFonction, in int niveau)
{
   indenter(niveau);
   writeln("▶ Première ligne de ", nomFonction);
}
 
void sortant(in char[] nomFonction, in int niveau)
{
   indenter(niveau);
   writeln("◁ Dernière ligne de ", nomFonctionx);
}
 
void main()
{
   entrant("main", 0);
   faireOmelette();
   mangerOmelette();
   sortant("main", 0);
}
 
void faireOmelette()
{
   entrant("faireOmelette", 1);
   toutPreparer();
   cuisinerOeufs();
   toutNettoyer();
   sortant("faireOmelette", 1);
}
 
void mangerOmelette()
{
   entrant("mangerOmelette", 1);
   sortant("mangerOmelette", 1);
}
 
void toutPreparer()
{
   entrant("toutPreparer", 2);
   preparerOeufs();
   preparerBeurre();
   preparerPoelle();
   sortant("toutPreparer", 2);
}
 
void cuisinerOeufs()
{
   entrant("cuisinerOeufs", 2);
   sortant("cuisinerOeufs", 2);
}
 
void toutNettoyer()
{
   entrant("toutNettoyer", 2);
   sortant("toutNettoyer", 2);
}
 
void preparerOeufs()
{
   entrant("preparerOeufs", 3);
   sortant("preparerOeufs", 3);
}
 
void preparerBeurre()
{
   entrant("preparerBeurre", 3);
   sortant("preparerBeurre", 3);
}
 
void preparerPoelle()
{
   entrant("preparerPoelle", 3);
   sortant("preparerPoelle", 3);
}

Le programme produit la sortie suivante :

▶ Première ligne de main
  ▶ Première ligne de faireOmelette
    ▶ Première ligne de toutPreparer
      ▶ Première ligne de preparerOeufs
      ◁ Dernière ligne de preparerOeufs
      ▶ Première ligne de preparerBeurre
      ◁ Dernière ligne de preparerBeurre
      ▶ Première ligne de preparerPoelle
      ◁ Dernière ligne de preparerPoelle
    ◁ Dernière ligne de toutPreparer
    ▶ Première ligne de cuisinerOeufs
    ◁ Dernière ligne de cuisinerOeufs
    ▶ Première ligne de toutNettoyer
    ◁ Dernière ligne de toutNettoyer
  ◁ Dernière ligne de faireOmelette
  ▶ Première ligne de mangerOmelette
  ◁ Dernière ligne de mangerOmelette
◁ Dernière ligne de main

Les fonctions entrant et sortant sont utilisées pour indiquer les première et dernière lignes des fonctions avec l'aide des caractères ▶ et ◁. Le programme commence par la première ligne de main(), entre dans les autres fonctions et finit par la dernière ligne de main().

Modifions la fonction preparerOeufs() pour prendre le nombre d'œufs en paramètre. Comme certaines valeurs de ce paramètre seraient des erreurs, faisons en sorte que cette fonction lève une exception quand le nombre d'œufs est inférieur à 1 :

void preparerOeufs(int nombre)
{
   entrant("preparerOeufs", 3);
 
   if (nombre < 1) {
      throw new Exception(
           format("Impossible de prendre %s oeufs du réfrigérateur", nombre));
   }
 
   sortant("preparerOeufs", 3);
}

Afin de pouvoir compiler le programme, nous devons modifier d'autres lignes du programme pour les rendre compatibles avec cette modification. Le nombre d'œufs à prendre du réfrigérateur peut être passé de fonction en fonction, en commençant par main(). Les parties du programme qui doivent changer sont les suivantes. La valeur invalide de -8 est voulue, elle est là pour montrer ce qui change dans la sortie du programme par rapport à la sortie précédente, quand une exception est levée :

// ...
 
void main()
{
   entrant("main", 0);
   faireOmelette(-8);
   mangerOmelette();
   sortant("main", 0);
}
 
void faireOmelette(int nombreOeufs)
{
   entrant("faireOmelette", 1);
   toutPreparer(nombreOeufs);
   cuisinerOeufs();
   toutNettoyer();
   sortant("faireOmelette", 1);
}
 
// ...
 
void toutPreparer(int nombreOeufs)
{
   entrant("toutPreparer", 2);
   preparerOeufs(nombreOeufs);
   preparerBeurre();
   preparerPoelle();
   sortant("toutPreparer", 2);
}
 
// ...

Maintenant, quand on démarre le programme, on voit qu'il manque les lignes qui étaient affichées après le point où l'exception est levée :

▶ Première ligne de main
  ▶ Première ligne de faireOmelette
    ▶ Première ligne de toutPreparer
      ▶ Première ligne de preparerOeufs
object.Exception: Impossible de prendre -8 oeufs du réfrigérateur

Quand l'exception est levée, l'exécution du programme sort des fonctions preparerOeufs(), toutPreparer(), faireOmelette() et main() dans cet ordre, du niveau le plus profond au niveau le moins profond. Aucune étape additionnelle n'est exécutée quand le programme sort de ces fonctions.

Un arrêt si brutal est justifié par le fait qu'on devrait considérer qu'un échec dans une fonction de plus bas niveau implique que les fonctions de plus hauts niveaux, nécessitant un succès de celle-ci, ont également échoué.

L'objet exception qui est levé depuis un niveau de fonction plus bas est transféré aux fonctions de niveaux supérieurs, niveau par niveau, pour finalement entraîner la sortie du programme de la fonction main(). Le chemin que l'exception prend peut être vu comme le chemin rouge dans l'arbre suivant :

Le but du mécanisme des exceptions est précisément d'avoir ce comportement : sortir de tous les appels de fonctions directement. Parfois, attraper l'exception levée pour trouver une manière de continuer l'exécution du programme fait sens. Nous allons bientôt introduire le mot-clé catch.

Utilisez throw dans les situations où il n'est pas possible de continuer. Par exemple, une fonction qui lit un nombre d'étudiants depuis un fichier peut lever une exception si l'information n'est pas disponible ou si elle est incorrecte.

D'un autre côté, si le problème est causé par une action quelconque de l'utilisateur telle que la saisie d'une valeur invalide, il peut être plus judicieux de valider cette donnée au lieu de lever une exception. Afficher un message d'erreur et demander à l'utilisateur de saisir une nouvelle fois la donnée est plus approprié dans ce genre de cas.

Le type Exception, que nous avons utilisé jusqu'à maintenant dans les exemples, est un type générique d'exception. Ce type indique simplement qu'une erreur s'est produite dans le programme. Il contient aussi un message qui peut expliquer l'erreur plus en détail, mais il ne contient pas d'information sur le type de l'erreur.

ConvException et ErrnoException, que nous avons rencontrés plus tôt dans le chapitre, sont des types d'exceptions plus spécifiques : le premier concerne une erreur de conversion et le second une erreur système. Comme beaucoup d'autres types d'exceptions dans Phobos et comme leurs noms respectifs le suggèrent, ConvException et ErrnoException héritent tous deux de la classe Exception.

Exception et sa sœur Error sont eux-mêmes hérités de Throwable, le type d'exception le plus général.

Même si c'est possible, il n'est pas recommandé d'attraper des objets de type Error ou de types qui en héritent. Comme ils sont plus généraux que les types Error, il n'est pas non plus recommandé d'intercepter des objets de type Throwable. Les seuls objets qui devraient normalement être attrapés sont ceux qui font partie de la hiérarchie Exception.

Il est possible d'attraper les objets d'un type particulier. Par exemple, il est possible d'attraper de manière spécifique un objet ErrnoException pour gérer une erreur système.

Les exceptions sont attrapées seulement si elles correspondent au type qui est spécifié dans un bloc catch. Par exemple, un bloc catch qui essaie d'attraper une exception SpecialExceptionType n'attrapera pas un ErrnoException.

Le type de l'objet exception qui est levée pendant l'exécution d'un bloc try est comparé aux types qui sont spécifiés par les blocs catch, dans l'ordre dans lequel les blocs catch sont écrits. Si le type de l'objet correspond au type d'un bloc catch, alors l'exception est considérée comme attrapée par ce bloc catch et le code qui est à l'intérieur de ce bloc est exécuté. Une fois qu'une correspondance a été trouvée, les blocs catch restant sont ignorés.

Du fait que les blocs catch sont testés dans l'ordre, les blocs catch doivent être ordonnées de l'exception du type le plus spécifique au plus général. De même, si nécessaire, le type Exception doit être indiqué au dernier bloc catch.

Par exemple, une instruction try-catch qui essaie d'attraper plusieurs types spécifiques d'exceptions à propos d'une liste d'étudiants peut ordonner les blocs catch du plus spécifique au plus général comme dans le code qui suit :

try {
    // des opérations sur les enregistrements d'étudiants
    // qui peuvent lever une exception
 
} catch (ChiffreIdEtudiantException exc) {
 
    // Une exception dédiée aux erreurs sur
    // les chiffres des identifiants des étudiants
 
} catch (IdEtudiantException exc) {
 
    // Une exception plus générale sur les identifiants des étudiants
    // mais pas nécessairement sur leurs chiffres
 
} catch (EnregistrementEtudiantException exc) {
 
    // Une exception plus générale sur les enregistrements des étudiants
 
} catch (Exception exc) {
 
    // L'exception la plus générale qui peut ne pas être en
    // rapport avec les enregistrements des étudiants
 
}

finally est un bloc optionnel de l'instruction try-catch. Il contient des expressions qui doivent être exécutées, qu'une exception ait été levée ou pas.

Pour voir comment finally fonctionne, examinons un programme qui lève une exception 50 % du temps :

import std.stdio;
import std.random;
 
void leverExceptionLaMoitieDuTemps()
{
   if (uniform(0, 2) == 1) {
      throw new Exception("le message d'erreur");
   }
}
 
void foo()
{
   writeln("La première ligne de foo()");
 
   try {
      writeln("La première ligne du bloc try");
      leverExceptionLaMoitieDuTemps();
      writeln("La dernière ligne du bloc try");
 
 // ... il peut y avoir un ou des blocs catch ici ...
 
   } finally {
      writeln("Le corps du bloc finally");
   }
 
   writeln("La dernière ligne de foo()");
}
 
void main()
{
    foo();
}

La sortie du programme est la suivante quand la fonction ne lève pas une exception :

La première ligne de foo()
La première ligne du bloc try
La dernière ligne du bloc try
Le corps du bloc finally
La dernière ligne de foo()

La sortie du programme est la suivante quand la fonction lève une exception :

La première ligne de foo()
La première ligne du bloc try
Le corps du bloc finally
object.Exception@essai.d: le message d'erreur

Comme on peut le constater, quand une exception est levée, bien que « La dernière ligne du bloc try » et « La dernière ligne de foo() » ne soient pas affichées, le contenu du bloc finally est quant à lui toujours exécuté.

L'instruction try-catch est utile pour attraper des exceptions pour faire quelque chose de spécial avec.

Pour cette raison, l'instruction try-catch ne devrait être utilisée que quand il y a quelque chose de spécial à faire. Sinon, n'attrapez pas d'exceptions et laissez-les aux fonctions des niveaux supérieurs qui pourraient vouloir les attraper.

Nous avons vu comment le mécanisme des exceptions peut être utile. Il permet aux opérations de bas niveau comme aux opérations de haut niveau d'être interrompues directement, au lieu de laisser le programme continuer avec des données incorrectes ou manquantes ou agir de n'importe quelle autre mauvaise manière.

Ceci ne veut pas dire que chaque état erroné justifie une levée d'exception. On peut parfois faire mieux selon les types d'erreurs.

42-3-1-1. Erreurs de l'utilisateur▲

import std.stdio;
import std.string;
 
void utiliserLeFichier(string nomFichier)
{
 auto fichier = File(nomFichier, "r");
 // ...
}
 
string lireChaîne(in char[] invite)
{
 write(invite, ": ");
 return chomp(readln());
}
 
void main()
{
   bool fichierUtilisé = false;
 
   while (!fichierUtilisé) {
      try {
         utiliserLeFichier(
             lireChaîne("Entrez un nom de fichier"));
 
         /*
          * Si nous arrivons ici, c'est que la fonction
          * utiliserLeFichier() s'est déroulée avec succès,
          * ce qui indique que le nom de fichier était
          * valide.
          *
          * Nous pouvons maintenant positionner le drapeau
          * de boucle afin de quitter la boucle while.
          */
         fichierUtilisé = true;
         writeln("Le fichier a bien été utilisé");
 
      } catch (std.exception.ErrnoException exc) {
         stderr.writeln("Ce fichier n'a pas pu être ouvert");
      }
   }
}

void gérerSelectionMenu(int selection)
{
 assert(selection >= 0);
 // ...
}
 
void main()
{
 gérerSelectionMenu(-1);
}

core.exception.AssertError@essai.d(3): Assertion failure

42-3-1-2. Résumé▲