Discussion :

[sinasquax]

Bonjour a tous, j'ai un petit probleme avec ma conception des exceptions.

J'ai une classe CException avec un constructeur paramétré :

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
 
 
 class CException : public std::exception
 {
  public :
 
   CException () throw() {};
   CException (const std::string &msg) throw() { m_what = msg; };
 
   virtual const char *what (void) const throw() { return m_what.c_str(); };
 
  protected :
 
   std::string m_what;
 
 };

J'ai ensuite une hiérarchie de classe dérivée de CException en fonction de l'exception relevée :

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
 
 
 class CExceptionMemory : public CException
 {
 };
 
 class CExceptionMemoryAllocFailed : public CExceptionMemory
 {
 };
 
 class CExceptionFile : public CException
 {
 };
 
 class CExceptionFileOpen : public CExceptionFile
 {
 };
 
...

Le probleme est que si je veux lever une exception CExceptionFileOpen par exemple avec comme parametre le nom du fichier :

Code :

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

1
2
3
 
 
throw CExceptionFileOpen(filename);

Le compilateur me dit que CExceptionFileOpen n'a pas de constructeur avec un const std::string &, pourtant la classe de base (CException) contient ce type de constructeur.

Je peux corriger ce probleme en implémentant le constructeur paramétré dans chaque classe dérivée mais y a t'il une meilleure solution 'orienté objet' ?

D'après mes recherches, il n'y a pas d'autres solutions mais peut etre que je n'ai pas trouvé.

Merci

[koala01]

Salut, et bienvenue sur le forum.

Tu pourrais déjà envisager de choisir une autre classe d'exception (elles ne manquent pas dans la STL) que la classe std::exception comme base de... ta propre exception de base.

En effet, toutes les classes qui dérivent de std::exception disposent d'un constructeur prenant une référence sur une chaine de caractères constante, et fournissent le comportement adéquat pour what.

Ainsi, étant donné que tes exceptions personnalisées vont sensiblement toutes arriver en période d'exécution, et qu'une fois que tu auras mis ton programme au point, tu devrais à tout le moins avoir tester ta logique jusque dans les moindre recoins, tu pourrais décider de faire dériver ta classe CException de la classe ...runtime_error de manière à ce qu'elle "réalise" cette exception fournie par le langage .

Ce n'est qu'un détail en soi, mais, à partir du moment où cela te permet de te simplifier la tâche, pourquoi t'en passer

Ceci dit, ce n'est pas parce qu'une classe dont tu fais dériver une autre classe dispose d'un constructeur donné que la classe héritière accepte automatiquement un constructeur qui prend les même arguments.

Pire encore: Si tu déclare un seul constructeur dans ta classe de base, et que tu indique pour celui-ci des arguments n'ayant pas de valeur par défaut, tu sera de toutes manières obligé d'appeler le constructeur en lui fournissant tous les arguments non facultatifs.

Ainsi, si tu as une classe de base sous la forme de

Code :

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

1
2
3
4
5
6
7
 
class Base
{
    public:
        Base(const std::string& str);
        /* les autres méthodes et membres de la classe
};

et que tu as une classe dérivée dont le constructeur n'a pas besoin d'argument, donnant quelque chose ressemblant à
class Derivee : public Base
{
public:
Derivee(){}
};
(ou que tu laisse le compilateur mettre ses constructeurs par défaut)
tu te fera jeter par le compilateur parce que tu n'invoque pas explicitement le seul constructeur qui soit connu pour la classe de base (hormis le constructeur de copie).
L'implémentation du constructeur de la classe Derivee devrait au minimum ressembler à

Code :

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

1
2
3
Derivee::Derivee():Base("une chaine de caractères propre a la classe Derivee")
{
}

en outre, le constructeur qui prend (dans le cas présent) une chaine de caractères s'applique... à la classe de base et non à la classe dérivée.

Ainsi, le seul constructeur de Derivee que le compilateur connait est... le constructeur ne prenant pas d'argument

Et c'est la raison pour laquelle il te "jette" quand tu essaye de faire créer une instance (ici d'une exception particulière) de la classe dérivée.

Pour résoudre le problème, c'est tout simple:

Déclare un constructeur dans ta classe dérivée qui prend lui aussi une référence constante sur une chaine de caractères, sous la forme de

Code :

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

1
2
3
4
5
6
class Derivee : public Base
{
    public:
        Base(const std::string& str):Base(str){}
        /* les autres méthodes et membres de la classe */
};

ou, étant donné que le constructeur de ta classe de base prévoit une liste d'exceptions potentielles vide, il faudra prévoir un constructeur prenant la forme de

Code :

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

1
2
3
4
5
class Derivee : public Base
{
    public:
        Derivee(const std::string& str)throw():Base(str){}
};