Héritage sur 2 classes CDialog?

Version imprimable

Bonjour,
je dispose de 2 classes héritant de CDialog. Elles sont pratiquement identiques sauf leur boîte de dialogue. Peut-on faire un héritage intermédiaire? Sinon, quelle meilleure architecture à adopter?

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
 
class CMyDial : public CDialog
{
  enum { IDD = IDD_MyDial};
  void set();
  void setTracker();
  void setDisplay();
{{AFX_VIRTUAL(CMyDial )
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	virtual BOOL OnInitDialog();
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
	afx_msg void OnPaint();
	afx_msg void OnSize(UINT nType, int cx, int cy);
	afx_msg void OnMove(int x, int y);*/
	//}}AFX_VIRTUAL
}
 
class CMyDial1 : public CDialog
{
  enum { IDD = IDD_MyDial1};
  void set();
  void setTracker();
  void setDisplay();
 
{{AFX_VIRTUAL(CMyDial )
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	virtual BOOL OnInitDialog();
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
	afx_msg void OnPaint();
	afx_msg void OnSize(UINT nType, int cx, int cy);
	afx_msg void OnMove(int x, int y);*/
	//}}AFX_VIRTUAL
}

Merci

27/11/2009, 17h23
koala01
Salut,

Le fait est que, lorsque deux classes ont une même classe de base et qu'une quatirème classe doit hériter des deux première, tu te trouve dans une situation que l'on appelle "l'héritage en diamant" (en fait, ici, c'est plutot en losange :P):
Code:

1 2 3 4 5 6 7 Base / \ / \ Derivee1 Derivee2 \ / \ / Derivee3
et que cette situation est rarement intéressante du fait des conflits qu'elle risque d'engendrer (quand on veut travailler sur Base, on travaille avec Derivee1::Base ou avec Derivee2::Base... ou doit-ce être la même base :question:) ou du fait de la nécessité de déclarer l'héritage de de Derivee1 et de Derivee2 vis à vis de Base virtuel, ce qui apporte également son lot de problèmes.

Si donc, l'idée que tu as en tête est de créer une troisième boite de dialogue qui contient simplement les deux autres, le mieux est, sans doute, de:
1. Faire en sorte que les classes que tu as appelé CMyDial et CMyDial1 soient en réalité considérés comme... des composant de ta boite de dialogue
2. Créer des boites de dialogue permettant d'utiliser ces deux composants personnalisés de manière autonome
3. Créer une boite de dialogue contenant les deux composant personnalisés, placés selon ton gout
Mais nous partons alors sur une aggrégation, et non plus sur un héritage (hormis l'hértiage unique de la troisième boite de dialogue qui hérite directement de CDialogue et non plus de CMyDial ni de CMyDial1) ;)
27/11/2009, 17h39
neonico
L'idée était plutôt de faire cela...
Code:

1 2 3 4 5 6 7 8 9 CDialog | | CMyDialType / \ / \ CMyDial1 CMyDial2
Mais la ressource crée dans CtypeDial ne sert donc à rien... Toutes les fonctions sont définies dans CMyDialType. Seules résident dans les classes CMyDialx constructeur, destructeur, et déclaration de l'ID de ma dialog. Ca passe cela?

Merci
27/11/2009, 18h13
koala01
Ouppsss... Au temps pour moi...

Mais, sur base de l'explication et du code fourni, je me suis quelque peu fourvoyé :P

Il n'y a, a priori, aucune restriction quant au fait de faire dériver une classe d'une autre qui, elle-même, dérive d'une troisième classe que nous pouvons considérer comme ancêtre.

Et cela peut même, d'après la norme, aller encore beaucoup plus loin car la norme préconise, pour les compilateurs qui la respectent, de supporter au minimum 1024 classe de base directes et 16384 classes de bases directe et indirectes pour une seule classe...

Tu vois donc qu'il est tout à fait possible de donner libre cours à ta folie de l'héritage :D (d'autant plus qu'il s'agit ici... de minimum, et que ton compilateur peut en supporter d'avantage ;))

Mais, si j'ai écris "a priori" au début de ma réponse, ce n'est pas anodin, car il y a d'autres paramètres à prendre en compte avant de décider de le faire...

de manière non exhaustive, nous pouvons citer:
- Que t'apporterait le fait de faire dériver une classe "générique" de CDialog et de faire dériver tes classes utiles de cette classe :question: En d'autre termes, pourquoi ne pas faire, directement dériver boites de dialogue de... CDialog :question:
- Le fait d'avoir une hiérarchie d'héritage trop "profonde" a tendance à rendre les choses vraiment complexes, tant à l'utilisation (puis-je utiliser un pointeur Mere1 dans mon cas ou dois-je utiliser un pointeur ArriereArriereArrriereGrandMere, pour être sur que la conversion soit envisageable, et, surtout, pour avoir accès aux comportements qui m'intéressent :question:)
- D'aucun estiment (avec raison) qu'au delà de trois niveau d'héritage, cela devient réellement du superflu
- La bibliothèque IHM que tu utilise (vu que c'est la situation que tu dépeint) accepte-t-elle que l'on fasse hériter une classe d'une autre classe qui, elle-même, hérite d'une classe de cette biblitohèque :question:
- et j'en oublie surement
Tout cela pour dire que, oui, tu peux le faire, mais... il y a un grand MAIS à prendre en compte avant de te donner une réponse définitive ;)

Et, je ne dispose pas actuellement des informations qui me permettent d'évaluer sereinement les implications de ce MAIS ;)

Merci Koala

Code:

Que t'apporterait le fait de faire dériver une classe "générique" de CDialog et de faire dériver tes classes utiles de cette classe En d'autre termes, pourquoi ne pas faire, directement dériver boites de dialogue de... CDialog

Je reviens au fait que l'idée est que ce qui diffère mes classes filles l'une de l'autre est simplement la ressource graphique... les fonctionnalités sont les mêmes. Donc dériver mes filles de CDialog reviendrait à pratiquemenht faire du copier coller de l'une par rapport à l'autre, avec ce qui diffère la ressource graphique. Je veux donc passer par une classe intérmédiaire pour factoriser cela.
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 42 43 44 45 46 class CMyDialType : public CDialog { enum { IDD = IDD_MyDialType}; void set(); void setTracker(); void setDisplay(); {{AFX_VIRTUAL(CMyDial ) protected: virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support virtual BOOL OnInitDialog(); afx_msg void OnLButtonDown(UINT nFlags, CPoint point); afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message); afx_msg void OnPaint(); afx_msg void OnSize(UINT nType, int cx, int cy); afx_msg void OnMove(int x, int y);*/ //}}AFX_VIRTUAL } class CMyDial1 : public CMyDialType { enum { IDD = IDD_MyDial1}; CMyDial1(); ~CMyDial1(); } class CMyDial2 : public CMyDialType { enum { IDD = IDD_MyDial2}; CMyDial2(); ~CMyDial2(); } void main() { CMyDial2 *mydial2 = new CMyDial2(); mydial2->setTracker(); CMyDial1 *mydial1 = new CMyDial1(); mydial1->setTracker(); }
Ce code a t'il du sens?

Ou alors on opte pour une solution plus simple maos lourde, ie
Code:

1 2 3 4 5 CDialog / \ / \ CMyDial1 CMyDial2

Mais, alors, ne pourrait on pas envisager le fait que la ressource graphique n'est en réalité que... du détail d'implémentation, qui pourrait parfaitement être géré dans une classe unique, en fonction d'un argument supplémentaire fournit au constructeur :question:

Je m'explique...

tu va te trouver face à la situation (je laisse volontairement l'héritage sur le coté) proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class MyDial1 { publilc: MyDial1():someStuff(new SomeStuff) { } private: SomeStuff* stuff; }; class MyDial2 { public: MyDial1():stuff(new OtherStuff) { } private: OtherStuff * stuff; };
Dés lors, étant donné que SomeStuff et OtherStuff ont des comportements, finalement, fort similaire, pourquoi ne pas envisager que ces deux classe aient des comportement polymorphes, grace à un héritage commun :question:
Cela te donnerait un résultat proche de
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 class BaseStuff /* : public CElement */ { public: BaseStuff(/*...*/){} virtual ~BaseStuff(); }; class SomeStuff : public BaseStuff { }; class OtherStuff : public BaseStuff { }; /* enum eStuffType { stSome, stOther }; */ class MyDial : public CDialog { public: MyDial(eStuffType s): stuff(s==stSome? new SomeStuff : new OtherStuff){} private: BaseStuff * stuff; };