appeler instance père

Version imprimable

05/08/2009, 16h26
os128

appeler instance père

Bonjour

J'ai un problème pour acceder a certaines classes de mon programme

J'ai un main, une classe A, une classe B
le main créer une instance de A disons a
la classe A créer une instance de B disons b.

depuis b, je veux appeler l'instance père, c'est à dire l'instance a dont b hérite.

Savez vous comment faire?

Merci d'avance.
05/08/2009, 16h40
ymoreau
Seule une classe hérite, et pas une instance. Et elle hérite d'une autre classe (et pas d'une instance non plus).

Pour utiliser un object dans un autre objet, tu dois lui passer en argument du constructeur un pointeur vers cet objet.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class A { public: a() {} }; class B { A* _pointeurVersA; public: b(A* a) : _pointeurVersA(a) {} }; A a; B b(&a);
Ensuite tu n'as qu'à utiliser la donnée membre _pointeurVersA pour utiliser a dans b.
05/08/2009, 16h47
koala01

Salut,

Il manque juste une petite information dans le cas que tu décris: la classe B hérite-t-elle de la classe A, ou hérite-t-elle d'une classe tout autre (mettons... Z) :question:

Ceci dit, tu devrais retrouver, dans ta classe B, l'interface publique (AKA: tous les membres et fonctions membres) de la classe dont B hérite.

De prime abord, il n'y a donc finalement aucun problème dans le sens fille->mere (dérivée->base), ou du moinss, il ne devrait pas y en avoir...

Le problème est beaucoup plus pointu lorsqu'il s'agit, en disposant d'un objet qui "se fait passer" pour un objet de la classe mère, de récupérer quelque chose qui fait partie de l'interface propre à l'objet enfant ;)

Dans ce cas, il s'agit de recourir au "downcasting", à coup de static_cast / dynamic_cast, et c'est souvent le signe d'un défaut de conception ;)

Au fait... Il existe ce que l'on appelle le Principe de Substitution de Liskov (souvent abrégé en LSP, du terme anglais correspondant) qui dit que, pour qu'une classe puisse dériver d'une autre, il faut que toutes les propriétés qui sont valables pour la classe mère soient aussi valables pour la classe fille...

Bien sur, la classe fille peut avoir des propriétés supplémentaires par rapport à la classe mère, mais pas l'inverse ;)

En définitive, si, lors d'un héritage public (la fameuse relation "est-un / Is A" ), tu te trouve dans le cas où la classe fille n'a pas toutes les propriétés de la classe mère, ce qui serait le seul cas qui justifierait ta question, c'est que, là aussi, tu es sans doute confronté à un problème de conception ;)

Hope it helps ;)
05/08/2009, 16h55
koala01

Ouppsss, je me suis laissé berner par le mot "hérite"...

Effectivement, si tu veux garder une référence vers l'instance d'un objet qui a créé un autre au sein de l'objet créé, le recours à un pointeur est souvent nécessaire dans l'objet créé.

Il faut alors être particulièrement attentif à l'ordre dans lequel les différents objets seront détruits ou, s'ils sont créé sans avoir recours à l'allocation dynamique, à l'endroit où l'on quitte la portée dans laquelle une variable est déclarée.

Il est en effet très facile d'en arriver à avoir un pointeur vers l'objet "créateur" qui pointe vers... une adresse qui n'est plus utilisée (ou pire, utilisée pour autre chose ;))
05/08/2009, 20h25
nikko34
Pour YoniBlond: tu n'es pas obligé d'utiliser des pointeurs
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class A { public: A() {} }; class B { A & a_; public: B(A & a) : a_(a) {} }; int main() { A a; B b(a); }
Du coup tu peux mettre une contrainte const.
05/08/2009, 21h08
koala01

Citation:

Envoyé par nikko34

Pour YoniBlond: tu n'es pas obligé d'utiliser des pointeurs

En fait, tout dépend des relations qui existent entre les deux objets...

Si tu n'as qu'une relation à "sens unique" (de b vers a), tu peux, effectivement, utiliser une référence.

Par contre, si la relation s'effectue dans les deux sens (conteneur <==> contenu), tu n'aura d'autre choix que d'utiliser un pointeur vers le conteneur dans le contenu ;)
06/08/2009, 11h12
Pragmateek
Citation:

Par contre, si la relation s'effectue dans les deux sens (conteneur <==> contenu), tu n'aura d'autre choix que d'utiliser un pointeur vers le conteneur dans le contenu

Aurais-tu un exemple où c'est le cas ?

Parce que ce code semble valide :
Code:

1 2 3 4 5 6 7 8 9 10 11 class B; class A { B& b; }; class B { A& a; };
Merci.
06/08/2009, 12h59
JulienDuSud
Citation:
Envoyé par seriousme

Aurais-tu un exemple où c'est le cas ?

Parce que ce code semble valide :

Code:

1 2 3 4 5 6 7 8 9 10 11 class B; class A { B& b; }; class B { A& a; };

Merci.
Les références membres doivent être initialisées au moment de l'initialisation de l'objet. Or, si 2 objets doivent se référencer, il faut qu'au moins l'un des 2 objets existe déjà. Du coup, l'objet créer en premier ne pourra pas référencer le 2ème objet à créer.

Mais, un pointeur peut être initialisé à une valeur quelconque, NULL inclu. Donc, il suffit d'initialiser le 1er objet, de là initialiser le 2nd (le 2nd pourra contenir une référence sur le 1er) et ensuite d'assigner le pointeur du 1er sur l'instance du 2nd (mais pas une référence, car les références ne peuvent être initialisées à NULL, et ne sont pas dynamique quant à l'objet qu'ils référencent).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class MyContainer;
class MyContent
{
    public:
        MyContent(MyContainer & ct):ct_(ct){}
    private:
    MyContainer & ct_; /*ooops on demande à quelque chose de "petit
                                    * de disposer d'une référence vers quelque
                                    * chose qui est indéniablement plus grand
                                    * que lui
                                    */
};
class MyContainer
{
    std::vector<MyContent> items_;
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
class MyContainer;
class MyContent
{
    public:
        MyContent(MyContainer & ct):ct_(ct){}
    private:
    MyContainer & ct_; 
};
class MyContainer
{
    MyContent& ctt_;
};

sera refusé pour les raisons indiquées par Julien ;)
par contre, les deux situations sont acceptées si MyContainer est représenté sous la forme d'un pointeur dans MyContent car... il peut être
null et qu'un pointeur a toujours la même taille, quel que soit le type de l'objet vers lequel il pointe (équivalent généralement un size_t ou un unsigned long)

En effet, de facto c'est le cas, mais étant donné que les références sont implémentées via des pointeurs le compilateur pourrait bien interpréter :
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 B; class A { public: int n; public: A(B& b) : b(b) { } public: B& b; }; class B { public: B(A& a) : a(a) { } public: A& a; }; int main(void) { A a(B(a)); }
En fait ce code compile mais ne donne pas le résultat attendu : il considère que "A a(B(a))" est la déclaration d'une fonction.

06/08/2009, 14h25
koala01

Citation:

Envoyé par seriousme

En fait ce code compile

Le réglage du compilateur (ou son implémentation) est peut être un peu trop permissif ;)

Citation:

mais ne donne pas le résultat attendu : il considère que "A a(B(a))" est la déclaration d'une fonction.

Disons plutôt qu'il ne donne pas le résultat que tu croyais obtenir ou que tu espérais ;)
06/08/2009, 14h39
Pragmateek

Citation:

Le réglage du compilateur (ou son implémentation) est peut être un peu trop permissif

g++ 4.3.2 avec les flags -Wall -Wextra.

Citation:

Disons plutôt qu'il ne donne pas le résultat que tu croyais obtenir ou que tu espérais

En effet ;)
06/08/2009, 16h48
os128
Bonjour

Excusez moi de vous répondre si tard. Je vous remercie de vos réponses.

Le but est de faire communiquer les 2 classes A et B. Faire hériter B de A pourrait marcher, mais visiblement je ne peux meme pas faire hériter B d'une classe C qui n'a rien à voir, pourtant j'utilise la bonne synthaxe
Code:

1 2 class ClasseB:public ClasseC
La classe C est pourtant bien incluse dans le projet.

Dire que je croyait betement que c'était à cause des doubles inclusions
A inclut dans B
et B inclut dans A

Dans tous les cas, Merci à tous
06/08/2009, 16h57
os128

ps

pour la classe C, c'était parce qu comme un con j'avais pas mis l'include C dans le B.h, n'empeche que le compilateur n'aime quand meme pas les inclusions multiples
06/08/2009, 17h21
koala01

Fais attention au fait que l'héritage est la relation la plus forte qui puisse exister entre deux classes...

A ce titre, tu ne peux réellement l'envisager que s'il est sémantiquement correct de dire que la classe B est une classe A "particulière" (cf ma première intervention et LSP).

Et encore, pour pouvoir faire communiquer une instance de la classe A avec une autre instance de la classe B (ou deux instances différentes de la classe A ou encore deux instances de la classe B entre elles), il faut qu'au moment où la communication est nécessaire l'appelant dispose... d'un moyen d'accéder à l'appeler, soit parce qu'il aura été transmis comme argument d'une fonction, soit parce qu'il dispose d'un membre relié à lui ;)