Un problème d'include (circulaire?)

Version imprimable

Bonjour,

Je poste ce message aujourd'hui car je n'arrive pas à résoudre une erreur de compilation dans un projet que je développement en ce moment.
Voici à quoi ressemblent mes fichiers:

main.c
Code:

1 2 3 4 5 6 7 8 9 #include <stdio.h> #include <stdlib.h> #include "source2.h" int main() { printf("Hello world!\n"); return 0; }
source1.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #ifndef SOURCE1_H #define SOURCE1_H #include "source2.h" typedef struct { int atrb1; int atrb2; } T_Struct1; void funct(T_Struct1 pParam1, T_Struct2 pParam2); #endif // SOURCE1_H
source2.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #ifndef SOURCE2_H #define SOURCE2_H #include "source1.h" typedef struct { int atrb1; int atrb2; } T_Struct2; void funct2(T_Struct1 pParam1, T_Struct2 pParam2); #endif // SOURCE2_H
Si dans le main j'inclue source1.h je me retrouve avec l'erreur suivante:

Code:

C:\Users\Daniel\Mon dossier\Test\source2.h|13|parse error before "pParam1"|

Et si j'include source2.h

Code:

C:\Users\Daniel\Mon dossier\Test\source1.h|13|parse error before "T_Struct2"|

Je pense comprendre d'où vient le problème: lorsque je fais un include de source2.h dans source1.h le prototype de funct2 a besoin de la structure définie dans source1.h mais cette dernière ne sera définie qu'une fois que source2.h aura fini d'être définie elle même
(je ne sais pas si je suis assez clair :?)
Est-ce que quelqu'un aurait une solution à ce problème, sachant qu'il est important que ces structures soient dans des fichiers séparés?

En vous remerciant par avance,

Bonjour,

Tu as plusieurs solutions pour résoudre ton problème

Ne créer qu'un include

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef SOURCE_H
#define SOURCE_H
 
typedef struct
{
    int atrb1;
    int atrb2;
} T_Struct1;
 
typedef struct
{
    int atrb1;
    int atrb2;
} T_Struct2;
 
void funct(T_Struct1 pParam1, T_Struct2 pParam2);
void funct2(T_Struct1 pParam1, T_Struct2 pParam2);
 
#endif

Créer des includes qui ne contiennent que les définitions des structures et les inclure quand tu as besoin de les connaître :

Code:

1
2
3
4
5
6
7
8
9
10
#ifndef DEF_STRUCT1
#define DEF_STRUCT1
 
typedef struct
{
    int atrb1;
    int atrb2;
} T_Struct1;
 
#endif

Idem pour T_Struct2, puis :

Code:

1
2
3
4
5
6
7
#ifndef SOURCE1_H
#define SOURCE1_H
 
#include "def_struct1.h"
#include "def_struct2.h"
 
void funct(T_Struct1 pParam1, T_Struct2 pParam2);

Idem pour source2.h

Modifier tes fonctions pour qu'elles utilisent des pointeurs sur tes stuctures et faire des forward declarations

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef SOURCE1_H
#define SOURCE1_H
 
struct T2;
 
typedef struct T1
{
    int atrb1;
    int atrb2;
} T_Struct1;
 
void funct(struct T1 *pParam1, struct T2 *pParam2);

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef SOURCE2_H
#define SOURCE2_H
 
struct T1;
typedef struct T2
{
    int atrb1;
    int atrb2;
} T_Struct2;
 
void funct2(struct T1* pParam1, struct T2 *pParam2);
 
 
#endif // SOURCE2_H

19/05/2013, 14h43
Portugues13

Bonjour kwariz,

Merci pour cette réponse à la fois rapide et complète. Je vais tester tout ça et si je n'ai plus d'erreur je marquerai le sujet comme "Résolu".

Juste une petite question :
J'hésite entre utiliser la 2eme et la 3eme solution. Selon vous laquelle est la plus "propre"/standard?

En vous remerciant par avance,
Cordialement,

C'est en grande partie une question de style et de préférences personnelles.
Néanmoins, l'idéal à mon sens serait d'avoir un module qui ne s'occupe que de ce qui concerne la première structure, un autre pour ce qui concerne la seconde et un troisième qui regroupe ce qui concerne les deux. Quelque chose comme :
Code:

1 2 3 4 5 6 7 8 9 10 11 #ifndef STRUCT1_H #define STRUCT1_H typedef struct T1 StructT1; struct T1 { ... } void f1_1(StructT1 param1); void f1_2(StructT1 param1, const char* param2); void f1_3(StructT1 param1, ...);
Code:

1 2 3 4 5 6 7 8 9 10 11 #ifndef STRUCT2_H #define STRUCT2_H typedef struct T2 StructT2; struct T2 { ... } void f2_1(StructT2 param1); void f2_2(StructT2 param1, const char* param2); void f2_3(StructT2 param1, ...);
Code:

1 2 3 4 5 6 7 #ifndef BIDULE_H #define BIDULE_H #include "structt1.h" #include "structt2.h" void g_1(StructT1 param1, StructT2 param2);
Cela permet de bien séparer les responsabilités, l'implémentation est plus claire, ...

Quant à l'utilisation ou non de pointeurs plutôt que de passer des structures en paramètres c'est également en partie une affaire de goût. Toutefois, comme les paramètres sont passés par copie le coût de la copie de grosses structures peut être pénalisant :)

Je pense que par défaut j'opterais pour le découpage ci-dessus en utilisant des pointeurs sur les structures.

19/05/2013, 15h14
Portugues13

Je vois. :D

Encore un grand merci à vous, cela m'aura été très instructif ! :ccool: