Heritage avec constructeur sans parametres

**Panaméen** · 12/09/2008, 20h50

Bonjour

Jai un soucis , pouvez vous maider , je vous laisse voir le code

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
 
//main:
 
ALAN *Mon_Alan;
AL *Mon_Al;
AN *Mon_An;
 
Mon_Alan = new ALAN;
Mon_Al = new AL;
Mon_An = new AN;
 
 
//les classes :
 
class M
{
        public :
                M(){};
                ~M(){};
};
 
// M est la mère de ALAN !!!
// or ALAN est relié a R et P par compo bi et directionnelle ... 
 
class ALAN: public M
{
        private :
        // pas visible par les fils !!!
                R*m_pt_r;
                P*m_pt_p;
        public :
                ALAN();
                ~ALAN();
};
 
 
ALAN:: ALAN()
{
        m_pt_r= new R;
        m_pt_r->set_m_pt_alan(this);
        m_pt_p = new P;
}
ALAN:: ~ALAN()
{
}
 
 
// et ALAN est la mère de AL et AN 
 
class AN : public ALAN
{
        public :
                AN(){};
                ~AN{}();
};
class AL : public ALAN
{
        public :
                AL(){};
                ~AL(){};
};
 
 
class P
{
        public :
                P(){};
                ~P(){};
};
class R
{
        protected :
                ALAN*m_pt_alan;
                bool m_instanciation;
        public :
                R();
                ~R();
                void set_m_pt_alan(ALAN*);
                bool Tester_Instanciation();
                bool Tester_Bidirection();
};
R:: R()
{
        m_pt_alan = 0;
        m_instanciation = true;
}
R:: ~R()
{
        m_instanciation = false;
}
void R:: set_m_pt_alan(ALAN*m_pt_alan)
{
        if (Tester_Instanciation() ==1 && Tester_Bidirection() ==0)
        {
                this->m_pt_alan=m_pt_alan;
        }
}
bool R:: Tester_Bidirection()
{
        bool test = false;
        if (m_pt_alan != 0 ) test = true;
        return test;
}
bool R:: Tester_Instanciation()
{
        bool test = false;
        if ( m_instanciation != 0 ) test = true;
        return test;
}

ALAN crée R et P ok !!!
Le main crée ensuite ses filles , AL et AN , et le problème , c'est que en fait à la construction de celle-ci le contructeur de M puis ALAN sont appellés ce qui provoque lappel celui de R voila le probleme ...

Comment eviter ca ?
Qu'estce qui ne va pas dans mon code et/ou mes relations ?

Merci par avance ... je bug complet sur le sujet

**henderson** · 13/09/2008, 10h39

Salut !

En dérivant de TObject on dispose de la méthode ClassNameIs.

Donc on aurait ce contexte là :

M : public TObject
ALAN : public M
AN : public ALAN
AL : public ALAN
R : public TObject
P : public TObject

La classe R n'a plus besoin de grand chose sauf du lien :
public :
ALAN *Alan;

Donc dans le constructeur de ALAN on aurait quelque chose comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
bool alan = ClassNameIs("ALAN");
if(alan)
    {
    pR = new R;
    pR->Alan = this;
    pP = new P;
    }
else
    {
    //donc n'est pas ALAN mais, à ce stade, AL ou AN selon ...
    }

Sans doute ne pas oublier dans le destructeur de ALAN de détruire les objets qu'il aura créés :

Code :

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

1
2
3
 
delete pR;
delete pP;

J'espère quand même avoir tout compris !

Sinon, à défaut de pouvoir utiliser TOBject comme classe de base, on peut toujours passer un paramètre au niveau constructeur...

A plus !

**Panaméen** · 13/09/2008, 13h17

Je ne veux pas utliser les classes Builder dsl

**henderson** · 13/09/2008, 14h49

Salut !

Autre solution est de donner deux constructeurs à ALAN

Code :

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

1
2
3
4
5
 
//Coté utilisateur
ALAN();
//Coté concepteur
ALAN(bool dummy);

Les constructeurs peuvent êtres montés comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
ALAN::ALAN() : M()
{
//Faire ce qu'il y a à faire
}
 
ALAN::ALAN(bool dummy) : M()
{
//Est sollicité par les classes dérivées AL et AN
//Donc dans ton cas, on n'y fait rien
}

On impose ici aux classes dérivées AL et AN de solliciter le deuxième constructeur dont le paramètre dummy ne sert à rien sauf à distinguer les deux constructeurs.

Code :

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

1
2
3
4
5
6
7
8
 
AL::AL() : ALAN(false)
{
}
 
AN::AN() : ALAN(false)
{
}

Je ne connais pas d'autre astuce !
Donc en attendant d'avoir une plus belle solution !

A plus !

**henderson** · 13/09/2008, 18h08

Salut !

Un petit détail supplémentaire au cas où l'on soit dans l'obligation d'interdire l'usage du second constructeur... donc avec paramètre (du point de vue de l'utilisateur) :

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
 
 
// chez moi AL et AN sont rédigées après ALAN donc...
class AN;
class AL;
 
class ALAN : public M
{
// les classes AL et AN vont avoir un accès complet à cette classe 
friend class AL;
friend class AN;
 
private :
// accessible pour les classes amies
    ALAN(bool dummy);
 
public :
 
    ALAN();
    ~ALAN();
};

Dans ce cas précis, le contructeur ALAN(bool) ne sera accessible que par la classe ALAN et les deux classes amies AL et AN.
Donc l'utilisateur ne pourra utiliser que les constructeurs sans paramètres et on aura donc bien :

Code :

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

1
2
3
4
 
ALAN *Alan;
AL *Al;
AN *An;

Code :

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

1
2
3
4
 
Alan = new ALAN; // ALAN::ALAN(bool) n'est pas accessible donc...
Al = new AL;
An = new AN;

Où Alan créera pour lui-même R et P tandis que Al et An n'auront rien pu créer pour eux-mêmes.

En espérant que...

A Plus !

**Panaméen** · 13/09/2008, 18h22

Merci bcq henderson, jai lu avec atttention des posts, et je penses que ta solution est tres bonne ... je vais faire comme ceci

je demanderais lavis de mon prof aussi.

Je ne sais pas si tu as vu aussi, j'essais de tester la bidirection et l'instanciation ... connais tu une autre methode, sans passer par les methodes builder et co' ?

Merci par avance

**henderson** · 14/09/2008, 00h22

Salut !

Pour tester la validité de la bidirection au niveau de R, il me semble que (en espérant que j'ai bien compris le truc) :

Code :

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

1
2
3
4
5
6
 
R::GetBidirection()
{
if(Alan != NULL) return(Alan->r == this);
return false;
}

A la place d'une méthode qui renvoie une valeur, peut-être qu'une propriété en lecture seule serait plus simple à utiliser (je parle pour l'utilisateur).

A plus !

**Panaméen** · 14/09/2008, 07h34

J'avou ne pas t'avoir compris.
J'ai modifier mon code mais avant je testais bidirection et instanciation dans une methode nomée test... or là je n'y suis pas arriver donc jai fait comme cela mais je cherche des autres solutions plus simple oui.

**henderson** · 14/09/2008, 10h23

Salut !

Qu'en est-il au juste de la classe R ?
Est-ce que R doit exclusivement être instanciée par ALAN ?
Au quel cas cette bidirection deviendrait facilement implicite (les deux objets se liant entre eux lors de la construction) !
Il suffirait de déclarer cette classe R dans la classe ALAN en private pour interdire toute instanciation de R hors du scope de ALAN.

A plus !

**Panaméen** · 19/09/2008, 19h35

En fait ,

Imaginons que R a une methode publique qui sappelle test ,

Je veux que dans cette methode , on teste avant si le pointeur qui appelle cette methode a bien été affecté a une adresse avec le new et l'adresse de celui qui a appellé a été envoyé a l'instance R pour la bidirection ...

Jespere avoir été clair j'espère

**henderson** · 22/09/2008, 16h43

Salut !

Pour en revenir aux classes ALAN et R en se limitant à la question initiale :
Si ALAN est une classe amie de R dotée d'un constructeur privé supplémentaire, le lien s'effectue simplement :

Code :

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

1
2
3
 
R *r; // ALAN::r
ALAN *a; // R::a

Code :

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

1
2
3
4
5
 
ALAN::ALAN()
{
r = new R(this);
}

Code :

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

1
2
3
4
5
 
R::R(ALAN *A)
{
a = A;
}

A ce stade ALAN et R sont liés à la construction et compte tenu que leurs liens sont privés, ils sont donc indissociables (je parle des instances).
L'objet ALAN est visible mais l'objet R est invisible.

Donc :

Code :

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

1
2
3
4
5
6
7
8
 
R::Test()
{
if(a != NULL)
    {
    // ici
    }
}

En fait c'est suffisant tant que l'on ne peut pas modifier le pointeur R::a !

Par contre ça peut devenir compliqué si on modifie la règle, en particulier si on rend modifiable le pointeur R::a pour faire quelque chose comme :

Code :

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

1
2
3
4
 
ALAN *A = new ALAN;
R *R1 = new R;
R1->a = A;

Dans ce cas on aurait : R1->A<->R sans parler d'éventuels AL et AN ...

Mais je trouve que ça devient un peu trop ... théorique !!!

A plus !

Heritage avec constructeur sans parametres

C++Builder

Discussions similaires

Partager

Partager