Discussion :

[Mortada]

Bonjour,
J'utilse 3 classes dans un programme de la manière suivante :
la class Task:
Elle possède un pointeur sur PreviousManager

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
 
 
 
class Task : public  ProcessObject
{
protected:
 
	bool m_bIsExecuted;
	bool m_bResult;
	bool m_bLaunch;
	bool m_bIsLaunched;
	PreviousManager* m_pPrevious;
public:
	Task();
	~Task();
 
//	bool execute(){return true;};
//	bool check() {return true;};
	bool check(){return true;};
	bool execute(){return true;};
	bool getIsExecuted();
	bool getResult();
	bool getLaunch();
	bool getIsLaunched();
};

La classe PreviousManager qui est une liste de pointeurs sur Previous:

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
 
#ifndef PREVIOUSMANAGER_H_
#define PREVIOUSMANAGER_H_
 
class PreviousManager
{
private:
	vector<Previous*> m_lstListPrev;
 
public:
	PreviousManager();
	virtual ~PreviousManager();
	bool addPrev( Task* T, bool iscrit, bool cond) ;
	bool removePrev(Previous* p);
	bool checkCond(Previous * P);
};
 
#endif /*PREVIOUSMANAGER_H_*/

et enfin la classe Previous:

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
 
class Task;
 
class Previous
{
private:
	Task* m_pT;
	bool m_bIsCriteria;
	bool m_bCond;	
 
public:
	Previous();
	Previous (Task *T,bool iscrit, bool cond);
	~Previous();
 
	bool getIsCriteria();
	bool getCond();
	void setIsCriteria(bool b);
	void setCond(bool b);
	Task* getTask();
};

ensuite pour les includes:
dans Task.cpp:
#include "Previous.h"
#include "PreviousManager.h"
#include "Task.h"

dans PreviousManager.cpp:
#include "Previous.h"
#include "PreviousManager.h"

et dans Previous.cpp:
#include "Previous.h"

Alors j'ai été obligé de rajouter la ligne "class Task;" dans la classe Previous car sinon j'avais une boucle sur les includes. En effet un Task possède un PreviousManager qui est une liste de Previous qui eux même sont des Tasks particulières (j'espère que ca vous paraît clair )

Mon problème est dans la fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
bool PreviousManager::checkCond(Previous* P)
{
	// si le Previous na pas de condition alors on retourne true
	
	if (!(P->getIsCriteria()))
		return true;
	if ((P->getCond())==((P->getTask())->getResult()))
		return true;
	else
		return false;
}

La ligne en rouge me donne une erreur du type:
Severity and Description
error: forward declaration of `struct Task' DIS Previous.h line 4
error: invalid use of undefined type `struct Task' DIS PreviousManager.cpp line 58

Je pense que la classe Previous n'a pas pris en compte le fait que la ligne "class Task" signifiait que la classe Task existe mais est définié ailleurs. Elle la voit comme une struct.

Je sais pas si j'ai été assez clair, j'espère que certains d'entre vous sauront m'aidé.
Merci d'avance.

[Feriaman]

Tu dois inclure "Task.h" dans ton "PreviousManager.cpp"

[Mortada]

J'ai déjà essayé et ça me fait une boucle sur les includes et donc une erreur à la compilation. Et j'ai essayé toutes les séquences dans les includes entre les 3 classes.

[befalimpertinent]

Je pense à un pb de références croisées. Essayes ici FAQ

[Feriaman]

Pour bien comprendre, il te faut arriver à distinguer, les moments ou tu as besoin qu'un élément syntaxique soit déclaré, des moments où tu as besoin qu'il soit définit.

J'entend par "déclaré", le fait que tu aie déjà dit qu'ils existaient et de quelle nature ils étaient.
Ceci par exemple :

Code :

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

class Previous;

veut dire : il existe un élément syntaxique qui s'appelle Previous et qui est une classe (donc previous est un nom de type).

J'entend par "définit", le fait que tu aie déjà dit comment un élément syntaxique se comporte.
Ceci par exemple :

Code :

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

1
2
3
4
class Previous
{
   void m();
};

veut dire : il existe un élément syntaxique qui s'appelle Previous, qui est une classe et qui peut être utilisée de la façon suivante : en appelant une fonction boid Previous::m();

En particulier :
1. ta classe PreviousManager contient des pointeurs de Previous.
Pour faire référence à un pointeur de quelque chose il suffit de savoir que le quelque chose en question est un nom de type (par opposition au fait que ce soit le nom d'une variable, une valeur d'enum, le nom d'une fonction ...)
Donc au moment où tu écris :

Code :

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

Previous*

tu dois déjà avoir mis quelque part en amont :

Code :

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

class Previous

ou

Code :

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

1
2
3
4
class Previous
{
...
}

ou

Code :

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

#include "Previous.h"

2. Ta fonction PreviousManager::checkCond utilise la fonction getResult() qui est une fonction de Task.
Pour pouvoir utiliser cette fonction, il faut qu'au moment où tu l'écris, la classe Task soit définie, pour que tu puisse affirmer que tu as le droit d'utiliser cette fonction.
Si tu avais appelé la fonction tataYoYo() qui n'existe pas, tu aurais voulu que cela ne compile pas.

Il faut donc que tu aie déjà écrit en amont :

Code :

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

1
2
3
4
class Task
{
...
}

ou

Code :

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

#include "Task.h"

mais en aucun cas tu ne peux imaginer que

Code :

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

class Task

soit suffisant

Voici comment on fait d'habitude dans un cas simple

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
-------------          
|fichier A.h |         ------------          
-------------          |fichier B.h|
|struct B;   |         ------------
|struct A    |         |struct A;  |
|{           |         |struct B   |
|   void m();|         |{          |
|  B* p;     |         |  A* p;    |
|}           |         |  void m();|
-------------          |}          |
                       |           |
                       -------------
--------------
|fichier A.cpp|        ---------------
--------------         |fichier B.cpp |
|A::m()       |        ---------------
|{            |        |#include "A.h"|
|   ....      |        |B::m()        |
|}            |        |{             |
-------------          |   p->m();    |
                       |}             |
                       -------------

[Mortada]

Je comprends tout à fait ce que tu veux dire. Mon souci c'est que j'ai bien essayer de le caser dans PreviousManager ce #include "Task.h" mais j'ai toujours une erreur à la compilation et le type Task n'est plus reconnu du tout.

Dans mon compilateur, Previous est compiler en premier sur les 3. C'est lors de la compilation de PreviousManager que l'erreur survient. Je comprends que c'est parce que j'instancie une variable Task et fais appel aux méthodes de cette classe sans "l'inclure" dans PreviousManager.

Si je mets un #include "Task.h" dans PreviousManager, j'aurai une boucle car les includes sont dans ce sens dans Task.cpp:

Code :

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

1
2
3
4
 
#include "Previous.h"
#include "PreviousManager.h"
#include "Task.h"

C'est de la que vient la boucle. Si je dois rajouter un Task.h dans PreviousManager, je n'arrive pas trouver où exactement je dois le rajouter.

[Feriaman]

Hum, je n'avais probablement pas compris.

Si ton problème vient du fait que tu inclus deux fois le même fichier de déclaration (.h) depuis le même fichier d'implémentation (.cpp), par deux chemins différents, c'est en effet autre chose.

Il te faut protéger tous tes fichiers de déclaration afin qu'il ne puissent pas être inclus plusieurs fois.

cela se fait facilement grace à des directives de précompilation en écrivant au début de chaque .h

Code :

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

1
2
#ifndef MACLASSTASK
#define MACLASSTASK

en choisissant un identifiant pour chaque fichier, ici j'ai pris MACLASSETASK, mais pour chaque fichier tu dois en prendre un différent

sans oublier de terminer le fichier par :

Code :

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

#endif //MACLASSTASK

Ainsi chaque fichier de déclaration n'est inclus qu'une seule fois dans chaque fichier d'implémentation.

Du coup l'ordre des includes n'a plus aucune importance.

[Mortada]

C'est une bonne idée. Cependant mon patron refuse que je mettes des includes dans les .h et je ne sais pas si ça marchera dans les .cpp (mes premiers tests suite à ton post n'ont pas marchés mais c'est surement une erreur de ma part).

Mais j'aimerai savoir comment tu t'y prendrai dans les includes si tu dois avoir:
- une classe A qui possède une variable de type B
-une classe B qui possède une liste de variable de type C
- et une classe C qui possède un pointeur sur un type A.

[ep31]

Déclare une classe A dans ton fichier .h contenant le prototype de ta classe C :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class A;
 
class C 
{
public :
   C ();
   ~C ();
...
protected :
   A* m_MonPointeurDeA;
};

[coyotte507]

dans PreviousManager.cpp:
#include "Previous.h"
#include "PreviousManager.h"

C'est normal t'as pas inclus task.h, comment il pourrait savoir quels sont ses membres (que tu utilises)?

fais

Code :

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

1
2
3
4
dans PreviousManager.cpp:
#include "Previous.h"
#include "PreviousManager.h"
#include "Task.h"

et dans task.h

Code :

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

1
2
3
4
5
6
#ifndef TASK_H
#define TASK_H
 
...
 
#endif

[befalimpertinent]

ET si tu fais juste :
//EDIT: corrections après vérification

Code :

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

1
2
3
4
5
6
7
8
 
//A.hpp
#include "B.hpp"
 
class A
{
B objB;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
 
//B.hpp
#include "C.hpp"
 
class B
{
C ob1C;
C ob2C;
C ob3C;
}

Code :

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

1
2
3
4
5
6
7
8
 
//C.hpp
class A;
 
class C
{
A* ptrobjA;
}

?
Je cite laFAQ :

De manière générale les déclarations anticipées sont à utiliser autant que possible, à savoir dès qu'on déclare dans une classe un pointeur ou une référence sur une autre classe. En effet, cela permet aussi de limiter les dépendances entre les fichiers et de réduire considérablement le temps de compilation.

Néanmoins ce genre d'inclusion cyclique semble montrer un problème de conception plus général

[coyotte507]

Le problème c'est qu'il appelle un membre de task, sans avoir défini task.

Edit: @Mortada: si tu mets tes includes seulement dans les cpp comme tu le fais, tu n'auras jamais d'inclusion cyclique.

[Mortada]

Voici les modifications que j'ai apportée:
dans PreviousManager.cpp:

Code :

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

1
2
3
4
 
#include "Previous.h"
#include "PreviousManager.h"
#include "Task.h"

et maintenant j'ai une erreur:

Code :

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

1
2
Severity and Description	Path	Resource	Location	Creation Time	Id
error: expected class-name before '{' token	DIS	Task.h	line 8	1184857061265	4400

La différence c'est que ce n'est plus ma fonction PreviousManager::checkCond(Previous* P) qui génère l'erreur.

edit voici le code de Task.h :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#ifndef TASK_H_
#define TASK_H_
 
 
 
 
class Task : public  ProcessObject
{
protected:
....
};
#endif /*TASK_H_*/

[coyotte507]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#ifndef TASK_H_
#define TASK_H_
 
class ProcessObject;
 
class Task : public  ProcessObject
{
protected:
....
};
#endif /*TASK_H_*/

[Mortada]

Non ca ne marche pas. je me retrouve avec les même erreurs quand dans mon premier post

Code :

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

1
2
3
Severity and Description
error: forward declaration of `struct ProcessObject' DIS Task.h line 5
error: invalid use of undefined type `struct ProcessObject' DIS Task.h line 8

[coyotte507]

c'est normal il faut faire les même corrections avec ta classe ProccessObject.

dans task.cpp:

Code :

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

1
2
3
...
...
#include "ProcessObject.h"

Met bien cet include en dernier dans les includes

[Mortada]

toujours la même erreur

[coyotte507]

tu peux remettre les fichiers .h et l'ordre des include dans les cpp?

[Mortada]

Task.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
#ifndef TASK_H_
#define TASK_H_
 
 
//class ProcessObject;
 
class Task : public  ProcessObject
{
protected:
 
	bool m_bIsExecuted;
	bool m_bResult;
	bool m_bLaunch;
	bool m_bIsLaunched;
	PreviousManager* m_pPrevious;
public:
	Task();
	~Task();
 
 
	bool check(){return true;};
	bool execute(){return true;};
	bool getIsExecuted();
	bool getResult();
	bool getLaunch();
	bool getIsLaunched();
};
#endif

PreviousManager.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
#ifndef PREVIOUSMANAGER_H_
#define PREVIOUSMANAGER_H_
 
class Task;
class PreviousManager
{
private:
	vector<Previous*> m_lstListPrev;
 
public:
	PreviousManager();
	virtual ~PreviousManager();
	bool addPrev( Task* T, bool iscrit, bool cond) ;
	bool removePrev(Previous* p);
	bool checkCond(Previous * P);
	vector<Previous*> getList();
};
 
inline vector<Previous*>
PreviousManager::getList()
{
	return m_lstListPrev;
}
 
#endif /*PREVIOUSMANAGER_H_*/

Previous.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
#ifndef PREVIOUS_H_
#define PREVIOUS_H_
 
class Task;
 
class Previous
{
private:
	Task* m_pT;
	bool m_bIsCriteria;
	bool m_bCond;	
 
public:
	Previous();
	Previous (Task *T,bool iscrit, bool cond);
	~Previous();
 
	bool getIsCriteria();
	bool getCond();
	void setIsCriteria(bool b);
	void setCond(bool b);
	//bool verifyCond();
	Task* getTask();
};
#endif

L'ordre des includes:
Task.cpp:

Code :

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

1
2
3
4
5
#include "Previous.h"
#include "PreviousManager.h"
 
#include "Task.h"
#include "ProcessObject.h"

PreviousManager.cpp:

Code :

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

1
2
3
4
#include "Previous.h"
 
#include "PreviousManager.h"
#include "Task.h"

Previous.cpp:

Code :

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

#include "Previous.h"

[coyotte507]

ProcessObject aussi, vu qu'il est impliqué

Edit: tu as mis en commentaire le class ProcessObject;