Discussion :

[dsant]

Bonjour,

Je souhaite définir une classe A dont le constructeur prends comme argument un element de type B.
Et une classe B dont le constructeur peut prendre en argument un element de type A.

La définiton tourne en rond...

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
 
class A
{
	public : 
	A(B _b)
	{ //constructeur
	}
};
 
class B
{
	public : 
	B(A _a)
	{ //constructeur
	}
};

Je ne me souvient plus quel était le mot magique qui dit au compilateur : je définirai la classe B plus tard (promis, sans fautes) ?

[Obsidian]

Bonjour,

Code C++ :

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

1
2
class A;
class B;

Tout simplement. :-)

À condition toutefois d'avoir d'autres constructeurs car avec seulement ceux-ci, tu ne parviendras jamais à instancier la première classe.

[dsant]

Je pige pas tout. J'ai ajouté tes 2 lignes au début sans succés.
Voici mon code qui ne compile pas à la ligne 11 :

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
 
class classeA
{
	public : 
		int x,y;
		classeA(int _x, int _y)
		{
			x=_x;
			y=_y;
		};
		classeA(classeB _b)
		{
			x=_b.x;
			y=_b.y;
		};
};
 
class classeB
{
	public : 
		int x,y;
		classeB(int _x, int _y)
		{
			x=_x;
			y=_y;
		};
		classeB(classeA _a)
		{
			x=_a.x;
			y=_a.y;
		};
};
 
int main(void)
{
 ;
}

Retourne : prog.cpp:11:19: error: expected ‘)’ before ‘_b’

[Bousk]

Les 2 lignes en question n'apparaissent pas est-ce normal ?
Il s'agit pourtant de la solution à ton problème : forward declaration.

[dsant]

Voici ce que ca donne avec les 2 lignes :

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
class classeA;
class classeB;
 
class classeA
{
	public : 
		int x,y;
		classeA(int _x, int _y)
		{
			x=_x;
			y=_y;
		};
		classeA(classeB _b)
		{
			x=_b.x;
			y=_b.y;
		};
};
 
 
class classeB
{
	public : 
		int x,y;
		classeB(int _x, int _y)
		{
			x=_x;
			y=_y;
		};
		classeB(classeA _a)
		{
			x=_a.x;
			y=_a.y;
		};
};
 
int main(void)
{
	;
}

Erreur à la ligne 13 :
prog.cpp: In constructor ‘classeA::classeA(classeB)’:
prog.cpp:13:3: error: ‘_b’ has incomplete type

[cob59]

Les forward-declaration ne fonctionnent que si A est utilisé comme pointeur dans la déclaration de la classe B et inversement, non ?

Par contre, est-ce qu'il n'y aurait pas moyen d'utiliser l'héritage ici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class C {
C(const C& other) : x(other.x), y(other.y) {...}
};
class A : public C {
A(const A& other) : C(other) {...}
A(const C& other) : C(other) {...}
};
class B : public C {
B(const B& other) : C(other) {...}
B(const C& other) : C(other) {...}
};

[Rewpparo]

La forward declaration dit juste "Il existe une classe nomée B, je te dirais plus tard ce qu'il y a dedans". Or pour passer un B en variable ligne 13, le compilateur a besoin de savoir notamment quelle taille fait B, la forward declaration ne lui dit pas, et il n'a pas encore parsé la définition de la classe qui est plus bas dans le fichier.
La forward declaration permet par contre de passer des références et des pointeurs. Changes ton code ainsi :

Code :

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

1
2
3
classeA(const classeB& _b)
...
classeB(const classeA& _b)

Ca devrait marcher.

EDIT : je suis d'accord avec le post du dessus. En général on essaie d'éviter les dépendances cycliques entre les classes si c'est possible, généralement en utilisant une classe de base commune. Mais c'est pas toujours faisable, a toi de voir si c'est possible dans ton contexte.