POO – Langage C++

Les exceptions
1ère année ingénieur informatique

Mme Wiem Yaiche Elleuch

2018 - 2019
 plan
• Définition d'une exception: throw..try..catch
• Cheminement/propagation des exceptions
• Redéclenchement/relance d'une exception
• Spécification d'interface
• Exceptions standards

Mme Wiem Yaiche Elleuch 2

 Définition d'une exception
• Exception: est une erreur, anomalie, incident au cours de l'exécution
d'un programme (exemples: échec allocation, erreur d'indice, disque
plein, problème d'ouverture de fichier, etc)

• Gestion des exceptions: mécanisme très puissant de traitement de

ces anomalies, qui a été intégré au langage C++

• But: Séparer, dissocier, découpler :

– la détection de l'erreur dans un programme
– Le traitement de l'erreur

• La détection d’un incident et son traitement dans les programmes

importants doivent se faire dans des parties différentes du code.

• Résultat: développer des composants réutilisables destinés à être

exploités par de nombreux programmes.
Mme Wiem Yaiche Elleuch 3
 Les exceptions
• une exception est une rupture de séquence déclenchée (levée, lancée)
par une instruction throw, comportant une expression d'un type
donné.

• Il y a alors branchement à un ensemble d'instructions nommé

gestionnaire d'exception (choisi selon le type de l'exception).

• Le modèle de gestion des exceptions proposé par C++ ne permet pas

de reprendre l’exécution à partir de l’instruction ayant levé l’exception,
mais le permet après le bloc catch correspondant

•  chaque exception est caractérisée par un type, et le choix du bon

gestionnaire se fait en fonction du type de l'expression mentionnée à
throw.
Mme Wiem Yaiche Elleuch 4
 Structure de contrôle try … catch
• Pour qu'une partie de programme puisse intercepter une exception, il est
nécessaire qu'elle figure à l'intérieur d'un bloc précédé du mot clé try.

• Quand une exception est détectée dans un bloc try, le contrôle de l'exécution
est donné au bloc catch correspondant au type de l'exception, s'il en existe.

• Un bloc try doit être suivi d'un ou de plusieurs blocs catch représentants les
différents gestionnaires correspondants.

• Si plusieurs blocs catch existent, ils doivent intercepter un type d'exception

différent.

• Un gestionnaire d'exception peut contenir des instructions exit ou abort qui

mettent fin à l'exécution du programme

• À la fin du bloc catch, le programme continue sur l'instruction qui suit le

Mme Wiem Yaiche Elleuch 5
dernier catch
 jargon
• Une exception a un type (de préférence, utiliser type
classe)

• Une exception est déclenchée /lancée / levée par throw

• Le bloc try contient l'instruction qui peut générer

l'exception.

• Une exception est attrapée/capturée/interceptée par un

bloc catch

Mme Wiem Yaiche Elleuch 6

 Exception déclenchée dans main
throw … try … catch
Exception de type int, 
catch est de type int

Bloc try

Gestionnaire
d'exception

Mme Wiem Yaiche Elleuch 7

 déroulement
• À l'exécution, le programme se déroule normalement comme
si les instructions try et les blocs catch n'étaient pas là.

• Par contre, au moment où l'ordinateur arrive sur une

instruction throw, il saute toutes les instructions suivantes et
appelle le destructeur de tous les objets déclarés à l'intérieur
du bloc try. Il cherche le bloc catch correspondant à l'objet
lancé.

• Arrivé au bloc catch, il exécute ce qui se trouve dans le bloc et

reprend l'exécution du programme après le bloc catch.

Mme Wiem Yaiche Elleuch 8

 Exception de type string 
catch est de type string

Mme Wiem Yaiche Elleuch 9

 Les fonctions terminate et abort

• Remarque: dans cet exemple, l'exception est de type string, et aucun catch de
type string n'a été défini  une fonction spéciale terminate, qui par défaut
appelle la fonction abort, est appelée pour terminer l'exécution du programme.
Mme Wiem Yaiche Elleuch 10
exemple

Mme Wiem Yaiche Elleuch 11

Quelques schémas: exception lancée dans main

Mme Wiem Yaiche Elleuch 12

Quelques schémas: exception lancée par une fonction appelée

Mme Wiem Yaiche Elleuch 13

D'une manière générale

Mme Wiem Yaiche Elleuch 14

Exemple: Exception déclenchée par la
fonction division appelée par main

Mme Wiem Yaiche Elleuch 15

 plan
• Définition d'une exception: throw..try..catch
• Cheminement/propagation des exceptions
• Redéclenchement/relance d'une exception
• Spécification d'interface
• Exceptions standards

Mme Wiem Yaiche Elleuch 16

 Cheminement des exceptions
• Lorsqu'une exception est levée par une fonction, on
cherche tout d'abord un gestionnaire dans l'éventuel
bloc try associé à cette fonction

• S'il n'existe pas, (ou si aucun bloc try n'est associé), on

poursuit la recherche dans un éventuel bloc try associé
à une fonction appelante et ainsi de suite.

• Si aucun gestionnaire d'exception n'est trouvé, on

appelle la fonction terminate, qui par défaut appelle
abort
Mme Wiem Yaiche Elleuch 17
Dans cet exemple, l'exception déclenchée est de type int, elle est attrapée par le
Mme Wiem Yaiche Elleuch 18
bloc catch de main, car aucun bloc catch de la fonction division n'est de type int.
 plan
• Définition d'une exception: throw..try..catch
• Cheminement/propagation des exceptions
• Redéclenchement/relance d'une exception
• Spécification d'interface
• Exceptions standards

Mme Wiem Yaiche Elleuch 19

 Redéclenchement d'exception avec
throw;
• Dans un gestionnaire, l'instruction throw (sans
expression) retransmet l'exception au niveau
englobant.

• Cette possibilité permet par exemple de compléter un

traitement standard d'une exception par un traitement
complémentaire spécifique.

• voici un exemple dans lequel une exception (ici de type

int) est tout d'abord traitée dans la fonction division,
avant d'être traitée dans main:
Mme Wiem Yaiche Elleuch 20
Mme Wiem Yaiche Elleuch 21
 plan
• Définition d'une exception: throw..try..catch
• Cheminement/propagation des exceptions
• Redéclenchement/relance d'une exception
• Spécification d'interface
• Exceptions standards

Mme Wiem Yaiche Elleuch 22

 Spécification d'interface: la fonction
unexpected
• Une fonction peut spécifier les exceptions qu'elle est susceptible de
déclencher/provoquer (elle-même, ou dans les fonctions qu'elle
appelle à son tour).

• Elle le fait à l'aide du mot clé throw, suivi, entre parenthèses, de la

liste des exceptions concernées.

• Dans ce cas, toute exception non prévue et déclenchée à l'intérieur

de la fonction (ou d'une fonction appelée) entraîne l'appel d'une
fonction particulière nommée unexpected.

void division (…) throw (int,string) { }

// la fonction division ne peut déclencher que des
exceptions de type int et string
Mme Wiem Yaiche Elleuch 23
 Spécification d’exceptions
1. void f() throw (string): seule l'exception du type string
peut être lancée dans la fonction f.

2. void g() throw (int, double): uniquement les exceptions

du type int et double peuvent être lancées dans la
fonction g.

3. int f() throw(): aucune exception ne peut être lancée dans

la fonction f.

4. double f(): toutes les exceptions peuvent être levées dans

la fonction f, c'est l'approche par défaut.

Mme Wiem Yaiche Elleuch 24

 Spécification d’exceptions
• Si une fonction lance une exception non déclarée
dans son entête, une fonction unexpected est
appelée.

• Cette fonction appellera une fonction terminate.

• La fonction terminate aura pour tâche d'appeler la

fonction abort pour arrêter l'exécution du
programme.

Mme Wiem Yaiche Elleuch 25

 plan
• Définition d'une exception: throw..try..catch
• Cheminement/propagation des exceptions
• Redéclenchement/relance d'une exception
• Spécification d'interface
• Exceptions standards

Mme Wiem Yaiche Elleuch 26

 Les exceptions standards
• La bibliothèque standard exception
comporte quelques classes logic - error
fournissant des exceptions domain error
spécifiques susceptibles invalid _argument
length - error
d'être déclenchées par un out_of_range
programme. runtime_error
range - error
overflow error
• Toutes ces classes dérivent underflow - error
d'une classe de base bad_alloc
nommée exception et sont bad_cast
organisées suivant la bad_exception
bad _typeid
hiérarchie suivante: 27

Mme Wiem Yaiche Elleuch

 Les exceptions déclenchées par la
bibliothèque standard
• bad_alloc: échec d'allocation mémoire par new;

• bad_cast : échec de l'opérateur dynamic _cast;

• bad_typeid : échec de la fonction typpeid ;

• bad_exception: erreur de spécification d'exception; cette exception peut

être déclenchée dans certaines implémentations par la fonction
unexpected ;

• out_of_range: erreur d'indice; cette exception est déclenchée par les

fonctions at, membres des différentes classes conteneurs ainsi que par
l'opérateur [] du conteneur bitset;

• invalid_argument: déclenchée par le constructeur du conteneur bitset:

28

• overflow_error : déclenchée par la fonction to_ulong du conteneur bitset.

Mme Wiem Yaiche Elleuch
 Les exceptions utilisables dans un
programme
• Toutes les classes précédentes sont utilisables pour
les exceptions déclenchées par l'utilisateur, soit telles
quelles, soit sous forme de classes dérivées.

• Il est cependant préférable d'assurer une certaine

cohérence à son programme; par exemple, il ne
serait pas raisonnable de déclencher une exception
bad_alloc pour signaler une anomalie sans rapport
avec une allocation mémoire.
29

Mme Wiem Yaiche Elleuch

 Les exceptions standards
• la classe de base exception dispose d'une fonction
membre what censée fournir comme valeur de retour
un pointeur sur une chaîne expliquant la nature de
l'exception.

• Cette fonction, virtuelle dans exception, doit être

redéfinie dans les classes dérivées et elle l'est dans
toutes les classes citées ci-dessus

• toutes ces classes disposent d'un constructeur recevant

un argument de type chaîne dont la valeur pourra
ensuite être récupérée par what.

Mme Wiem Yaiche Elleuch 30

 Création d'exceptions dérivées de la
classe exception
Il est recommnadé de créer des classes dérivées de la classe exception, pour
au moins deux raisons:

1. on est sûr d'intercepter toutes les exceptions avec le simple gestionnaire:

catch (exception & e) { …… }
Ce ne serait pas le cas pour des exceptions non rattachées à la classe
exception.

1. On peut s'appuyer sur la fonction what, à condition de la redéfinir dans

les classes dérivées. Il est alors facile d'afficher un message explicatif
concernant l'exception détectée, à l'aide du simple gestionnaire suivant:

catch (exception & e) // attention à la référence, pour bénéficier

de la ligature dynamique de la fonction virtuelle what 31
{ cout << "exception interceptée: " << [Link]() << "\n" ;
} Mme Wiem Yaiche Elleuch
Mme Wiem Yaiche Elleuch 32
choix du gestionnaire d'exception: l'examen des blocs
catch se fait dans l'ordre

&
&

&
&

Mme Wiem Yaiche Elleuch 33

Exemple classe out_of_range

Mme Wiem Yaiche Elleuch 34

Exemple simple 1

Mme Wiem Yaiche Elleuch 35

Exemple simple 2

Mme Wiem Yaiche Elleuch 36