Durée de vie d'une exception

Bonsoir,

J'ai le code suivant :
Code:

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:

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

et
Code:

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

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.

Citation:
Envoyé par ram-0000
J'ai le code suivant :
Code:

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.

Citation:

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 :

Citation:

Envoyé par la norme

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.
Citation:
Est ce que le mieux ce ne serait pas d'écrire

Code:

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

et
Code:

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 :)

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.

Citation:

Envoyé par Sylvain Togni

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.

Citation:

Envoyé par Sylvain Togni

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 ::

Citation:

Envoyé par la norme

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 !!

Citation:

Envoyé par Sylvain Togni

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

Bonne nouvelle donc.

Merci à tous

salut,

Citation:

Envoyé par ram-0000

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.

Citation:

Envoyé par maxim_um

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.

Absolument.

Citation:

Envoyé par maxim_um

Absolument.

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

Pourquoi tu dis:

Citation:

Envoyé par Matthieu Brucher

normalement, pas de copie ;)

Tu n'en es pas sûr?