Discussion :

[coyotte507]

Bonjour!

En fait j'ai des tas de problèmes...

Dans ma classe dérivée j'ai plusieurs constructeurs. Chacun appelle automatiquement le constructeur de base (c'est pas de ma faute c'est le compilo qui fait ça). De plus, ils appellent tous le constructeur principal de la classe dérivée, qui fait lui-même un appel spécial au constructeur de base:

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
 
//Exemple
 
class Windows : public OS
{
  public:
    Windows(int, float);
    Windows(float, int);
}
 
//constructeur principal
Windows::Windows (int a, float b)
{
  /*
    ....
    Est tout le temps appelé car fait l'initialisation
    des membres de la classe
  */
 
  //appelle le constructeur de la classe de base avec certains paramètres
   OS(/* ...*/);
}
 
//constructeur secondaire
Windows::Windows (float a, int b)
{
  /*
    ....
  */
 
  //appelle le constructeur principal de la classe dérivée
   Windows(/* ...*/);
}

Existe - t - il un moyen de limiter les appels au constructeur de la classe de base? La si j'appelle le deuxième constructeur de Windows, j'ai trois appels au constructeur de base...

[hiko-seijuro]

Pourquoi ne pas utiliser les listes d'initialisation ?

et je pense que ta méthode est douteuse vis a vis des constructeurs car quand appel un constructeur conceptuellement cela créé l'objet donc un constructeur d'un objet qui appel un autre constructeur d'un meme objet ca équivaut dire à un macon d'appeler un autre macon pour construire la maison :s

[Zavonen]

Dans la définition d'un constructeur on peut faire un appel explicite à un constructeur d'une classe parente avec passage de paramètres immédiatement après la liste des paramètres au moyen de l'opérateur :
Le truc est récursif de sorte que chaque constructeur fait son boulot et rien que son boulot (en général initialiser les variables qui sont propres à sa classe)
exemple:

Si la classe CEtudiant est fille de CCitoyen

CEtudiant::CEtudiant(char * N, char * P, int X):CCitoyen(N,P)
{Numero=X;}

Pour le reste même remarque que la précédente concernant un constructeur appelant un autre constructeur de la même classe.

[coyotte507]

en fait c'est juste un autre constructeur qui utilise une va_list (voir stdarg)

L'un est appelé avec dess arguments multiples (...), l'autre avec une liste d'arguments (va_list)

Le deuxième convertit juste les arguments en liste d'arguments pour le premier constructeur.

Sinon pour la liste d'intialistaion, je vais y penser, mais ce n'est pas possible pour le constructeur à arguments multiples (...) et ça ne résout pas le problème de l'appel d'un constructeur de la même classe.

Ce que je voudrait c'est savoir si il est possible d'empecher au compilateur d'appeler automatiquement le constructeur de la classe de base

[Zavonen]

Par défaut, cest le constructeur par défaut de la classe mère qui est appelé.
De sorte que si vos constructeurs par défaut ne font rien (en dehors d'une réservation mémoire évidemment), les appels en série ne feront rien (qu'une réservation d'espace) et c'est un moindre mal nécessaire de toutes façons.

[Laurent Gomila]

Il faut obligatoirement appeler un constructeur de la classe de base (elle doit bien être construite !).

Ce que tu sembles ne pas savoir, c'est que cet appel doit obligatoirement être fait dans la liste d'initialisation, et que tout appel à un constructeur par la suite ne fera pas ce à quoi tu t'attends : cela va construire un nouvel objet temporaire puis le supprimer aussi sec ; absoluement aucun effet sur ton instance donc.

[koala01]

Salut,

Déjà, de manière générale, l'utilisation d'une va_list n'est clairement pas conseillée, et elle l'est encore moins en ce qui concerne le constructeur.

Il faut bien comprendre qu'un constructeur, ca permet d'initialiser un objet, et que, en gros, ca se fait en trois étapes:

• trouver un endroit en mémoire où l'on a la place suffisante pour tout mettre (sur la pile ou sur le tas, en fonction de si on utilise new ou non)
• trouver les adresses, dans l'espace mémoire fournis, auxquelles commencent les différentes variables qui composent l'objet
• fournir une valeur à ces variables

Ensuite, je conçois mal que l'on puisse faire une pate à crepes, ou construire une maison, sans avoir une idée précise de ce que l'on va mettre dans la pate ou du matériaux que l'on va utiliser pour la maison...

Pourquoi faire différemment en programmation

Au pire, rien ne t'empeche de prévoir plusieurs constructeurs distincts:

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
 
class MaClasse
{
    public:
        MaClasse():                 /* constructeur par défaut, toutes les 
        _name("unnamed"){}           * valeurs sont nulles  ou prédéterminées */
        MaClasse(const std::string& nom):/* juste le nom est donné, les autres
        _name(nom){}                      * valeurs sont nulles ou
                                          * prédéterminées */
        MaClasse(const std::string& nom, int i):/* seul j est prédéterminé, on
        _name(nom)                                * fournit un seul "i" */
        {
             _i.push_back(i);
        }
        MaClasse(const std::string& nom, int i, float j);/* un seul i et 
        _name(nom)                                        * un seul j*/
        {
            _i.push_back(i);
            _j.push_back(j);
        }
        MaClasse(const std::string& nom, std::vector<int> tabi, 
                 std::vector<float> tabj):/* plusieurs "i" et plusieurs "j" */
        _name(nom),_i(tabi),_j(tabj){}
        /* le reste (pourquoi pas d'autres constructeurs si besoin ? */
    private:
        std::string _name;
        std::vector<int> _i;
        std::vector<float> _j;
        /* le reste */
};

Une fois que tu as prévu l'ensemble des possibilités de construction de ta classe de base, rien ne t'empeche d'utiliser le constructeur de cette classe "qui va bien" dans les classes dérivée, en fonction des besoin

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
 
class Deriv1: public Maclasse
{
    public:
        Deriv1(const std::string& nom, const std::string& type):Maclasse(nom)
        _type(type){}
    private:
        std::string _type;
};
class Deriv2:public MaClasse
{
    public:
        Deriv2(const std::string& nom, int i, float j, double d):
            MaClasse(nom, i, j), _d(d){/* "surplus éventuel" */}
    private:
       double _d;
};
class Deriv3:public MaClasse
{
    public:
        Deriv3(const std::string& nom, std::vector<int> tabi, 
        std::vector<float> tabj, std::vector<std::string> s):
            Maclasse(nom, tabi,tabj),_s(s){/* "surplus" éventuel */}
    private:
        std::vector<std::string> _s;
};

et, s'il se fait que les informations recues - quelle que soit l'origine, mais, de manière générale, via la ligne de commande - sont susceptibles d'être fournies dans le désordre, il s'agira de vérifier ces informations avant l'appel du constructeur, afin, principalement, de s'assurer qu'elles soient valides...