Programmation D - Gestion des exceptions

Une exception est un problème qui survient lors de l'exécution d'un programme. Une exception AD est une réponse à une circonstance exceptionnelle qui survient pendant l'exécution d'un programme, telle qu'une tentative de division par zéro.

Les exceptions fournissent un moyen de transférer le contrôle d'une partie d'un programme à une autre. La gestion des exceptions D repose sur trois mots-cléstry, catch, et throw.

• throw- Un programme lève une exception lorsqu'un problème apparaît. Ceci est fait en utilisant unthrow mot-clé.

• catch- Un programme intercepte une exception avec un gestionnaire d'exceptions à l'endroit dans un programme où vous souhaitez gérer le problème. lecatch Le mot clé indique la capture d'une exception.

• try - Un tryblock identifie un bloc de code pour lequel des exceptions particulières sont activées. Il est suivi d'un ou plusieurs blocs catch.

En supposant qu'un bloc lève une exception, une méthode intercepte une exception en utilisant une combinaison des try et catchmots clés. Un bloc try / catch est placé autour du code qui peut générer une exception. Le code dans un bloc try / catch est appelé code protégé, et la syntaxe d'utilisation de try / catch ressemble à ceci:

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

Vous pouvez lister plusieurs catch instructions pour attraper différents types d'exceptions au cas où votre try block soulève plus d'une exception dans différentes situations.

Lancer des exceptions en D

Les exceptions peuvent être lancées n'importe où dans un bloc de code en utilisant throwdéclarations. L'opérande des instructions throw détermine un type pour l'exception et peut être n'importe quelle expression et le type du résultat de l'expression détermine le type d'exception levée.

L'exemple suivant lève une exception lorsque la condition de division par zéro se produit -

Exemple

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

Attraper les exceptions en D

le catch bloc suivant le tryblock intercepte toute exception. Vous pouvez spécifier le type d'exception que vous souhaitez intercepter et cela est déterminé par la déclaration d'exception qui apparaît entre parenthèses après le mot clé catch.

try { 
   // protected code 
} 

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

Le code ci-dessus attrape une exception de ExceptionNametype. Si vous souhaitez spécifier qu'un bloc catch doit gérer tout type d'exception levée dans un bloc try, vous devez mettre une ellipse, ..., entre les parenthèses entourant la déclaration d'exception comme suit -

try { 
   // protected code 
} 

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

L'exemple suivant lève une exception de division par zéro. Il est pris dans le bloc de capture.

import std.stdio; 
import std.string;
  
string division(int a, int b) { 
   string result = "";  
   
   try {  
      if( b == 0 ) {
         throw new Exception("Cannot divide by zero!"); 
      } else { 
         result = format("%s",a/b); 
      } 
   } catch (Exception e) { 
      result = e.msg; 
   }
   
   return result; 
} 
 
void main () { 
   int x = 50; 
   int y = 0;  
   
   writeln(division(x, y));  
   
   y = 10; 
   writeln(division(x, y)); 
}

Lorsque le code ci-dessus est compilé et exécuté, il lit le fichier créé dans la section précédente et produit le résultat suivant -

Cannot divide by zero!
5