En C++, lorsqu'il faut lancer une exception, on doit créer un objet dont la classe caractérise cette exception, et utiliser le mot clé codice_1. Sa syntaxe est la suivante :
throw objet;
où objet est l'objet correspondant à l'exception. Cet objet peut être de n'importe quel type, et pourra ainsi caractériser pleinement l'exception.
L'exception doit alors être traitée par le gestionnaire d'exception correspondant. On ne peut attraper que les exceptions qui sont apparues dans une zone de code limitée (cette zone est dite protégée contre les erreurs d'exécution), pas sur tout un programme. On doit donc placer le code susceptible de lancer une exception d'un bloc d'instructions particulier. Ce bloc est introduit avec le mot clé codice_2 :
try {
 // Code susceptible de générer des exceptions...
Les gestionnaires d'exceptions doivent suivre le bloc try. Ils sont introduits avec le mot clé catch :
catch (classe [&][temp]) {
 // Traitement de l'exception associée à la classe
Notez que les objets de classe de stockage automatique définis dans le bloc codice_2 sont automatiquement détruits lorsqu'une exception fait sortir le contrôle du programme de leur portée. C'est également le cas de l'objet construit pour lancer l'exception. Le compilateur effectue donc une copie de cet objet pour le transférer au premier bloc catch capable de le recevoir. Cela implique qu'il y ait un constructeur de copie pour les classes d'exceptions non triviales.
De même, les blocs catch peuvent recevoir leurs paramètres par valeur ou par référence, comme le montre la syntaxe indiquée ci-dessus. En général, il est préférable d'utiliser une référence, afin d'éviter une nouvelle copie de l'objet de l'exception pour le bloc catch. Toutefois, on prendra garde au fait que dans ce cas, les modifications effectuées sur le paramètre seront effectuées dans la copie de travail du compilateur et seront donc également visibles dans les blocs catch des fonctions appelantes ou de portée supérieure, si l'exception est relancée après traitement.
Il peut y avoir plusieurs gestionnaires d'exceptions. Chacun traitera les exceptions qui ont été générées dans le bloc try et dont l'objet est de la classe indiquée par son paramètre. Il n'est pas nécessaire de donner un nom à l'objet (temp) dans l'expression catch. Cependant, cela permet de le récupérer, ce qui peut être nécessaire si l'on doit récupérer des informations sur la nature de l'erreur.
Enfin, il est possible de définir un gestionnaire d'exception universel, qui récupérera toutes les exceptions possibles, quels que soient leurs types. Ce gestionnaire d'exception doit prendre comme paramètre trois points de suspension entre parenthèses dans sa clause catch. Bien entendu, dans ce cas, il est impossible de spécifier une variable qui contient l'exception, puisque son type est indéfini.
Exemple 9-1. Utilisation des exceptions.
using namespace std;
class erreur // Première exception possible, associée
 // à l'objet erreur.
public:
 int cause; // Entier spécifiant la cause de l'exception.
 // Le constructeur. Il appelle le constructeur de cause.
 // Le constructeur de copie. Il est utilisé par le mécanisme
 // des exceptions :
class other {}; // Objet correspondant à toutes
 // les autres exceptions.
int main(void)
 int i; // Type de l'exception à générer.
 cout « "Tapez 0 pour générer une exception Erreur, "
 "1 pour une Entière :";
 cin » i; // On va générer une des trois exceptions
 // possibles.
 cout « endl;
 try // Bloc où les exceptions sont prises en charge.
 switch (i) // Selon le type d'exception désirée,
 case 0:
 erreur a(0);
 throw (a); // on lance l'objet correspondant
 // (ici, de classe erreur).
 // Cela interrompt le code. break est
 // donc inutile ici.
 case 1:
 int a=1;
 throw (a); // Exception de type entier.
 default: // Si l'utilisateur n'a pas tapé 0 ou 1,
 other c; // on crée l'objet c (type d'exception
 throw (c); // other) et on le lance.
 } // fin du bloc try. Les blocs catch suivent :
 catch (erreur &tmp) // Traitement de l'exception erreur ...
 { // (avec récupération de la cause).
 cout « "Erreur erreur ! (cause " « tmp.cause « ")" « endl;
 catch (int tmp) // Traitement de l'exception int...
 cout « "Erreur int ! (cause " « tmp « ")" « endl;
 catch (...) // Traitement de toutes les autres
 { // exceptions (...).
 // On ne peut pas récupérer l'objet ici.
 cout « "Exception inattendue !" « endl;
 return 0;
Selon ce qu'entre l'utilisateur, une exception du type erreur, codice_4 ou codice_5 est générée.

Programmation C-C++/Les exceptions/Remontée des exceptions

Les fonctions intéressées par les exceptions doivent les capter avec le mot clé catch comme on l'a vu ci-dessus. Elles peuvent alors effectuer tous les traitements d'erreurs que le C++ ne fera pas automatiquement. Ces traitements comprennent généralement le rétablissement de l'état des données manipulées par la fonction (dont, pour les fonctions membres d'une classe, les données membres de l'objet courant), ainsi que la libération des ressources non encapsulées dans des objets de classe de stockage automatique (par exemple, les fichiers ouverts, les connexions réseau, etc.).
Une fois ce travail effectué, elles peuvent, si elles le désirent, relancer l'exception, afin de permettre un traitement complémentaire par leur fonction appelante. Le parcours de l'exception s'arrêtera donc dès que l'erreur aura été complètement traitée. Bien entendu, il est également possible de lancer une autre exception que celle que l'on a reçue, comme ce peut être par exemple le cas si le traitement de l'erreur provoque lui-même une erreur.
Pour relancer l'exception en cours de traitement dans un gestionnaire d'exception, il faut utiliser le mot clé throw. La syntaxe est la suivante :
 throw ;
L'exception est alors relancée, avec comme valeur l'objet que le compilateur a construit en interne pour propager l'exception. Les gestionnaires d'exception peuvent donc modifier les paramètres des exceptions, s'ils les attrapent avec une référence.
Si, lorsqu'une exception se produit dans un bloc try, il est impossible de trouver le bloc catch correspondant à la classe de cette exception, il se produit une erreur d'exécution. La fonction prédéfinie std::terminate est alors appelée. Elle se contente d'appeler une fonction de traitement de l'erreur, qui elle-même appelle la fonction abort de la bibliothèque C. Cette fonction termine en catastrophe l'exécution du programme fautif en générant une faute (les ressources allouées par le programme ne sont donc pas libérées, et des données peuvent être perdues). Ce n'est généralement pas le comportement désiré, aussi est-il possible de le modifier en changeant la fonction appelée par std::terminate.
Pour cela, il faut utiliser la fonction std::set_terminate, qui attend en paramètre un pointeur sur la fonction de traitement d'erreur, qui ne prend aucun paramètre et renvoie void. La valeur renvoyée par std::set_terminate est le pointeur sur la fonction de traitement d'erreur précédente. std::terminate et std::set_terminate sont déclaréee dans le fichier d'en-tête exception.
Exemple 9-2. Installation d'un gestionnaire d'exception avec set_terminate.
using namespace std;
void mon_gestionnaire(void)
 cout « "Exception non gérée reçue !" « endl;
 cout « "Je termine le programme proprement..."
 « endl;
 exit(-1);
int lance_exception(void)
 throw 2;
int main(void)
 set_terminate(&mon_gestionnaire);
 try
 lance_exception();
 catch (double d)
 cout « "Exception de type double reçue : " «
 d « endl;
 return 0;

Programmation C-C++/Les exceptions/Liste des exceptions autorisées pour une fonction