Héritage + Constructeurs avec nb variable de paramêtres

Version imprimable

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.

:arrow: Situation:
Code:

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 ? }
:arrow: 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 ;-)

30/09/2004, 10h21
tut

les paramètres qui suivent sont-ils tous des const char* ?
30/09/2004, 10h24
rolkA

Citation:

Envoyé par tut

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.
30/09/2004, 10h28
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.
30/09/2004, 10h39
rolkA

Merci je vais y réfléchir :koi:

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:

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.

Exemple pondu a la va vite :

Code:

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:

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

30/09/2004, 12h55
rolkA

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

:merci: et A+ :ccool: