Discussion :

[Lavock]

Bonjour à tous (ça faisait longtemps ><) !

En dehors de tout problème de design, pourquoi :

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 A {};
 
Class B : A {
public:
  operator A() { // Mais quelle utilité me direz-vous ??
    return *static_cast<A*>(this);
  }
};
 
int main() {
  B b;
  A(b); 
  return 0;
}

Me renvoie boulet méchamment en clamant au scandale parce que mon héritage est privé ?
Honnêtement, ça m'a étonné. Je pensais qu'au pire, il arriverait pas à trouver ce qu'il faut faire... mais là !

J'ai un peu cherché dans la norme, mais j'ai rien trouvé... Même pas un comportement indéfinie.... :'( !

Merci de m'éclairer de vos illustres lumières

[koala01]

Salut,

Tu semble oublier qu'un héritage privé n'a pas du tout la même sémantique qu'un héritage public.

L'héritage public est une relation EST-UN, au sens sémantique du terme (une voiture EST-UN véhicule), alors que l'héritage public est une relation "est implémenté en terme de", et se rapproche fortement d'une... agrégation.

Tu ne peux donc pas te baser sur le moindre raisonnement qui serait valable pour des objets polymorphes

[Lavock]

Je comprend ce que tu dis, mais je vois pas bien en quoi ça répond... En faite, je m'attendais bêtement a ce que le compilateur fasse le cast à l'aide de l'opérateur de conversion... Pas qu'il tente un upcast impossible.

Aussi, en ce qui concerne la semantique, permet moi de m'auto-cité :

[...] En dehors de tout problème de design, [...]

PS : si je me plante pas, le seul intêret d'un héritage privé sur une agrégation, c'est qu'il permet l'upcast en interne non ?

[Jean-Marc.Bourguet]

L'accessibilité ne joue aucun rôle dans la résolution de surcharge et dans l'introduction des conversions implicites, elle détermine juste la validité du choix fait. On détermine donc ici qu'il s'agit d'une base et comme elle n'est pas accessible, c'est une erreur, on ne cherche pas des moyens plus détournés pour rendre l'expression valide.

[3DArchi]

Assez peu d'intérêt mais :

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
42
43
class A {};
 
class B : private A {
public:
   operator A&() {
      return *this;
   }
 
   operator A const&() const{
      return *this;
   }
   A getA()const
   {
       return *this;
   }
   operator A() const
   {
      return *this;
   }
};
void fonction(A&)
{}
void cfonction(A const &)
{}
void vfonction(A)
{}
 
int main() {
   B b;
   A ra = (A&)b;
   A const & rca = (A const&)b;
   A ca = b.getA();
   A ca2 = b.B::operator A();
   //  fonction(b);// erreur
   fonction((A&)b);
   //  cfonction(b);// erreur
   cfonction((A const&)b);
 
   //  vfonction(b);// erreur
   vfonction(b.getA());
 
   return 0;
}

[koala01]

A vrai dire, j'en suis presque à me demander quel peut être réellement l'intérêt d'un héritage privé.

A part le fait de pouvoir accéder, depuis les fonctions de la classe dérivée, à tout ce qui est publique ou (ou plutôt "et surtout") protégé dans la classe de base sans devoir fournir le membre auquel cela se rapporte (ce qui peut, effectivement, avoir quelques avantages), c'est plutôt limité, non

[Jean-Marc.Bourguet]

A vrai dire, j'en suis presque à me demander quel peut être réellement l'intérêt d'un héritage privé.

Tu compares à quoi?

Deux choses qu'il est difficile de faire sans héritage privé:
- être initialisé avant une base publique (pour pouvoir passer un pointeur vers ce sous-objet au constructeur de la base publique; quand c'est nécessaire, je ne vois pas comment faire autrement)
- supplanter des membres virtuels (on peut introduire une classe supplémentaire, la rendre friend et avoir des pointeurs croisés...)

Si tu cherches dans les archives, il me semble qu'on en avait déjà discuté.

[Lavock]

Effectivement, un cast c-style marche dans se cas... J'hésite souvent à l'utiliser, peur de reinterpret_cast.

Au passage, je pensais que l'opérateur de conversion s'appelait explicitement par le static_cast. Je me trompe donc ?