Exceptions et boule de gomme

**Captain'Flam** · 24/03/2016, 16h30

Bonjour à tou(te)s !

en faisant joujou avec les exceptions sous gcc, je suis tombé sur un comportement des plus étranges...
Voici un petit bout de code pour illustrer mon propos :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
#include <iostream>
#include <string>
using namespace std ;
 
struct Exception
    {
    Exception ()                                               { cout << "Exception::Exception()" << endl ;}
    Exception ( const Exception & e )     : message(e.message) { cout << "Exception::Exception(e) " << message << endl ;}
    Exception ( const string & m )        : message(m)         { cout << "Exception::Exception(s) " << message << endl ;}
    string message ;
    };
 
void failure1 ( const string & s )
    {
    cout << "failure1 : just before throw " << s << endl ; 
    throw Exception( s ) ; // throw just constructed Exception : ok
    }
 
void failure2 ( const string & s )
    {
    static Exception e ;
    e.message = s ;
    cout << "failure2 : just before throw " << s << endl ; 
    throw e ; // throw static Exception : ok
    }
 
void failure3 ( const string & s )
    {
    Exception e( s ) ;
    cout << "failure3 : just before throw " << s << endl ; 
    throw e ; // throw local Exception : KO
    }
 
void sub_failure4 ( const Exception & exception )
    {
    cout << "sub_failure4 : just before throw " << exception.message << endl ; 
    throw Exception( exception ) ; // throw just constructed Exception, but from elder one : KO
    }
 
void failure4 ( const string & message )    
    { 
    cout << "failure4 : just before call sub_failure4" << endl ; 
    sub_failure4( Exception( message )) ;
    }
 
int main ( int argc , const char ** argv )
    {
    try { throw Exception("Exception 0") ;} catch ( Exception e )  { cout << "catch : " << e.message << endl << endl ;} // ok
    try { failure1("Exception 1" )       ;} catch ( Exception e )  { cout << "catch : " << e.message << endl << endl ;} // ok
    try { failure2("Exception 2" )       ;} catch ( Exception e )  { cout << "catch : " << e.message << endl << endl ;} // ok
    if (argc > 1)
    try { failure3("Exception 3" )       ;} catch ( Exception e )  { cout << "catch : " << e.message << endl << endl ;} // KO !
    try { failure4("Exception 4" )       ;} catch ( Exception e )  { cout << "catch : " << e.message << endl << endl ;} // KO !
    }

J'ai 5 scénarios de levée d'exception : les 0, 1 et 2 fonctionnent, les 3 et 4 plantent !
NB : pour pouvoir tester facilement les 3 et 4, je les ai conditionné par la présence d'un argument sur la ligne de commande.

Compilation (avec gcc (i686-posix-dwarf-rev2, Built by MinGW-W64 project) 4.9.0 sous Windows 7 64bits) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

gcc e.cpp -Wall -fexceptions -O2 -lstdc++ -o e.exe

Exécution avec l'exception n°4 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
>e.exe
Exception::Exception(s) Exception 0
Exception::Exception(e) Exception 0
catch : Exception 0
 
failure1 : just before throw Exception 1
Exception::Exception(s) Exception 1
Exception::Exception(e) Exception 1
catch : Exception 1
 
Exception::Exception()
failure2 : just before throw Exception 2
Exception::Exception(e) Exception 2
Exception::Exception(e) Exception 2
catch : Exception 2
 
failure4 : just before call sub_failure4
Exception::Exception(s) Exception 4
sub_failure4 : just before throw Exception 4
Exception::Exception(e) Exception 4
 
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

Exécution avec l'exception n°3 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
e.exe x
Exception::Exception(s) Exception 0
Exception::Exception(e) Exception 0
catch : Exception 0
 
failure1 : just before throw Exception 1
Exception::Exception(s) Exception 1
Exception::Exception(e) Exception 1
catch : Exception 1
 
Exception::Exception()
failure2 : just before throw Exception 2
Exception::Exception(e) Exception 2
Exception::Exception(e) Exception 2
catch : Exception 2
 
Exception::Exception(s) Exception 3
failure3 : just before throw Exception 3
Exception::Exception(e) Exception 3
 
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

Comme on peut le voir, dans les cas 3 et 4, on n'atteint pas le catch.

Si quelqu'un(e) comprend quelque chose à ce mystère, je suis preneur !

Merci d'avance

**foetus** · 24/03/2016, 16h59

À vue de pif cela semble logique

:

Exception 3 -> Lancement d'une exception qui est détruite à la fermeture de failure3. Comportement normal pour une variable locale.

Exception 4 -> Tu dois avoir un problème avec ton constructeur de recopie, puisque ton paramètre doit être détruit à la fermeture de sub_failure4.

**Médinoc** · 24/03/2016, 17h23

Envoyé par foetus

À vue de pif cela semble logique

:

Exception 3 -> Lancement d'une exception qui est détruite à la fermeture de failure3. Comportement normal pour une variable locale.

Mais les exceptions sont censées être lancées par valeur, non?
(surtout qu'ici en plus, elles sont aussi catchées par valeur)

Un truc qui serait intéressant serait de rajouter un destructeur à tes exceptions, pour voir quand exactement elles sont détruites.

**Gaulouis** · 24/03/2016, 17h45

Salut, j'ai fait un petit test sur Windows 7 32bits(gcc 4.9.1) et sur Ubuntu 64bits (gcc 4.8.4) y'a rien qui plante chez moi

**jo_link_noir** · 24/03/2016, 17h51

Pareil que Gaulouis avec gcc et g++ 4.9.1 et 5.0.0 sur Linux.

**Captain'Flam** · 25/03/2016, 09h17

Merci les gars !

Donc si je comprends bien, c'est juste ma config et un léger bug de gcc qui sont en cause...

**Captain'Flam** · 25/03/2016, 11h27

Punaise ! je suis passé à gcc (x86_64-posix-seh-rev2, Built by MinGW-W64 project) 4.9.0 et tout passe !

Toutefois, je me pose encore des questions à propos de la durée de vie d'une variable levée comme exception...
J'ai donc codé une variante de mon test précédant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
#include <iostream>
#include <string>
using namespace std ;
 
struct Exception
    {
   ~Exception ()                                                         { cout << "~Exception[" << id << "]()" << endl ;}
    Exception ()                          : id(bid++)                    { cout <<  "Exception[" << id << "]()" << endl ;}
    Exception ( const Exception & e )     : id(bid++),message(e.message) { cout <<  "Exception[" << id << "]([" << e.id << "])" << endl ;}
    Exception ( const string & m )        : id(bid++),message(m)         { cout <<  "Exception[" << id << "]('" << message << "')" << endl ;}
    Exception & set ( const string & m )                                 { message = m ; cout <<  "Exception[" << id << "] = " << message << endl ; return *this ;}
    static int bid ;
    int    id ;
    string message ;
    };
 
int Exception::bid = 1 ;
 
void failure1 ( const string & s )
    {
    cout << "failure1 : just before throw " << s << endl ; 
    throw Exception( s ) ;
    }
 
void failure2 ( const string & s )
    {
    static Exception e ;
    e.set( s ) ;
    cout << "failure2 : just before throw " << s << endl ; 
    throw e ;
    }
 
void sub_failure3 ( const Exception & exception )
    {
    cout << "sub_failure3 : just before throw " << exception.message << endl ; 
    throw exception ;
    }
 
void failure3 ( const string & message )    
    { 
    cout << "failure3 : just before call sub_failure3" << endl ; 
    sub_failure3( Exception( message )) ;
    }
 
int main ()
    {
    try { failure1("***1***" ) ;} catch ( Exception e )          { cout << "catch[" << e.id << "]" << endl ;} ; cout << "---------------------------" << endl ;
    try { failure1("***2***" ) ;} catch ( Exception & e )        { cout << "catch[" << e.id << "]" << endl ;} ; cout << "---------------------------" << endl ;
    try { failure1("***3***" ) ;} catch ( const Exception & e )  { cout << "catch[" << e.id << "]" << endl ;} ; cout << "---------------------------" << endl ;
    try { failure2("***4***" ) ;} catch ( const Exception & e )  { cout << "catch[" << e.id << "]" << endl ;} ; cout << "---------------------------" << endl ;
    try { failure3("***5***" ) ;} catch ( const Exception & e )  { cout << "catch[" << e.id << "]" << endl ;} ; cout << "---------------------------" << endl ;
    }

et sa sortie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
failure1 : just before throw ***1***
Exception[1]('***1***')
Exception[2]([1])
catch[2]
~Exception[2]()
~Exception[1]()
---------------------------
failure1 : just before throw ***2***
Exception[3]('***2***')
catch[3]
~Exception[3]()
---------------------------
failure1 : just before throw ***3***
Exception[4]('***3***')
catch[4]
~Exception[4]()
---------------------------
Exception[5]()
Exception[5] = ***4***
failure2 : just before throw ***4***
Exception[6]([5])
catch[6]
~Exception[6]()
---------------------------
failure3 : just before call sub_failure3
Exception[7]('***5***')
sub_failure3 : just before throw ***5***
Exception[8]([7])
~Exception[7]()
catch[8]
~Exception[8]()
---------------------------
~Exception[5]()

De 1,2,3 : on voit qu'on économise une construction par copie en catchant l’exception par référence.
De 4 : il construit quand même une copie pour éviter de lever une exception statique (on se demande pourquoi...).
De 5 : il y a une construction par copie en trop selon moi...

Si quelqu'un a un avis pertinent...

**Médinoc** · 25/03/2016, 11h33

À mon avis, la réponse est simple: On ne peut pas faire de throw par référence, seulement par valeur (ou pointeur, façon Java, mais c'est encore autre chose).

C'est probablement une question de sécurité, car les destructeurs dans les fonctions appelantes sont appelés avant l'entrée dans le bloc catch: ainsi, s'il était possible de lancer une exception par référence, tu pourrais catcher une exception déjà détruite!

**Captain'Flam** · 25/03/2016, 13h12

Envoyé par Médinoc

À mon avis, la réponse est simple: On ne peut pas faire de throw par référence, seulement par valeur (ou pointeur, façon Java, mais c'est encore autre chose).

Heu... dans les cas 2 et 3, on voit bien que l'exception qui a été construite avant le throw est celle qui arrive jusqu'au catch.
Donc, d'une manière ou d'une autre, il "sait" que cette instance va être catchée et il n'appelle pas son destructeur.

**Médinoc** · 25/03/2016, 13h55

Euh, les cas 2 et 3 utilisent tous deux failure1(), qui construit l'exception sur la ligne du throw...

Edit: En fait en y réfléchissant, c'est un peu comme les appels de fonction: Si une fonction prend un paramètre par valeur mais qu'on construit le paramètre dans l'appel lui-même, celui-ci est construit directement et donc non copié...

**Gaulouis** · 25/03/2016, 14h32

x86_64-posix-seh-rev2 c'est pour une machine 64bit
or i686-posix-dwarf-rev2 c'est pour une machine 32bit

fallait essayer avec l'option -arch x86_64

**secuexpert** · 29/03/2016, 23h12

Dans ces cas là, instrumente tout : constructeurs (y compris constructeur de copie) et destructeur.

Exceptions et boule de gomme

C++

Discussions similaires

Partager

Partager