Discussion :

[Louzof]

Bonjour à tous,

c'est mon premier message sur ce forum

Alors je travaille avec C++ builder 2006 (sous windows donc...) et j'ai quelques petits soucis.

Le projet comporte environ 50 classes (ben oui c'est un gros truc) et j'ai plein de liens entre les classes, héritage, association, composition ... En bref, rien d'extraordinaire.

Pour que les en-têtes de fichiers ne soient pas surchargée j'ai décidé de créer un .h qui effectue toutes les inclusions et jusque là ça marche
Mais j'ai un soucis au niveau des héritage, j'ai une classe TSouris_seg qui hérite d'une classe TEvenement_seg mais le compilateur dit qu'il ne trouve pas le type, alors qu'il le trouve en tant qu'attribues d'une autre classe...

Donc voici ma classe TSouris_seg:

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
//---------------------------------------------------------------------------
 
#ifndef TSourisH
#define TSourisH
 
#include "header.h"
//---------------------------------------------------------------------------
 
class TSouris_seg : public TEvenement_seg{
	private:
		...
	protected:
	public:
		TSouris_seg();
		~TSouris_seg();
		void DeclancherEvenement();
 
		/////////////// Tous les accesseurs pour toutes les variables //////////
		...
};
#endif

le cpp de cette classe :

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
//---------------------------------------------------------------------------
 
 
#pragma hdrstop
#include "TSouris.h"
//--------------------------------------------------------------------------
 
#pragma package(smart_init)
 
 
TSouris_seg::TSouris_seg(){
}
TSouris_seg::~TSouris_seg(){
}
 
...
}

la classe TEvenement_seg qui est abstraite:

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
//---------------------------------------------------------------------------
 
#ifndef TEvenementH
#define TEvenementH
#include "header.h"
//---------------------------------------------------------------------------
class TEvenement_seg {
	private:
		TProjet_seg* projet;
	protected:
	public:
		TProjet_seg* getProjet();
		void setProjet(TProjet_seg* newProjet);
 
};
#endif

Y a rien d'extraordinaire dans le CPP...

Et maintenant le header.h qui doit faire toutes mes inclusions:

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
//Ficher d'inclusion de toutes les bibliothèques
/* Ceci est dûe au parcours des librairies dans le .H */
#ifndef HEADER_H
#define HEADER_H
 
//Bibliothèques C++
#include <fstream.h>
#include <string.h>
 
 
//Bibliothèque externe
#include "atDiagram.hpp"
 
 
////////Liste de tous les types
class TProjet_seg;
class TEvenement_seg;
 
...
 
class TSouris_seg;
 
..................
 
 
//Bibliothèques du projet
 
#include "TProjet.h"
 
.........
 
#include "TEvenement.h"
#include "TSouris.h"
#include "TClavier.h"
 
.....
 
#endif

Et l'erreur du compilateur est:
[C++ Erreur] TSouris.h(10): E2029 'TEvenement_seg' doit être une classe ou une structure précédemment définie


Voila, j'espère que j'ai été claire sur mon problème, est-ce que quelqu'un peut m'aider?

Je vous remercie d'avance prendre un peu de votre temps pour vous penchez sur mon problème

[Cheps]

Pour que les en-têtes de fichiers ne soient pas surchargée j'ai décidé de créer un .h qui effectue toutes les inclusions et jusque là ça marche

Si toutes les classes de ton projet incluent header.h, qui lui-même inclue toutes les classes, c'est à mon avis une très mauvaise idée, peut-être que ton problème vient de là. En plus ça doit pas compiler super vite

Sinon tu t'es peut-être emmêlé avec tes directives pré-processeur #ifndef #define #pragma, ou autre (genre un copier-coller qui a mal tourné). Quelle est l'erreur exacte du compilateur, quelle est la ligne fautive?

[Louzof]

Si toutes les classes de ton projet incluent header.h, qui lui-même inclue toutes les classes, c'est à mon avis une très mauvaise idée, peut-être que ton problème vient de là. En plus ça doit pas compiler super vite

En faite c'est pas vraiment un problème vue qu'il ne va effectuer qu'une seule compilation de chaque fichier quoi qu'il arrive

Sinon tu t'es peut-être emmêlé avec tes directives pré-processeur #ifndef #define #pragma, ou autre (genre un copier-coller qui a mal tourné). Quelle est l'erreur exacte du compilateur, quelle est la ligne fautive?

Je pense pas que je me suis embrouillé avec les inclusions ni les pragma, les inclusions il n'y en a que quelques unes et les pragma c'est ceux de C++ builder j'en est pas rajouté.

Sinon la ligne qui pose problème c'est:

Code :

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

class TSouris_seg : public TEvenement_seg{

(dans TSouris.h)

et l'erreur c'est:

Code :

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

[C++ Erreur] TSouris.h(10): E2029 'TEvenement_seg' doit être une classe ou une structure précédemment définie

Il est important de savoir que si j'enlève l'héritage ça marche mais par contre ça plante sur un autre héritage d'une autre classe. Donc je pense qu'il y a un souci dans mon header qui pose problème avec les héritage...

[Cheps]

En faite c'est pas vraiment un problème vue qu'il ne va effectuer qu'une seule compilation de chaque fichier quoi qu'il arrive

Oui mais si tu modifies un petit truc dans un fichier, il doit te recompiler tout le projet.

Bon j'ai créé un nouveau projet avec Visual Studio et j'y ai mis les fichiers tels qu'ils sont là, ça compile sans problème (j'ai juste viré le #pragma package(smart_init) qui n'est pas reconnu par VS). Je vois pas d'erreur dans ce que tu as posté. Mais à mon avis ton principe du fichier unique d'inclusion est à revoir.


P.S. : tu devrais utiliser <fstream> et <cstring> qui sont les bibliothèques C++ standard, plutôt que <ifstream.h> et <string.h> qui sont là essentiellement pour la compatibilité avec C.

[r0d]

Bonjour,

Je n'ai pas de réponse directe, mais je vois un truc qui pourrait être une partie du problème: il est inutile (et peut-être dangereux) de pré-déclarer une classe (class TSouris_seg; ) et d'include l'en-tête où cette classe est définie. Il faut faire l'un ou l'autre, suivant le besoin, mais pas les deux.

Hope it helps.

[Louzof]

Donc en faite le problème viendrais de mon fichier unique d'inclusion. Il est vrai que ça marchais avant de mettre ce fichier d'inclusion mais je voulais enlever ces en-têtes de 15 lignes pour mon projet.
Par contre dans mon projet j'ai des classes qui s'appelle mutuellement les unes les autres d'autre avec des héritage... et je voudrais vraiment éviter de mettre des pleins d'include dans chaque fichier...

Est-ce qu'il y aurais un autre moyen pour faire ça? faire une .h avec des trucs spécifiques dedans... ou autres?


PS: <fstream> et <cstring> ne sont pas reconnu.

[buggen25]

Salut
dans le fichier header.h ta fait un cmpilation conditionnelle du type

Code :

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

1
2
3
 
#ifndef HEADER_H
#define HEADER_H

et pour TSouris.h ta mis TSourisH, pourquoi pas TSOURIS_H pour etre coherent.mais je pense pas que sa a une incidence sur le code
Cordialement

[Louzof]

Salut
dans le fichier header.h ta fait un cmpilation conditionnelle du type

Code :

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

1
2
3
 
#ifndef HEADER_H
#define HEADER_H

et pour TSouris.h ta mis TSourisH, pourquoi pas TSOURIS_H pour etre coherent.mais je pense pas que sa a une incidence sur le code
Cordialement

En effet, c'est simplement parce que TSouris a été mis automatiquement par delphi alors que j'ai écris le header moi même mais t'a raison je vais le changer c'est pas beau ^^

[Cheps]

Est-ce qu'il y aurais un autre moyen pour faire ça? faire une .h avec des trucs spécifiques dedans... ou autres?


PS: <fstream> et <cstring> ne sont pas reconnu.

Je vois pas où est le problème d'avoir 15 include dans chaque fichier d'en-tête, c'est même mieux de savoir de quels autres fichiers il dépend.

Si fstream et cstring ne sont pas reconnus, alors ce n'est pas un compilateur C++ standard (ou il est mal installé).

[r0d]

Salut
dans le fichier header.h ta fait un cmpilation conditionnelle du type

Code :

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

1
2
3
 
#ifndef HEADER_H
#define HEADER_H

et pour TSouris.h ta mis TSourisH, pourquoi pas TSOURIS_H pour etre coherent.mais je pense pas que sa a une incidence sur le code
Cordialement

Effectivement ce n'est pas beau mais ça n'a aucune incidence sur le code.

Donc en faite le problème viendrais de mon fichier unique d'inclusion. Il est vrai que ça marchais avant de mettre ce fichier d'inclusion mais je voulais enlever ces en-têtes de 15 lignes pour mon projet.
Par contre dans mon projet j'ai des classes qui s'appelle mutuellement les unes les autres d'autre avec des héritage... et je voudrais vraiment éviter de mettre des pleins d'include dans chaque fichier...

Essaie de supprimer les pré-déclarations de tes classes dans ce fichier d'inclusion.

Est-ce qu'il y aurais un autre moyen pour faire ça? faire une .h avec des trucs spécifiques dedans... ou autres?

Ben, pas que je sache. D'ailleurs, ce que tu essaie de faire est une bonne chose, et c'est une méthode beaucoup utilisée.

Mais bien souvent (attention, je dis "souvent", ce n'est pas obligatoirement ton cas), ce genre de problème d'inclusions proviennent d'une mauvaise conception. Il faut, par exemple, éviter (tant que faire se peut, et ce n'est pas toujours possible et/ni la meilleure solution) les références croisées et essayer d'avoir un graphe de référence qui ressemble le plus possible à un arbre.

[r0d]

Je vois pas où est le problème d'avoir 15 include dans chaque fichier d'en-tête, c'est même mieux de savoir de quels autres fichiers il dépend.

Bah, c'est tout de même plus lisible et plus simple à programmer/maintenir. D'autant plus qu'avec les pare-feu de compilation on perd finalement très peu de temps (voire pas du tout) à la compilation.

Un bon exemple de code qui utilise cette technique est boost. Mais boost à une structure de référence en arbre (au moins dans la première couche), ce qui rend cette méthode très facile à mettre en oeuvre.

Si fstream et cstring ne sont pas reconnus, alors ce n'est pas un compilateur C++ standard (ou il est mal installé).

En effet, je ne suis pas sûr que C++ Builder 2006 respecte les standards :s

[Louzof]

Je vois pas où est le problème d'avoir 15 include dans chaque fichier d'en-tête, c'est même mieux de savoir de quels autres fichiers il dépend.

Si fstream et cstring ne sont pas reconnus, alors ce n'est pas un compilateur C++ standard (ou il est mal installé).

Oui c'est vrai que c'est pas spécialement génant mais c'est juste que quand tu veux faire des modifs tu sais où trouver tes includes... Enfin s'il n'y pas solutions je vais revenir à la bonne vieille méthode ^^

Et en effet le compilo n'est pas un truc standard c'est du Borland, à mon avis c'est pas vraiment standard!

Edit: @r0d: En faite, je peux pas enlever les déclarations de classes parce que j'ai beaucoup de déclaration croisée car j'ai de nombreuses composition dans mon diagramme de classe, d'ailleur j'ai pas vraiment d'autre choix pour ceci...

Par contre je peux peu-etre enlever les pré-déclarations de classe du .h les mettres seulement dans les classes indispensable et laisser les include dans le .h... je pense que ça peut marcher! Mais quelqu'un aurai une meilleur idée?

[befalimpertinent]

C'est quand même plus élégant et logique quand chaque header ou source inclut uniquement ce qui lui est nécessaire et sans dépendre de l'ordre d'inclusion des fichiers.
Une règle que je trouve amha plutôt juste est d'inclure d'abord les fichiers "proche" du système (stdlib, ...) puis des éventuelle api (gl,qt) puis ses propres headers (ma_classe.hpp) et enfin éventuellement les "class autre_classe" si celle ci n'est pas utilisé en tant que valeur dans le fichier.

[koala01]

Salut,

Ceci dit, rien ne t'empecherait de palcer toutes les déclaration anticipées dans un seul et même fichier, si, comme tu semble le dire, tes classes se font référence l'une à l'autre.

D'un autre coté, le seul autre fichier d'en-tête qui sera réellement indispensable dans le cas d'un héritage sera... le fichier de la classe mere

Au final, tu pourrais organiser tes fichiers plus ou moins sous la forme de:
un fichier "de déclaration anticipées" par "arborescence d'héritage"
first_typefwd.hpp

Code :

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

1
2
3
4
5
6
7
8
9
 
#ifndef FIRST_TYPEFWD_HPP
#define FIRST_TYPEFWD_HPP
class Mere1; // la déclaration anticipée de la première classe mere
class Fille1_1;
class Fille1_2;
class Fille1_3;
/*...*/
#endif // FIRST_TYPEFWD_HPP

second_typefwd.hpp

Code :

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

1
2
3
4
5
6
7
8
9
 
#ifndef SECOND_TYPEFWD_HPP
#define SECOND_TYPEFWD_HPP
class Mere2; // la déclaration anticipée de la deuxième classe mere
class Fille2_1;
class Fille2_2;
class Fille2_3;
/*...*/
#endif // SECOND_TYPEFWD_HPP

un fichier "inclusions communes" (<string>,<vector>,...)
CommonIncludes.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
#ifndef COMMONINCLUDES_HPP
#define COMMONINCLUDES_HPP
#include <string>
#include <fstream>
#include <sstream>
#include <vector>
#include <list>
#include <map>
/*...*/
#endif // COMMONINCLUDES_HPP

un fichier d'en-tête incluant les fichier d'en-tête d'un arbre d'héritage entier
fichier FirstTypeDefs.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
#ifndef FIRST_TYPE_DEFS_HPP
#define FIRST_TYPE_DEFS_HPP
/* il n'est pas nécessaire d'inclure le fichier de la classe mere, 
 * vu qu'il sera implicitement inclus par les fichiers des classes filles
 */
#include "Fille1_1.hpp"
#include "Fille1_2.hpp"
#include "Fille1_3.hpp"
/*...*/
#endif // FIRST_TYPE_DEFS_HPP

Les fichiers d'en-tête des classes mere ressembleraient à
fichier Mere1.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef MERE1_HPP
#define MERE1_HPP
#include <CommonInclude.hpp> // permet de récupérer les classes standard
/* éventuellement, et selon les besoins, un (ou plusieurs) fichier(s) de
 * déclarations anticipées et / ou un (ou plusieurs) fichier(s) d'inclusion
 * "d'arbre d'héritage"
 */
class Mere1
{
    /*...*/
};
#endif // MERE1_HPP

et, pour les classes filles:
fichier Fille1_1.hpp

Code :

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

1
2
3
4
5
6
7
8
#ifndef FILLE_1_1_HPP
#definie FILLE_1_1_HPP
#include "Mere1.hpp"
class Fille1_1: public Mere1
{
    /*...*/
}; 
#endif // FILLE_1_1_HPP

tu ne pourra donc pas réduire "aussi drastiquement" le nombre d'inclusion de 15 (ou 20) à un, mais tu le réduira néanmoins fortement en passant à 1 ou 2 maximum par arborescence d'héritage, et, si tu dois inclure les deux fichiers, l'un (celui qui contient les déclarations anticipées) sera dans le fichier d'en-tête, et l'autre (celui qui contient les définitions réelles) sera dans le fichier d'implémentation ce qui, en soit, n'est déjà pas si mal...

[Louzof]

Merci beaucoup pour vos réponses, je vais essayer ça et puis je vous tiens au courant!

Je viens de constater un problème dans ta réponse... c'est que tu ne parle pas des classes qui s'appelle mutuellement (les compositions du diag de classes)

De plus, normalement pour faire un héritage il n'est pas nécessaire de pré déclarer la classe.
Il suffit dans un cas simple de faire:

Code :

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

1
2
3
4
5
6
7
8
class Mere{
 
};
 
#include "Mere.h"
class Fille{
 
};

Et je me demande du coup si le problème ne viens pas du faite que je pré déclare des classes qui seront hérité plus tard...ou pire que ça vienne du faite que je pré déclare des classes qui sont utilisés dans des classes qui seront dérivée ...

Donc je me fais des tests et tout mais bon, je pense pas que c'est ça...

Edit:

Ca y est le problème est règlé!!! Merci à vous tous!

En faite, le problème venais que dans ma .h j'essayais d'inclure mon TSouris.h (par exemple) et de ce faite ça lui plaisait pas. Du coup je me suis pas mal inspiré de la solution du dessus pour corriger mon problème.

J'ai en faite réalisé 3 .h différentes:

1. Une pour les inclusions commune (<vector> ...)
2. Une pour la pré déclaration de tous les types de classes
3. Le header qui inclus les deux premières et qui inclus seulement les fichiers des classes mères

Et avec cette méthode ça marche très bien!

Merci à tous problème résolu