Discussion :

[rolkA]

Bonjour !
J'espère que quelqu'un pourra m'aider car j'ai le don de m'empêtrer dans des situations compliquées et cette fois j'arrive pas à en sortir.

Situation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class Erreur
{
    public:
        Erreur(const char* szMessage, ...); // implémenté
}
 
class ErreurFille : public Erreur
{
    public:
        ErreurFille(int iCode, const char* szMessage, ...); // comment construire le père ?
}

Problème:

Comme il s'agit d'une relation d'héritage, le constructeur du père doit être appelé dans la liste d'initialisation du constructeur du fils. Or à ce moment là, je ne connais pas encore la liste des arguments effectivement passés au constructeur fils.

Y a-t-il une façon de faire sans abandonner la hiérarchie entre les deux classes ?

Merci d'avance ;-)

[tut]

les paramètres qui suivent sont-ils tous des const char* ?

[rolkA]

les paramètres qui suivent sont-ils tous des const char* ?

non, ils dépendent de ce qu'il y a dans szMessage. C'est comme la syntaxe de la fonction printf du C.

[tut]

t'es vraiment obligé d'utiliser une liste de paramètres ?
une référence sur un conteneur (vector, list, etc...) contenant des objets d'une classe de base abstraite pourrait peut-être être une solution.
Après, tu peux utiliser le polymorphisme, ou au pire les RTTI pour retrouver tes types.

[rolkA]

Merci je vais y réfléchir

[Aurelien.Regat-Barrel]

Oui, une liste variable d'arg c'est pas terrible, surtout pour uen classe de gestion d'erreur. Y'a plusieurs possibilités. Tu peux utiliser une approche à la Qt et te faire un string builder du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class StrBuilder
{
public:
    StrBuilder( string Format );
 
    StrBuilder & arg( int );
    StrBuilder & arg( double );
    StrBuilder & arg( string );
 
    string str();
};
 
StrBuilder( "Nombre1=%1, Nombre2=%2" ).arg( 10 ).arg( 20.0 );

L'appel à arg() cherche la première occurence à % et la remplace par le type fourni en paramètre. C'est pratique et type safe. Avec une fonction arg() template ca doit même être simple à faire.

[Aurelien.Regat-Barrel]

Exemple pondu a la va vite :

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
33
34
35
36
37
38
39
40
41
class StrBuilder
{
public:
    StrBuilder( string Format ) : format( Format), nb_args( 0 ) {};
 
    template<typename T>
    StrBuilder & arg( T Val )
    {
        ostringstream motif;
        motif << '{' << this->nb_args << '}';
 
        ostringstream val;
        val << Val;
 
        size_t pos = this->format.find( motif.str() );
        if ( pos != string::npos )
        {
            this->format.replace(
                pos,
                motif.str().size(),
                val.str() );
            ++this->nb_args;
        }
        return *this;
    }
 
    string str() const
    {
        return this->format;
    }
 
private:
    string format;
    int nb_args;
};
 
int main( int argc, char ** argv )
{
    cout << StrBuilder( "Nombre1={0}, Nombre2={1}" ).arg( 10 ).arg( 20.0 ).str();
    return 0;
}

J'ai plutot utilisé la notation .Net pour les portions à remplacer.

Cela dit apres réflexion en C++ on utilise plutot directement ostringstream. Personnelement c'est ce que je fais pour ma gestion d'exception :

Code :

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

1
2
3
4
5
6
7
 
if ( erreur )
{
    ostringstream oss;
    oss << "Erreur ligne " << __LINE__ << " : blablabla";
    Erreur( oss.str() );
}

[rolkA]

Merci à vous deux d'avoir répondu aussi vite, je n'avais pas pensé à l'ostringstream

et A+