Discussion :

[mickyoun]

Bonjour,

J'ai un probleme de pointeur.
A partir d'une class1, j'instancie une class2 et je voudrai passer dans la class2, un pointeur de la class1:

donc j'ai ceci:

class1.h

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
 
 
#pragma once
 
#include "class2.h"
 
class class1
{
private:
	class2 *ptr_class2;
 
public:
	class1(void)
	{
		ptr_class2 =new class2();
	}
 
	~class1(void)
	{
		delete ptr_class2;
	}
};

class2.h

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
 
 
#include "classe1.h"
 
#pragma once
 
class class2
{
	class1 *ptr_class1;
public:
	class2( class1 *ptr_class1)
	{
		this->ptr_class1=ptr_class1;
	}
 
	~class2(void){}
};

Mais j'ai une erreur

fichiers Include trop nombreux : profondeur = 1024

Code :

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

1
2
3
4
5
 
 
Le probleme vient du faite que j'inclus ce que j'ai déjà inclu.
 
Comment faire pour passer les 2 pointeurs?

[YéTeeh]

Sauf quelques erreurs de syntaxe, l'exemple compile sans problèmes chez moi. J'utilise MSVC++6. Quel compilateur utilisez-vous ?

[Laurent Gomila]

Ce problème d'inclusion cyclique arrive souvent (d'ailleurs quelques posts en parlent déjà sur ce forum). La solution c'est les déclaration anticipées :

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
#pragma once 
 
#include "class2.h" 
 
class class1 
{ 
private: 
   class2 *ptr_class2; 
 
public: 
   class1(void) 
   { 
      ptr_class2 =new class2(); 
   } 
 
   ~class1(void) 
   { 
      delete ptr_class2; 
   } 
};

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
#pragma once
 
class class1; // <- ICI
 
class class2 
{ 
   class1 *ptr_class1; 
public: 
   class2( class1 *ptr_class1) 
   { 
      this->ptr_class1=ptr_class1; 
   } 
 
   ~class2(void){} 
};

Et si tu n'as pas de code concernant ptr_class2 dans ton header, tu peux faire de meme pour déclarer class2. Et n'oublie pas d'inclure class1.h dans class2.cpp, quand même.

[mickyoun]

oui ça fonctionne

thx


Maintenant si class1 devient class1: class3

class3 étant une classe de base et class1 ça dérivé, est ce que le code fonctionne toujours?

[bjousse]

On peut aussi utiliser les #define "anti reinclusion"

par exemple, dans myinclude.h

Code :

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

1
2
3
4
5
6
7
 
#ifndef(_INC_MYINCLUDE)
#define _INC_MYINCLUDE
.....
ici tout l'include
....
#endif

puis dans les autres include/source :

Code :

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

1
2
3
4
 
#ifndef(_INC_MYINCLUDE)
#include "myinclude.h
#endif

[Laurent Gomila]

On peut aussi utiliser les #define "anti reinclusion"

C'est ce qu'il a fait avec #pragma once. Ceci-dit c'est spécifique à VC, donc effectivement la solution portable serait à préférer. Et puis ça ne règle pas le problème des inclusions cycliques à lui tout seul

Code :

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

1
2
3
#ifndef(_INC_MYINCLUDE) 
#include "myinclude.h 
#endif

Pas besoin de faire ce test à chaque fois, puisque ce même test est fait dans le header que tu inclues !

Maintenant si class1 devient class1: class3

class3 étant une classe de base et class1 ça dérivé, est ce que le code fonctionne toujours?

Oui oui ça fonctionne, si c'est toujours un pointeur sur class1 qui est membre de class2.

[mickyoun]

thx ça fonctionne

Voilà j'ai une autre erreur:

Le finchier classe1.h contient maintenant 2 classe : class4 et class1

La class 4 doit aussi avoir le pointeur de la class2.

fichier classe1.h:

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
 
#pragma once
 
#include "class2.h"
 
 
class class4
{
   private:
 
   class2 *ptr_class2;
 
   public :
     class4(class2 *ptr_class2;)
     {
          this->ptr_class2 = ptr_class2;
      }
     ~class4(){}
}
 
 
class class1 : class3
{
private:
   class2 *ptr_class2;
    class4 *ptr_class4;
 
public:
   class1(void)
   {
      ptr_class2 =new class2();
      ptr_class4 = new class4(this->ptr_class2);
   }
 
   ~class1(void)
   {
      delete ptr_class2;
      delete ptr_class4;
   }
};

Le probleme est que bizarrement , class4 ne reconnait pas le type class2

et je ne comprends pas pourquoi

[Laurent Gomila]

Moi non plus je ne comprends pas

Peut-être qu'enlever le point-virgule qui traine dans class4(class2 *ptr_class2 résoud le problème ?

Sinon, poste la ligne de code et le message d'erreur exact.

(t'es sûr que t'as besoin d'avoir des pointeurs sur tes classes dans tous les sens comme ça : ça m'a l'air tordu comme conception)

[mickyoun]

en faite, c'est pas vraiment ce code "simple" que j'utilise

C'est pour un developpement de jeu 3d d'un coté le moteur (classe1) de l'autre le GUI (classe 2) qui est l'interface graphique.

alors il faut que les 2 classes puissent communiquer.

allez un petit screen pour te convaincre



et puis une petite vidéo
http://mickyoun.free.fr/ogre/editeur...tor%20v2.1.avi

[Laurent Gomila]

Joli (marrant, tout le monde fait son GUI en ce moment, même moi )

Bon je me doutais bien que ce n'était pas le vrai code, mais ça n'empêche pas d'indiquer l'erreur exacte et la ligne correspondante