Discussion :

[deubelte]

Bonjour

J'ai une question de base sur les gestions d'erreurs. Je ne comprends pas pourquoi le code suivant fonctionne:

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
int f(int i) {
   throw "test";
   return 0;
}
 
class C {
   int i;
 
public:
   C(int);
};
 
C::C(int ii) {
   try {   // function-try block
      f(ii) ;
      // body of function goes in try block
   }
   catch (...) {
      // handles exceptions thrown from the constructor-initializer
      // and from the constructor function body
      printf_s("In the catch block\n");
   }
}
 
int main() {
   C *MyC = new C(0);
   delete MyC;
}

alors que celui là, où j'ai juste remplacé catch(...) par catch(char*),

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
 
int f(int i) {
   throw "test";
   return 0;
}
 
class C {
   int i;
 
public:
   C(int);
};
 
C::C(int ii) {
   try {   // function-try block
      f(ii) ;
      // body of function goes in try block
   }
   catch (char*) {
      // handles exceptions thrown from the constructor-initializer
      // and from the constructor function body
      printf_s("In the catch block\n");
   }
}
 
int main() {
   C *MyC = new C(0);
   delete MyC;
}

ne fonctionne pas.

Je pensais que throw renvoyait une exception de type char*, mais, bien que cette exception se situait à un niveau plus inférieur que catch(char*), celle-ci remonterait pour être attrapée par ce catch. Mais ce n'est pas le cas apparemment.

Pourriez vous m'expliquer pourquoi?

Il semble que catch(...) soit un catch par défaut.


Merci

[Arzar]

Bonjour,
J'obtiens :
cas n°1 : "In the catch block"
cas n°2 : "In the catch block"

Pas trop compris ce que tu voulais montrer ?

PS : L'exemple est un peu curieux d'ailleurs. Pourquoi intercepter l'exception dans le constructeur et faire croire que tout c'est bien passé ? Généralement si la construction d'une classe échoue, on lance une exception vers l'extérieur pour signaler le problème, par exemple :

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
 
int f(int i) 
{
   throw "test";
   //return 0; return optionel ici
}
 
class C 
{
   int i;
 
public:
   C(int ii)
   {
      f(ii) ;
   }
};
 
 
int main() 
{
   C* MyC = NULL;
 
   try 
   {   
      MyC = new C(0);
   }
   catch (char*) 
   {
      // handles exceptions thrown from the constructor-initializer
      // and from the constructor function body
      printf_s("In the catch block\n");
      // delete MyC; pas besoin de delete ici
   }
}

[koala01]

Salut,

1- l'ellipse "(...)" récupère "n'importe quelle exception", c'est à dire, toute exception non rattrapée par ailleurs

2- ce n'est pas catch "(char * c)" que tu aurais du écrire mais "const char * c", car le pointeur est constant

3- +1 avec Azar... A moins que tu ne puisse faire quelque chose quand une exception est lancée, il ne sert pas à grand chose de la récupérer (et surtout de ne pas la relancer): le système se trouve dans un état aberrant lorsqu'une une exception est lancée. le but du catch est de te donner l'occasion de replacer le système dans un état correct . Tant que l'exception n'a pas pu être totalement gérée, il est donc largement recommandé de la laisser remonter, dans l'espoir qu'une des fonctions appelantes (de manière directe ou indirecte) puisse assurer cette remise du système dans un état correct

4- Il est très largement préférable de lancer des exception prenant la forme d'objets (de les lancer par valeur et de les récupérer par référence, pour être précis). En effet, le but premier d'une exception est, bien sur, de signaler que "quelque chose cloche", mais, surtout, de transmettre une information sur le contexte dans lequel cette chose à cloché.

Si tu ne transmet qu'une chaine de caractères (ou une valeur numérique entière) comme exception, tu te place dans une situation dans laquelle tu dois systématiquement tester l'ensemble des valeurs que les différentes exceptions peuvent prendre, ce qui peut rapidement devenir un foutoir sans nom.

Si, par contre, tu transmet des classes ou des structures, même si elles sont vide (à l'exception d'une fonction "what"), tu peux beaucoup plus facilement gérer les différents cas de figures, y compris grâce aux éventuelles hiérarchies de classes existantes, en plus de te permettre de fournir des informations plus précises sur ce qui a provoqué le problème

PS: d'ailleurs, l'idéal est toujours de d'hériter d'une des classes d'exception fournies par le standard, en choisissant celle qui correspond le mieux au contexte "générique" dans lequel le problème est survenu

[deubelte]

moi, quand je lance le deuxième cas, j'ai le message d'erreur suivant:

mais effectivement, quand je remplace par const char*
cela fonctionne parfaitement.

L'exemple est tiré de la MSDN

[koala01]

moi, quand je lance le deuxième cas, j'ai le message d'erreur suivant:

mais effectivement, quand je remplace par const char*
cela fonctionne parfaitement.

L'exemple est tiré de la MSDN

C'est normal...

Tu essaye d'attraper un const char * avec un catch( char*), ce qui fait que l'exception n'est pas attrapée.

Comme tu n'a pas d'autre catch qui soit éventuellement en mesure de récupérer ton exception, elle n'est... jamais récupérée et provoque la fin de l'application.

Et le système te signale que l'application est quittée parce qu'une exception n'a pas été attrapée