Discussion :

[KnifeOnlyI]

Bonjour,

Depuis longtemps je me suis posé la question de si on devais utiliser ou non les méthodes d'objets dans un constructeur.
Je sais que cela est autoriser par bien des langages, mais en C++, en activant une option (dont je ne me rappel plus le nom) lors de la compilation avec g++, il est déconseiller d'écrire un code comme celui-ci :

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
 
// Doit-on utiliser tous de même la liste d'initialisation ?
Lifebar::Lifebar(int max, int min): m_max(max), m_min(min)
{
    this->setMax(max);
    this->setMin(min);
 
    /*
     * Que je peut aussi écrire :
     *
     * setMax(max)
     * setMin(min)
     */
}
 
void Lifebar::setMax(int max)
{
    m_max = max;
}
 
void Lifebar::setMin(int min)
{
    m_min = min;
}

Je sais que l'utilisation du mot clé "this" n'est pas recommandé dans le constructeur car this est un pointeur sur l'instance d'objet, et dans le constructeur, il n'y a pas encore d'instance à proprement parler (c'est le but d'un constructeur).

Cependant, en retirant le mot clé this, est-ce que le compilateur fait quand même appel implicitement à lui ?

Et si oui, il parait évident qu'il ne faut pas faire appel aux méthodes dans le constructeur. Cependant, je trouve qu'on perd une partie de l’intérêt des accesseurs/mutateurs, car on duplique le code de vérification à 2 endroits différents dans le code (dans le code supposons que je ne veux pas que min et max soit inférieur à 1).

J'aimerais avoir l'avis de d'autres développeurs afin de mieux comprendre ce genre de situations.

Merci d'avance, et bonne journée !

[foetus]

Tu peux tester, mais dans un constructeur tu peux appeler une méthode de la classe.

Après, il faut voir pour une méthode virtuelle

Et sinon, il y a les méthodes inline qui correspondent souvent très bien aux accesseurs/ mutateurs

[KnifeOnlyI]

Tu peux tester, mais dans un constructeur tu peux appeler une méthode de la classe.

Après, il faut voir pour une méthode virtuelle

Et sinon, il y a les méthodes inline qui correspondent souvent très bien aux accesseurs/ mutateurs

Bien-sûr, sa fonctionne, d'ailleurs je l'utilise actuellement, seulement lorsqu'on active l'option de compilation -Weffc, celà nous indique que ce n'est pas recommandé (pourquoi je ne sais pas, je devrais lire le livre en question qui le déconseille).

Pour les inline sa reste la même réflexion, car au final, ce sont des méthodes de la classe comme les autres.

Globalement j'aimerais avoir l'avis de quelques personnes sur pourquoi sa ne serais pas recommandé ?

[dalfab]

Bonjour,

Ce qui est trompeur dans un constructeur, c'est l'appel d'une fonction virtuelle. Pour construire un objet dérivé, la fonction qui sera appelée est celle qui existe au niveau du constructeur en cours.
On pourrait alors préférer :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// on suppose ici que  Lifebar::setMax() est virtual
Lifebar::Lifebar(int max, int min): m_min(min) {
    Lifebar::setMax(max);  // lève le doute, on n'accède pas aux fonctionnalités dérivées tant que le corps de l'objet dérivé n'a pas débuté.
    this->setMax(max);     // équivalent, mais trompeur
    setMax(max);           // idem
}
void Lifebar::fonction() {
    setMax(max);           // si la setMax() est virtuelle et que fonction() est appelée après construction => appel virtuel
    this->setmax(max);     // idem
    Lifebar::setMax(max);  // empêche l'utilisation de DeriveDeLiveBar::setMax()
}

[KnifeOnlyI]

Ah, d'accord je vois mieux le pourquoi du comment alors, merci beaucoup, je passe le sujet en résolu dans ce cas.

Bonne journée à vous !