Discussion :

[jimaitou]

Bonjour,
Je suis débutant en c++ ... et je bute sur un problème d'initialisation des membres de la classe mère.

Ma classe de base (la classe Exception) a un constructeur dont la signature est la suivante :
Exception::Exception(const std::string &msg, ...)

J'ai déclaré une classe qui hérite de la classe Exception :
class GetoptException : public Exception

et le constructeur de la classe fille a été initialisé de la façon suivante :
GetoptException::GetoptException(const std::string &msg, ...) : Exception(msg, ...) {}

à la compilation, le compilateur me renvoie une erreur sur le constructeur de la classe GetoptException :
GetoptException.cpp:12: error: expected primary-expression before '...' token

qui vient de l'instruction Exception(msg, ...), en fait du nombre d'arguments variable parce qu'avec l'instruction Exception(msg), il n'y a pas d'erreur de compilation.

J'utilise un compilateur gcc en version 3.4.4.

Est-il possible d'appeler le constructeur de la classe fille et d'initialiser les membres de la classe mère avec un nombre d'arguments variables ?

D'avance merci pour vos réponses

Hervé

[Matthieu Brucher]

Pourquoi tu as besoin d'arguments variables ?

[jimaitou]

Dans le message d'erreur, j'ai besoin de pouvoir remplacer de 1 à n tags du type %s, %d, %g etc ...
throw GetoptException("Error - Syntax error, invalid parameter %s at line %d", p_key, p_line);

[Matthieu Brucher]

Pourquoi ne pas lever tout de suite l'exception avec la bonne chaîne de caractères ?

[JolyLoic]

Les listes variables d'arguments sont assez peu supportées en C++. Le problème de base existerait sans parler de constructeurs ou d'héritage :

Si tu as une fonction : int f(string const &s, ...) et une fonction g(string const& s, ...) comment faire pour appeler f depuis g ? Rien n'est prévu pour.

Si vraiment tu voulais faire ça, je verrais deux solution :

- Tu donnes aussi à la classe de base un constructeur qui prend en paramètre un tableau de void*, et dans le constructeur de la classe dérivée tu te débrouille pour transformer cette liste variable en tableau de void*.
- Tu as un compilateur qui implémente déjà les variadic templates de la future norme C++, et tu définis tes deux constructeurs sous le forme de variadic template, et là le transfert est possible. Cette solution n'est pas pour débutant je pense.

Le mieux est effectivement à mon avis de laisser tomber cette façon de définir le constructeur, et de lui passer en argument une chaîne déjà formatée au préalable, ou éventuellement un objet de type boost::format, ce qui permettrait d'écrire :

Code :

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

throw GetoptException(format("Error - Syntax error, invalid parameter %1% at line %2%") % p_key % p_line);

[Nogane]

Bonjour,
Une autre solution est d'implémenter un operateur << a ta class Exception:

Code :

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

1
2
3
4
5
6
7
8
template<class T>
Exception& Exception::operator << (const T &val)
{
	std::stringstream stream;
	stream << message_ << val;
	message_ = stream.str();
	return *this;
}

En supposant que message_ est un std::string, membre de Exception.

Ainsi on peut faire:

Code :

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

throw Exception() << "Error - Syntax error, invalid parameter " << p_key << " at line " << p_line;

C'est peut être pas la meilleur solution mais c'est ce que je fait et pour l'instant ça me convient bien.

[koala01]

Salut,

Selon toutes vraisemblances, les classe qui dérivent de Exception se contentent de réaliser la classe Exception

Dés lors, tu sais d'avance ce qui sera intéressant à transmettre au constructeur de Exception, et tu sais d'avance le nombre et le type des arguments que tu veux passer au constructeur de l'exception "particulière"

Je m'explique, si tu as une exception SyntaxError, le message sera sans doute de l'ordre de

Syntax Error : trucmuch must to be blabla in file F at line L

qui pourrait être considéré comme... deux chaines de caractères bien distinctes:

• Syntax Error qui indique l'exception réellement lancée
• trucmuch must to be blabla in file F at line L qui donne des précisions "facultatives" sur l'exception lancée

Tu peux donc tout à fait envisager de séparer effectivement ces deux chaines de caractères dans ta classe Exception, qui, pour assurer la compatibilité avec les exceptions de la SL pourrait prendre la forme de

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
 
class Exception : public std::exception
{
    public:
        Exception(std::string const& error):more(""), msg(error){}
        /* un constructeur sur base de n'importe quelle exception SL */
        Exception(std::exception& e):mmore("No more info, sorry"),
                                      msg(std::string(e.what()) ){}
        /*le destructeur qui ne peut pas lancer d'exception */
        ~Exception() throw(){/* mais qui ne fait rien */}
        /* la récupération de la chaine de caractères principale */
        const char* what() const throw(){return msg.c_str();}
        /* la récupération de la chaine de caractères secondaire */
        const char* more() const throw(){return mmore.c_str();}
    protected:
        /* la chaine de caractères secondaire ( protégée car susceptible
         * d'etre modifiée par les classes dérivées
         */
        std::string mmore;
    private:
        /* la chaine de caractères principale, ( privée car ne devant pas 
         * être modifiée par les classes dérivées )
         */
        std::string msg;
};

Par la suite, il te devient donc facile de dériver ton exception SyntaxError en ne lui donnant que les paramètres "qui lui vont bien", sous la forme de

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
class SyntaxError : public Exception
{
    public:
        /* Pour respecter la forme envisagée, il nous faut comme paramètres:
         * - un nom de variable (trucmuche)
         * - un message "clair "( muste be blabla)
         * - un nom de fichier (facultatif)
         * - un numéro de ligne (facultatif)
         * et nous invoquons le constructeur de Exception en ne lui passant
         * que "Syntax Error" ;)
         */
        SyntaxError(std::string const & var,
                    std::string const & message,
                    std::string const & file="",/* vide par défaut */
                    size_t line = 0 /* inexistant par défaut */ ):
                    Exception("Syntax Error")
        {
            /* construction d'un flux de conversion reprenant la
             * phrase complète
             */
            std::stringstream ss;
            ss<<var<<" "<<message;
            if(file!="")
            {
                ss<<" in file "<<file;
                if(line!=0)
                    ss<<" in line "<<line;
            }
            /* qui sera assigné à mmore */
            mmore = ss.str();
        }
};

Si, plus tard, tu veux définir une exception "DivisionByZero", ce ne sera pas plus compliqué

[poukill]

Si le posteur est vraiment débutant, à mon avis il a pas compris une ligne de ce que vous racontez...
Comme l'a dit Loïc, le passage d'un nombre d'argument aléatoire n'est pas à portée de débutant...

[jimaitou]

Bonsoir,
Merci à tous pour vos contributions. Je pense les avoir toutes comprises sauf celle de koala qui est effectivement un peu trop "tricki" pour moi, désolé ;-)
Mais j'ai appris avec toutes et c'est bien là l'essentiel.

Le chemin est encore long ;-)

Merci à tous

Hervé

[koala01]

Si tu me dis quelle partie tu n'as pas compris, je me ferai un plaisir d'être plus explicite