Discussion :

[ram-0000]

Bonsoir,

J'ai le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int main(int argc, char * argv [])
{
   try
   {
      if(bla bla)
         throw std::exception("bla bla");
   }
   catch(std::exception & e)
   {
      // gestion des erreurs
   }
   return EXIT_SUCCESS;
}

Cela marche bien mais je me pose une question au sujet de la durée de vie de l'exception

Dès que l'exception est levée, on quitte le bloc try et donc, normallement l'objet std::exception est détruit.

Comment se fait t'il alors qu'il existe encore dans le bloc catch et qu'il soit valide.

• Coup de chance
• c'est normal et j'ai rien compris
• autre chose

Est ce que le mieux ce ne serait pas d'écrire

Code :

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

   throw new std::exception("bla bla");

et

Code :

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

1
2
3
4
5
   catch(std::exception * e)
   {
      // gestion des erreurs
      delete e;
   }

[JulienDuSud]

Je vais peut-être dire une bêtise, mais je crois que le block try-catch en interne ne forme qu'un seul block et si une exception est levée, il y a un saut jusqu'au catch et l'exception n'est détruite qu'à la fin du block catch.

[Sylvain Togni]

J'ai le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int main(int argc, char * argv [])
{
   try
   {
      if(bla bla)
         throw std::exception("bla bla");
   }
   catch(std::exception & e)
   {
      // gestion des erreurs
   }
   return EXIT_SUCCESS;
}

A noter ici que la norme ne spécifie pas de constructeur de std::exception prenant une chaine de caractère. Même si cela peut compiler sur certains compilateurs le proposant en extension, ce genre de code n'est pas portable.

Cela marche bien mais je me pose une question au sujet de la durée de vie de l'exception

Dès que l'exception est levée, on quitte le bloc try et donc, normalement l'objet std::exception est détruit.

Normalement, oui, et même avant de quitter le bloc vu qu'il s'agit d'un temporaire. Mais les objets créés à l'aide du mot-clé throw ont une durée de vie différente :

A throw-expression initializes a temporary object [...] The memory for the temporary copy of the exception being thrown is allocated in an unspecified way [...] The temporary persists as long as there is a handler being executed for that exception.

Est ce que le mieux ce ne serait pas d'écrire

Code :

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

   throw new std::exception("bla bla");

et

Code :

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

1
2
3
4
5
   catch(std::exception * e)
   {
      // gestion des erreurs
      delete e;
   }

Pas besoin de s'embêter avec l'allocation dynamique, donc

[loufoque]

Il faut lever les exceptions par valeur et les attraper par référence.

Quand tu lèves une exception, l'objet est copié dans un stockage particulier.

[ram-0000]

A noter ici que la norme ne spécifie pas de constructeur de std::exception prenant une chaine de caractère. Même si cela peut compiler sur certains compilateurs le proposant en extension, ce genre de code n'est pas portable.

Je vais regarder ce détail mais effectivement, ce n'était pas le coeur du problème.

Normalement, oui, et même avant de quitter le bloc vu qu'il s'agit d'un temporaire. Mais les objets créés à l'aide du mot-clé throw ont une durée de vie différente ::

A throw-expression initializes a temporary object [...] The memory for the temporary copy of the exception being thrown is allocated in an unspecified way [...] The temporary persists as long as there is a handler being executed for that exception.

Ceci explique cela mais j'adore quand une norme décrit un comportement global sans pour autant le spécifier !!

Pas besoin de s'embêter avec l'allocation dynamique, donc

Bonne nouvelle donc.

Merci à tous

[maxim_um]

salut,

Dès que l'exception est levée, on quitte le bloc try et donc, normallement l'objet std::exception est détruit.

Il a bien été détruit, par contre le compilateur a fait une copie de ton objet pour permettre le traitement de l'exception par le bloc catch.
Aussi, tu dois bien garder à l'esprit que tu dois utiliser des références et non des pointeurs, dans quel cas tu risques de te retrouver avec plusieurs copies de travail.

[ram-0000]

Il a bien été détruit, par contre le compilateur a fait une copie de ton objet pour permettre le traitement de l'exception par le bloc catch.
Aussi, tu dois bien garder à l'esprit que tu dois utiliser des références et non des pointeurs, dans quel cas tu risques de te retrouver avec plusieurs copies de travail.

Donc si je comprends bien ce que tu dit, il faut que l'objet exception que je lève ait un constructeur de copie valide. Sinon l'objet traité dans le bloc catch risque d'être invalide.

[maxim_um]

Absolument.

[Matthieu Brucher]

Absolument.

Ou pour éviter cela, tu rattrapes par référence constante et normalement, pas de copie

[maxim_um]

Pourquoi tu dis:

normalement, pas de copie

Tu n'en es pas sûr?