Discussion :

[Lawyer666]

Bonjour à tous,

Aujourd'hui j'ai appris qu'on ne pouvait pas faire ça :

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 Mother
{
public:
   void setAttr (const Mother& obj) {this->attr = obj.attr;}
protected:
   int attr;
};
 
 
class Daughter: public Mother
{
   int getAttr () {return this->attr;}
   void setAttr (const Mother& obj) {this->attr = obj.attr;}
};

Et je dois dire que ça me laisse un peu sur le cul...
En effet, à l'intérieur d'une classe, on peut accéder aux attribut privés d'un objet tiers si celui-ci est du type de la dite classe.
Jusqu'ici tout va bien.

Et logiquement je pensais donc qu'a l'intérieur d'une classe dérivée, on pouvait accéder aux attributs protected des objets qui étaient de type des classes mères.
Mais en fait il n'en est rien...

J'aimerais savoir s'il y a une raison à cela ?

Apparemment ca serait la faute aux inavariants... mais ça ne m'éclaire pas beaucoup étant donné que je sais à peine ce que c'est.
Si vous aviez des explications ou des liens la dessus, ça m'intéresse fortement.

Merci beaucoup.

[Médinoc]

Je n'en connais pas la raison, mais voici ma parade habituelle quand cela est nécessaire:

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Mother
{
public:
   void setAttr (const Mother& obj) {this->attr = obj.attr;}
protected:
   int attr;
   static int getAttrOf(const Mother& obj) { return obj.attr; }
};
 
 
class Daughter: public Mother
{
   int getAttr () const {return this->attr;}
   void setAttr (const Mother& obj) {this->attr = getAttrOf(obj);}
};

[Luc Hermitte]

protected te donne le droit d'accéder à tes membres dont tu as hérités. Pas à ceux de ta soeur.

[Lawyer666]

Merci à vous 2 pour vos réponses.

@ Luc Hermitte : Mais justement, j'aimerais savoir pourquoi le mot-clef private permet d'accéder aux attribut privés d'une instance soeur, et non protected ? Y a-t-il une raison particulière à cela ?
Car ce n'est pas super pratique pour surcharger l'opérateur d'affectation par exemple. Il y a effectivement la solution de Médinoc, mais ça serait quand même plus beau si on pouvait y avoir accès directement.

De plus ce que tu dis ne me parait pas tout à fait exact. En effet :

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
class Mother
{
public:
   void setAttr (const Mother& obj) {this->attr = obj.attr;}
protected:
   int attr;
};
 
 
class Daughter: public Mother
{
public:
   int getAttr () {return this->attr;}
   void setAttr (const Daughter& obj) {this->attr = obj.attr;}
};

compile. On a donc bien accès aux attributs protected des instances soeurs si ces instances sont du même type que l'objet courant.
Mais si on veut écrire un code générique en passant un objet de la classe mère en paramètre, ce n'est plus possible...

[Vespasien]

Je lis rapidement le poste mais il me semble y avoir amalgame entre fille et soeur.

[koala01]

Salut,

Déjà, je me demande quand meme pourquoi tu veux redéfinir la fonction SetAttr, alors que:

1. la classe mère dispose de cette méthode
2. la classe fille en dispose grace à l'héritage
3. tu ne prend pas la peine de spécifier qu'il s'agit d'une fonction potentiellement redéfinissable (virtuelle)
4. tu ne modifie en rien le comportement induit par la classe mere

Dans l'exemple que tu propose, il n'y a donc aucune raison de le faire, et tu n'es de toutes manières pas en position de...

Si, vraiment, le comportement devait changer en fonction de la classe fille à laquelle il se rapporte, il faudrait rendre la fonction virtuelle sous une forme sans doute proche 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
class Mother
{
    public:
        Mother(/*...*/);
        virtual ~Mother();
        virtual void setAttr(const Mother&);
};
class Daugther
{
    public:
        Daugther(/*...*/);
        virtual ~Daugther();
        virtual void setAttr(const Mother&);
};
void Daugther::setAttr(const Mother& m)
{
    /* pré traitement éventuel */
    Mother::setAttr(m);
    /* post traitement éventuel */
}

D'un autre coté, il y a peut etre lieu de se poser la question de savoir si le mutateur est réellement nécessaire, et si oui, la raison qui te force à placer l'attribut dans l'accessibilité private

[deeal]

tu as essaie de faire cela

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
 
 
class Mother
{
public:
   void setAttr (const Mother& obj) {this->attr = obj.attr;}
protected:
   int attr;
};
 
 
class Daughter: public Mother
{
public:
   int getAttr () const {return this->attr;}
   void setAttr (const Daughter& obj) {this->attr = obj.getAttr();}
};

comme tu as defini getAttr pour la classe daughter, tu peux l'utliser pour avoir un attribut protected.