Discussion :

[Nyphel]

Bonjour,

Je travaille sur 3 classes.
Si on schématise, on aurait les classes A, B et C.

La classe A va créer des objets B.
La classe A va créer des objets C.

La classe B a besoin d'accéder à la classe A.
La classe C a besoin d'accéder à la classe A.

Jusque là, ca va. J'obtiens ceci :

Classe A.h :

Code :

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

1
2
3
4
5
6
7
8
class B;
class C;
 
class A:
{	
public:
    A();
}

Classe A.cpp :

Code :

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

1
2
3
#include "A.h"
#include "B.h"
#include "C.h"

---------------------------------------------------------------

Classe B.h :

Code :

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

1
2
3
4
5
6
7
#include "A.h"
 
class B:
{	
public:
    B();
}

Classe B.cpp :

Code :

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

#include "B.h"

---------------------------------------------------------------

Classe C.h :

Code :

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

1
2
3
4
5
6
7
#include "A.h"
 
class C:
{	
public:
    C();
}

Classe C.cpp :

Code :

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

#include "C.h"

Toutefois, maintenant, j'aurais besoin que mes objets <B> puissent accéder aux objets <C> instantiés par ma classe <A>.
Exemple : objetB->createurObjetA->objetC->...

Je ne comprends pas comment faire

Si j'essaie de faire comme indiqué ci-dessus, mon compilateur me retourne une erreur du type :
"Invalid use of undefined type 'struct <C>'"

Auirez-vous une idée, s'il vous plait ?
Merci d'avance pour votre aide

[pyrrhon_]

Bonjour,

as-tu regardé cette faq ?

[mchk0123]

C'est bien de simplifier le code mais pas trop quand même, car si je le prend tel quel il n'y a aucunes raisons pour que B.h et C.h fassent un #include "A.h" !

[Nyphel]

C'est à partir de cette FAQ que j'ai fait mes classes, précisément.
Toutefois elle ne répond pas à mon problème

J'ai une solution tout simple : <A> possède des fonctions qui permettent d'acceder (get/set/...) et de modifier les variables dont j'ai besoin dans <B> et <C>.
Lorsque <B> veut modifier l'objet <C> instantié par <A>, il ne le connait pas réelement puisqu'il n'a pas eu d'include de C.h mais seulement une défnition de classe pour le compilo.

Maintenant, l'objet <B> peut appeler la fonction de <A> qui va modifier l'objet <C>.

[mchk0123]

Je ne vois pas où est ton problème :

A dépend de C : car A contient un attribut de type C
B dépend de A (et donc de C) : car B utilise une méthode de A qui lui renvoi un objet de type C

Il n'y a pas de référence croisée, à moins que tu ne nous dit pas tout.

[Nyphel]

Comme je l'ai dit dans mon premier post :

<A> crée un objet <B>. Cet objet <B> a besoin d'intervenir sur son créateur <A>.
<A> crée un objet <C>. Cet objet <C> a besoin d'intervenir sur son créateur <A>.

Ca nous fait deux références croisées, sauf si je n'ai rien compris à la FAQ
Et c'est en plus de ce méli-melo que l'objet <B> cherche à accéder à l'objet <C> créé par <A>

[Ulmo]

L'objet A peut retourner un objet B. Pour les déclarations on doit juste savoir que B existe.
=> mettre "class B;" dans le header de A
=> inclure le header de B dans le fichier source de A

L'objet B contient une référence/un pointeur sur un objet A, et éventuellement des fonctions avec A en paramètre/retour
=> mettre "class A;" dans le header de B

L'objet B utilise effectivement l'implémentation de A
=> inclure le header de A dans le fichier source de B

[mchk0123]

<A> crée un objet <B>. Cet objet <B> a besoin d'intervenir sur son créateur <A>.
<A> crée un objet <C>. Cet objet <C> a besoin d'intervenir sur son créateur <A>.

Un petit bout de code pour éclaircir tout ça ?

Car "<A> crée un objet <B>" ça veut dire une instance de B ou bien un pointeur sur instance de B ?
Et "B à besoin d'intervenir sur son créateur <A>", soit, mais ou ça (à l'intérieur d'une méthode B, à l'intérieur d'une méthode de A, ailleurs) ?

[Nyphel]

Il s'agit de pointeurs.

Les constructeurs de <B> et <C> attendent un pointeur sur un objet de type <A > comme argument, de sorte à pouvoir appeler des méthodes de l'objet <A> et modifier quelques variables de status.

[Ulmo]

À nouveau, rien de problématique. Pour utiliser un pointeur sur A, tu n'as pas besoin de savoir ce que c'est que A, tu dois juste déclarer que cette classe existe. Exemple :

A.h

Code :

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

1
2
3
4
5
6
7
8
9
10
#ifndef H_A
#define H_A
class B;
 
class A {
    ...
    B createB();
    B *createBptr();
};
#endif // H_A

A.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include "A.h"
#include "B.h"
 
...
 
B A::createB() {
    B b(this);
    return b;
}
 
B *A::createBptr() {
    return new B(this);
}

B.h

Code :

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

1
2
3
4
5
6
7
8
9
#ifndef H_B
#define H_B
class A;
 
class B {
    ...
    A *createur;
};
#endif // H_B

B.cpp

Code :

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

1
2
3
4
#include "B.h"
#include "A.h"
 
...

[Nyphel]

D'accord merci beaucoup, là je comprends mieux