Exemple 1 : programme pour créer une classe d'exception personnalisée en C++
Cet exemple simple est implémenté pour démontrer la gestion et la détection des exceptions personnalisées en C++.
#include#inclure
en utilisant espace de noms norme ;
classe DémoException : publique exception
{
virtuel const carboniser * quoi ( ) const lancer ( )
{
retour « Exception personnalisée détectée » ;
}
} ;
int principal ( )
{
DémoException dEx ;
essayer
{
lancer dEx ;
}
attraper ( exception & sauf )
{
cout << sauf. quoi ( ) << fin ;
}
retour 0 ;
}
Nous définissons le fichier d'en-tête dans le code incluant le « iostream » et « l'exception ». Le « iostream » est spécifiquement appelé pour le flux d’entrée et de sortie, tandis que la bibliothèque « exception » est appelée pour gérer l’exception. Après cela, nous créons la classe « DemoException » qui est dérivée de la classe « exception » de C++. Ici, nous définissons la fonction virtuelle what() qui est utilisée pour fournir le const char* qui affiche les résultats d'un message d'erreur lié à l'exception.
Ensuite, nous invoquons une fonction main() où nous créons l'objet « dEx » de la classe « DemoException ». Après cela, nous avons une définition de bloc « try » qui lève l'exception si elle est rencontrée. Ici, nous lançons l'objet « dEx ».
Ensuite, nous définissons le bloc « catch » pour intercepter l'exception et la gérer. Nous passons la référence de l'exception de classe en tant que paramètre pour intercepter l'exception qui en dérive. À l’intérieur du bloc « catch », nous appelons la fonction what() sur « except » pour obtenir le message d’exception sur la console.
Après avoir exécuté le programme donné, le message d'exception personnalisé est intercepté et renvoyé sur la console :
Exemple 2 : programme pour créer une exception personnalisée à l'aide de deux classes
Le programme met l'accent sur la gestion de plusieurs exceptions qui peuvent être gérées indépendamment en définissant plusieurs classes.
#include
en utilisant espace de noms norme ;
classe évaluation1 { } ;
classe évaluation2 { } ;
int principal ( ) {
essayer {
lancer évaluation1 ( ) ;
}
attraper ( évaluation1 e ) {
cout << « Exception d'évaluation 1 capturée ! » << fin ;
}
essayer {
lancer évaluation2 ( ) ;
}
attraper ( évaluation2 e ) {
cout << « Exception d'évaluation 2 Attrapée ! » << fin ;
}
retour 0 ;
}
Dans le code donné, nous avons la définition de deux classes, « Évaluation1 » et « Évaluation2 », qui sont désormais vides. Après cela, nous exécutons la fonction main() du programme. Ici, nous définissons le bloc try{} où le mot-clé « throw » est utilisé pour lancer l'instance de la classe « Evaluation1() ». Cela signifie que l'exception « Evaluation1 » est levée si une exception survient dans le programme à l'intérieur de ce bloc « try ». Après cela, nous avons un bloc catch{} où l'exception est interceptée et affiche le message de l'exception.
De même, nous avons une définition d'un autre bloc try{} pour la classe « Evaluation2 ». À l’intérieur de ce bloc try{}, nous lançons l’instance de la classe « Evaluation2 ». Cela lève l'exception de « Evaluation2 » si une erreur se produit ici. Ensuite, nous appelons le bloc catch{} pour afficher le message d'exception à l'aide de la commande « cout » si l'exception est interceptée dans ce bloc.
Les deux exceptions des différents blocs « try-catch » sont lancées dans la console et sont gérées par les deux classes différentes.
Exemple 3 : programme pour créer une exception personnalisée avec un constructeur
Le programme utilise le constructeur pour gérer l'exception. Même si nous ne pouvons pas obtenir les valeurs du constructeur, nous pouvons y parvenir en utilisant le bloc « try-catch ».
#includeen utilisant espace de noms norme ;
classe Test {
int Val ;
publique :
Test ( int n )
{
essayer {
si ( n == 0 )
Val = n ;
afficher ( ) ;
}
attraper ( const carboniser * exp ) {
cout << 'Exception trouvée \n ' ;
cout << exp << fin ;
}
}
vide afficher ( )
{
cout << 'Valeur = ' << Val << fin ;
}
} ;
int principal ( )
{
Test ( 0 ) ;
cout << 'Créer à nouveau l'instance \n ' ;
Test ( 1 ) ;
}
Dans le code donné, nous établissons la classe « Test » où la variable est déclarée comme « val » de type entier. Ensuite, nous avons une définition de la fonction constructeur « Test() » qui est passée avec la variable « n ». Nous définissons ensuite le bloc « try-catch » dans la fonction constructeur « Test() ». Le bloc try est appelé avec l'instruction if(). Si la valeur de « n » est égale à zéro, le bloc « catch » interceptera l'exception et le message d'exception sera renvoyé à l'invite. La valeur de « n » est stockée dans la variable « val » au fur et à mesure que nous l'initialisons.
Après cela, nous appelons la fonction display() pour afficher la valeur stockée dans la variable « val ». Ensuite, nous avons la définition du bloc « catch » où l'exception levée par le bloc « try » est gérée. Enfin, nous invoquons la fonction main(). À l’intérieur duquel, nous appelons le constructeur « Test() ». Le constructeur est déclenché lorsque l'objet de la classe « Test() » est créé et spécifié avec la valeur « 0 » sur lequel l'exception est levée.
Après cela, nous appelons à nouveau la classe « Test() » pour créer une instance qui est passée avec la valeur 1. Ici, le constructeur ne lèvera aucune exception puisque la valeur n'est pas égale à 0. La fonction display() va exécuter et imprimer la valeur de 'val'.
L'exception personnalisée est levée sur la console en appelant le constructeur. De plus, lorsque la condition est satisfaite, le constructeur s’exécute sans aucune exception.
Exemple 4 : programme pour créer une exception personnalisée définie par l'utilisateur
Le programme ici gère et intercepte l'exception définie par l'utilisateur lorsqu'il lui est demandé dans l'invite.
#include#inclure
en utilisant espace de noms norme ;
classe MaDémo : publique exception {
publique :
const carboniser * quoi ( ) const lancer ( )
{
retour 'Exception ! J'ai essayé de diviser par zéro. ! \n ' ;
}
} ;
int principal ( )
{
essayer
{
int n1, n2 ;
cout << 'Entrez les deux entiers : \n ' ;
manger >> n1 >> n2 ;
si ( n2 == 0 )
{
MaDémo n3 ;
lancer n3 ;
}
autre
{
cout << 'n1/n2 = ' << n1 / n2 << fin ;
}
}
attraper ( exception & exc )
{
cout << exc. quoi ( ) ;
}
}
Dans le code donné, nous définissons d'abord la classe « MyDemo() » qui est la classe dépendante de l'exception. Après cela, nous définissons la fonction public what() avec le mot-clé « virtuel ». La fonction what() est appelée pour obtenir la cause de l'exception dans le programme lorsque la fonction throw() lève l'exception. Ensuite, nous avons une fonction main() où les blocs try-catch{} sont définis pour détecter et gérer l'exception. Dans le bloc try{}, nous déclarons deux variables, « n1 » et « n2 », dont les valeurs sont extraites de l'utilisateur à l'aide de la commande « cin ». Lorsque les valeurs de chaque variable « n1 » et « n2 » sont reçues, la condition « si » vérifiera si la variable « n2 » est égale à 0 ou non. Si tel est le cas, une exception est levée ou les résultats de la division sont renvoyés. Enfin, nous avons un bloc catch{} qui prend la référence de la classe « exception » comme paramètre hérité de celle-ci.
La sortie indique lorsque la condition n'est pas remplie et que le programme est exécuté sans exception :
De plus, nous définissons la valeur « 0 » pour la variable « n2 » pour représenter la manière dont l'exception est levée et interceptée dans le programme.
Conclusion
En conclusion, nous avons démontré le concept important du C++ qui constitue une exception. Une exception entrave l’exécution régulière du programme. Pour cela, nous avons utilisé les mots-clés « throw », « try » et « catch » pour gérer l'exception qui se produit dans le programme. Nous avons utilisé ces mots-clés dans les exemples précédents pour gérer l'exception différemment.