renseignement sur throw et son fonctionnement

15 réponses

Stephane Wirtel

11/09/2006 à 21:07

bonsoir,

simplement pour m'amuser, je viens de créer une classe d'exception
n'héritant pas d'une std::exception & co.

je l'ai rendue non copyable, mais j'ai constaté que le compilo (g++ 4.1)
râlait quand je lançais mon exception via throw.

le code est tout simple

<code exemple>

#include <string>
#include <boost/noncopyable.hpp>

/// La classe est rendue non copyable pour faire un test qui je pensais
/// allait réussir.
class MonException : boost::noncopyable {
public:
MonException( const std::string & msg_ ) : msg( msg_ ) {
}
private:
std::string msg;
};

int main( int argc, char ** argv ) {
try {
/// création d'une instance d'une classe
throw MonException("ceci est un test");
}
catch( const MonException & ex ) {
/// on catche une référence sur l'instance MonException qui a été
/// lancée
}
return 0;
}
</code>

Lors de la compilation, je constate que le compilateur essaye de créer
un constructeur de copie, alors que je l'interdit.

Est-ce dans la norme de créer une nouvelle instance de la classe par un
constructeur de copie ou est-ce un probleme dans le configuration de la
phase de compilation ?

Merci

10 réponses

1 2

Jean-Marc Bourguet

11/09/2006 à 21:34

Stephane Wirtel writes:

bonsoir,

simplement pour m'amuser, je viens de créer une classe d'exception
n'héritant pas d'une std::exception & co.

je l'ai rendue non copyable

Les exceptions doivent être copiables.

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Sylvain

11/09/2006 à 22:35

Stephane Wirtel wrote on 11/09/2006 21:07:

simplement pour m'amuser, je viens de créer une classe d'exception
n'héritant pas d'une std::exception & co.

bonne idée.

je l'ai rendue non copyable, mais j'ai constaté que le compilo (g++ 4.1)
râlait quand je lançais mon exception via throw.
[...]

Lors de la compilation, je constate que le compilateur essaye de créer
un constructeur de copie, alors que je l'interdit.

tu interdis cette copie mais le mode de propagation de l'exception
requiert cette copie, le compilo ne modifie pas ces appels (tout son
boussin) sur ta seule protection de la copie.

les exceptions peuvent être non copiables si tu propages un pointeur et
non une référence; eg

class MonException {
private:
MonException(const MonException&);
MonException& operator =(const MonException&);
char* extStr;
public:
MonException(char* str) : extStr(str) {}
const char* reason() const { return extStr; }
};

int main(){
try {
throw new MonException("ceci est un test");
}
catch (MonException* ex){
printf("%sn", ex->reason());
delete ex;
}
return 0;
}

Sylvain.

Stephane Wirtel

12/09/2006 à 08:26

Jean-Marc Bourguet wrote:

Stephane Wirtel writes:

bonsoir,

simplement pour m'amuser, je viens de créer une classe d'exception
n'héritant pas d'une std::exception & co.

je l'ai rendue non copyable

Les exceptions doivent être copiables.

A+

justement, je me suis demandé pour quelles raisons les exceptions

devaient être copiable.
Le throw crée une instance d'une classe qui sera propre au scope où elle
a été lancée. Est-ce que le compilateur doit créer une nouvelle instance
de cette classe pour avoir la possibilité de l'externationaliser du code
qui l'a lancé ?

En gros, je ne m'étais jamais trop demandé comment fonctionnait les
exceptions, mais à force je commence à me poser quelques questions.

Je vais regarder après un article qui pourrait m'expliquer le
fonctionnement des exceptions dans un compilo.

merci

stef

Jean-Marc Bourguet

12/09/2006 à 08:43

Stephane Wirtel writes:

Jean-Marc Bourguet wrote:
Stephane Wirtel writes:

bonsoir,

simplement pour m'amuser, je viens de créer une classe d'exception
n'héritant pas d'une std::exception & co.

je l'ai rendue non copyable
Les exceptions doivent être copiables.

A+

justement, je me suis demandé pour quelles raisons les exceptions devaient

être copiable.

Comment est-ce qu'à l'endroit où on attrape l'exception, on
pourrait accéder aux infos de celle-ci si elle n'était pas
copiée: on a quitté le scope où elle a été lancée et les
objets locaux à ce scope ont donc été détruit.

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Stephane Wirtel

12/09/2006 à 08:57

justement, je me suis demandé pour quelles raisons les exceptions devaient
être copiable.

Comment est-ce qu'à l'endroit où on attrape l'exception, on
pourrait accéder aux infos de celle-ci si elle n'était pas
copiée: on a quitté le scope où elle a été lancée et les
objets locaux à ce scope ont donc été détruit.
Bin, je pensais qu'on ne créait qu'une seule instance de l'exception à l'aide

du throw, et que via référence dans le catch, on accédait à cette unique
référence.
C'est à cause de ce raisonnement que je demandais un soupçon d'informations
complémentaires.

Fabien LE LEZ

12/09/2006 à 10:10

On Tue, 12 Sep 2006 08:57:43 +0200, Stephane Wirtel :

Bin, je pensais qu'on ne créait qu'une seule instance de l'exception à l'aide
du throw

"throw" ne crée rien. Il lance un objet déjà créé.
Et typiquement, l'objet en question a été créé comme variable locale,
donc va être détruit au moment de sortir de la fonction.

Stephane Wirtel

12/09/2006 à 10:30

"throw" ne crée rien. Il lance un objet déjà créé.
Et typiquement, l'objet en question a été créé comme variable locale,
donc va être détruit au moment de sortir de la fonction.

merci pour ces explications.

au début, je pensais que dans le cas d'un throw la portée d'une instance
était plus élevée que le bloc dans laquelle celle-ci était définie.

encore deux questions :d

donc, en gros, nous aurons au minimum deux instances d'une exception ?

est-ce que lorsque l'on relance une exception, une nouvelle copie est réalisée ?

merci

Michel Decima

12/09/2006 à 10:36

donc, en gros, nous aurons au minimum deux instances d'une exception ?

Une instance dans la portee locale et une issue de la copie lors du
throw (enfin c'est comme ca que ca se passait lors de ma derniere
experimentation avec gcc-4)

est-ce que lorsque l'on relance une exception, une nouvelle copie
est réalisée ?

Si tu relances avec throw tout court, cette nouvelle copie n'est pas
necessaire:

catch (exception& e) { throw; }

En revanche, si tu relances l'instance que tu as attrapee:

catch (exception& e) { throw e; }

il est possible qu'il y ait de nouveau une copie.

Pour gcc, il y a une doc. online qui explique comment ca se passe, mais
j'ai perdu le lien.

MD

Fabien LE LEZ

12/09/2006 à 10:41

On Tue, 12 Sep 2006 10:30:01 +0200, Stephane Wirtel
:

au début, je pensais que dans le cas d'un throw la portée d'une instance
était plus élevée que le bloc dans laquelle celle-ci était définie.

Regarde le code

throw MonException();

comme

MonException e;
throw e;

et tout te paraîtra clair.

donc, en gros, nous aurons au minimum deux instances d'une exception ?

Au minimum, oui : l'instance passée à throw, et l'instance stockée par
throw. Mais chaque implémentation a le droit de faire autant de copies
qu'elle veut.

Alain Gaillard

12/09/2006 à 10:50

Si tu relances avec throw tout court, cette nouvelle copie n'est pas
necessaire:

En effet. Du moins pas au moment où elle est relancée.

Si l'exception relancée est capturée plus loin et comme ça:

catch(exception e)

il y a copie. Du moins sur mon VC2005 mais je pense que tous les
compilos vont faire pareil.

En revanche si elle est capturée comme ça:

catch(...)

alors il n'y a pas copie, ce qui est somme toute logique et là aussi je
pense que tous les compilos font pareil.

--
Alain

1 2

renseignement sur throw et son fonctionnement

10 réponses

Veuillez sélectionner un problème