Exemple 1:
Est inclus ici le « iostream », le fichier d'en-tête dans lequel plusieurs fonctions sont déclarées. Nous utilisons ces fonctions qui sont déclarées dans ce fichier d'en-tête dans notre code, nous incluons donc ce fichier d'en-tête. Après cela, nous avons le « std » qui est placé ici car des fonctions comme « cin » et « cout » y sont également définies. Nous n'avons pas besoin de taper « std » avec toutes ces fonctions si nous ajoutons le « namespace std » au début de notre code. Après cela, la fonction « main() » est invoquée ici, également appelée code du pilote du programme C++.
Ensuite, nous utilisons ici le mot-clé « try » dans lequel nous initialisons « my_num1 » avec la valeur « 35 ». Il s'agit ici de la variable de type de données « int ». Maintenant, nous plaçons cette variable à l'intérieur de « if » et plaçons une condition qui dit que « my_num1 » doit être supérieur ou égal à « 98 ». Si la condition donnée est satisfaite, il avance à l'intérieur de « if » et exécute l'instruction écrite ici. Nous utilisons le « cout » et insérons un message à afficher lorsque la condition est satisfaite.
Après cela, nous utilisons le mot-clé « throw » après avoir placé « else ». Dans ce mot-clé « throw », nous passons « my_num1 » comme paramètre. Nous ajoutons la partie « catch » en dessous. Nous insérons « my_num2 » comme paramètre de « catch() » puis utilisons à nouveau le « cout » à l'intérieur de cette partie « catch ». Cette partie s'exécute uniquement lorsqu'une exception se produit dans la partie « try ».
Codage 1 :
#include
en utilisant espace de noms norme ;
int principal ( ) {
essayer {
int mon_num1 = 35 ;
si ( mon_num1 >= 98 ) {
cout << 'L'accès est accordé ici.' ;
} autre {
lancer ( mon_num1 ) ;
}
}
attraper ( int mon_num2 ) {
cout << 'L'accès est refusé ici.' << fin ;
cout << 'Le nombre est: ' << mon_num2 ;
}
retour 0 ;
}
Sortir:
Le nombre que nous avons entré est « 35 », ce qui est inférieur à « 98 ». Ainsi, l'exception se produit là et la partie « catch() » est affichée. L'accès à la partie « try » est refusé.
Exemple 2 :
Nous plaçons ici le fichier d'en-tête « iostream » et le « namespace std ». Après cela, nous créons une fonction « division() » dans laquelle nous plaçons deux paramètres qui sont le « numérateur » et le « dénominateur » du type de données « int ». Nous définissons le type de données de cette fonction « division » sur « double ».
En dessous, nous ajoutons « if() » dans lequel nous ajoutons la condition que le dénominateur soit égal à zéro. Après cela, nous utilisons le mot-clé « throw » et y tapons un message. Ce message est rendu chaque fois qu'une exception se produit dans ce code selon la condition. En dessous, nous utilisons le mot-clé « return » dans lequel nous plaçons « numérateur/dénominateur ». Ainsi, il renvoie le résultat de la division. Maintenant, la fonction « main() » est appelée.
Après cela, « num1 » et « num2 » sont initialisés en tant que variables « int » et leur attribuent respectivement « 89 » et « 0 ». Ensuite, nous initialisons le « résultat » du type de données « double ». Ici, nous utilisons le mot-clé « essayer ». Dans cette partie, nous ajoutons cette variable « result » et attribuons la fonction « division() » à cette variable. Nous passons deux paramètres à cette fonction : « num1 » et « num2 ». En dessous, nous affichons le « résultat » que nous obtenons après avoir appliqué la fonction « division() ». Après cela, nous utilisons également le « catch » et plaçons le « const char* msg » pour afficher le message que nous avons ajouté précédemment.
Code 2 :
#includeen utilisant espace de noms norme ;
double division ( int numérateur, int dénominateur ) {
si ( dénominateur == 0 ) {
lancer 'La division par zéro n'est pas possible ici !' ;
}
retour ( numérateur / dénominateur ) ;
}
int principal ( ) {
int num1 = 89 ;
int numéro2 = 0 ;
double résultat = 0 ;
essayer {
résultat = division ( numéro1, numéro2 ) ;
cout << résultat << fin ;
} attraper ( const carboniser * message ) {
cerr << message << fin ;
}
retour 0 ;
}
Sortir:
Le nombre que nous avons précédemment inséré comme dénominateur est « 0 ». Ainsi, l’exception se produit dans le code et affiche le message donné.
Exemple 3 :
La fonction « multiplication() » est créée ici dans laquelle nous plaçons la « valeur » et le « multiplicateur » comme paramètres du type de données « int ». Ensuite, nous utilisons « si » dans lequel nous ajoutons une condition multiplicatrice égale à zéro. Ensuite, « throw » est placé là où nous ajoutons une instruction. Ensuite, nous avons le « retour » où l’on place les variables « valeur * multiplicateur » que nous avons précédemment déclarées. Donc, il renvoie ici le résultat de la multiplication.
Après cela, nous appelons « main() » où nous déclarons « int value1 » et « int value2 » avec les valeurs « 34 » et « 0 », respectivement. Le « int m_res » est également déclaré puis appelé ici la fonction « multiplication() ». Après avoir exécuté cette fonction, le résultat est maintenant enregistré dans la variable « m_res » puis affiché. Par la suite, nous utilisons la fonction « catch » et insérons le « const char* msg » pour afficher le message que nous avons précédemment ajouté dans la partie « throw ».
Code 3 :
#includeen utilisant espace de noms norme ;
double multiplication ( int valeur , int multiplicateur ) {
si ( multiplicateur == 0 ) {
lancer 'On ne multiplie pas la valeur par zéro !' ;
}
retour ( valeur * multiplicateur ) ;
}
int principal ( ) {
int valeur1 = 3.4 ;
int valeur2 = 0 ;
int m_res ;
essayer {
m_res = multiplication ( valeur1, valeur2 ) ;
cout << m_res << fin ;
} attraper ( const carboniser * message ) {
cerr << message << fin ;
}
retour 0 ;
}
Sortir :
Étant donné que la valeur que nous avons saisie précédemment a « 0 » comme multiplicateur, le code a une exception qui provoque l'affichage de l'avis ici.
Exemple 4 :
Ici, nous construisons la fonction « multiply() » et transmettons « number1 » et « number2 » comme paramètres du type de données « int ». Ensuite, nous utilisons l'opérateur « si » pour y ajouter une condition qui est un multiplicateur inférieur ou égal à zéro. Après cela, l'instruction est ajoutée à l'endroit où « lancer » est censé se trouver. Le résultat de la multiplication est ensuite renvoyé dans la section « return » où l'on insère la variable « number1 * number2 » que nous avons précédemment déclarée.
Par la suite, nous invoquons la fonction « main() » et attribuons respectivement les valeurs « 34 » et « 12 » à « int newNumber1 » et « int newNumber2 ». Ici, la fonction « multiply() » est appelée après la déclaration du « int mResult ». Désormais, le résultat de cette fonction est stocké dans la variable « mResult » et est rendu ci-dessous. Nous utilisons ensuite la fonction « catch » et ajoutons le « const char* msg » pour afficher le message que nous avons écrit dans la section « throw ».
Code 4 :
#includeen utilisant espace de noms norme ;
double multiplier ( int numéro 1 , int numéro 2 ) {
si ( numéro 2 <= 0 ) {
lancer 'Nous ne multiplions pas la valeur par une valeur nulle ou négative !' ;
}
retour ( numéro 1 * numéro 2 ) ;
}
int principal ( ) {
int nouveauNum1 = 3.4 ;
int nouveauNum2 = 12 ;
int mRésultat ;
essayer {
mRésultat = multiplier ( nouveauNum1, nouveauNum2 ) ;
cout << 'Le résultat de la multiplication est ' << mRésultat << fin ;
}
attraper ( const carboniser * message ) {
cerr << message << fin ;
}
retour 0 ;
}
Sortir:
La valeur que l'on ajoute est « 12 » sur laquelle on ajoute la condition. Ainsi, la fonction « multiply() » est exécutée puisque la condition n’est pas vraie. Le résultat de la multiplication s'affiche. La partie « essayer » est exécutée ici.
Conclusion
Le concept « try-catch » et les codes de ce guide sont étudiés en détail. Nous avons exploré en profondeur ce concept « try-catch » et montré comment il fonctionne en programmation C++. Nous avons défini que le terme « throw » crée une exception lorsqu'une erreur est trouvée, ce qui nous permet d'écrire notre code unique. Grâce à l'expression « catch », nous pouvons spécifier un bloc de code à exécuter si une exception apparaît dans la partie « try ».