Inclusion .h par deux .c

Version imprimable

14/06/2010, 17h06
cauriera

Inclusion .h par deux .c
Bonjour,

J'ai une petite question...
J'ai deux fichiers .c, l'un contenant une API, et l'autre contenant les fonctions internes du projets.

je souhaite inclure un fichier .h dans les deux fichiers .c. Le but étant entre autre, d'avoir des variables partagées entre les deux fichiers (entre autre un buffer utilisé en débug pour les traces)

Mais dès que j'inclue le .h dans les deux fichiers, j'ai une erreurs:
Symbol blabla multiply defined (...)

J'ai tenté un:
Code:

1 2 3 4 5 6 7 #ifndef fichier_h #define fichier_h #define EXTERN #else #define EXTERN extern #endif
En plaçant un EXTERN devant les définitions de mes différentes variables, mais cela ne marche pas. Quelqu'un aurait il une idée?
14/06/2010, 17h21
zuurstof
Respectes-tu bien la structure d'un fichier H?
Code:

1 2 3 4 5 6 7 8 9 #ifndef FICHIER_H #define FICHIER_H //Declaration des variables //Declaration des fonctions #endif /*FICHIER_H*/
#ifndef et #endif "encadent" l'ensemble des déclarations

Et alors, dans les différents fichier C
Code:

1 2 #include "fichier.h"
14/06/2010, 17h29
cauriera

Oui, la structure est respectée.

Le problème ne vient pas du fait que les définitions ne sont pas trouvées, mais qu'elles sont en doubles.

Visiblement, la compilation de fichier_api.c inclue les variables (ca, c'est normal). Mais lors de la compilation de fichier_interne.c, l'inclusion du même .h, provoque la RE-déclaration des même variables.

Plutôt que de "comprendre" que c'est la même variable, le compilateur tente de faire une nouvelle référence. Le nom étant déjà utilisé, il y a une erreur.

Bonjour,

GNÉ? 8O
Code:

1 2 3 4 5 6 7 #ifndef fichier_h #define fichier_h #define EXTERN #else #define EXTERN extern #endif
Si ça c'est respecter la structure d'un fichier .h, alors je suis Linus Torvalds :roll:

Ce serait pas plûtot
Code:

1 2 3 4 5 #ifndef fichier_h #define fichier_h #define EXTERN extern #endif
? ;)

14/06/2010, 18h56
Bktero

Quel est l'intérêt de cette ligne

Code:

#define EXTERN extern

d'ailleurs ?

Je l'ai déjà vu une fois dans un code source, mais je n'ai pas vu l'intérêt :cry:
14/06/2010, 19h11
gl
Citation:

Envoyé par cauriera

Le problème ne vient pas du fait que les définitions ne sont pas trouvées, mais qu'elles sont en doubles.

Visiblement, la compilation de fichier_api.c inclue les variables (ca, c'est normal). Mais lors de la compilation de fichier_interne.c, l'inclusion du même .h, provoque la RE-déclaration des même variables.

Plutôt que de "comprendre" que c'est la même variable, le compilateur tente de faire une nouvelle référence. Le nom étant déjà utilisé, il y a une erreur.

Le comportement observé est tout à fait normal. Les gardes anti-réinclusion dans les .h empêche l'inclusion multiple d'un header dans un même .c mais non pas d'influence entre deux .c.
La définition de deux variables avec le même nom crée deux variables.

La meilleure solution serait de supprimer les variables globales et en particulier les variables globales partagées entre deux fichiers.

Si tu n'as vraiment pas le choix, il faut définir la variable une seule fois et la déclarer partout où il y en a besoin.
La solution généralement utilisée consiste à déclarer la variable dans le .h avec extern. Et de la définir dans un seul des .c (voire dans un .c dédié). Ce qui donne :
Code:

1 2 3 4 5 6 7 8 9 //global.h #ifndef GLOBAL_H #define GLOBAL_H extern int myGlobal; ... #endif
Code:

1 2 3 4 5 6 //global.c #include "global.h" int myGlobal; ...
Code:

1 2 3 4 //main.c #include "global.h" ...
15/06/2010, 10h59
cauriera

Très bien, merci je vais faire comme ca.
Je sais qu'il faut éviter les variables globales, mais pour certaines je n'ai pas le choix.

Salut,

Citation:

Envoyé par Bktero

Quel est l'intérêt de cette ligne

Code:

#define EXTERN extern

d'ailleurs ?

Je l'ai déjà vu une fois dans un code source, mais je n'ai pas vu l'intérêt :cry:

Cette ligne seule ne suffit pas. Soit un source "sharable.c" avec son header "sharable.h". Au début de "sharable.c", on met
Code:

1 2 #define SHARABLE_PRIVATE #include "sharable.h"
au lieu de simplement:

Code:

#include "sharable.h"

Dans "sharable.h", on a un squelette du genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #ifndef SHARABLE_HEADER #define SHARABLE_HEADER #ifdef SHARABLE_PRIVATE #define EXTERN #else #define EXTERN extern #endif EXTERN int toto; EXTERN int tata; #undef EXTERN #endif
Ça permet au source propriétaire du header de déclarer ses globales sans le extern, et tous les autres sources qui incluront ce header préfixeront avec extern. Cette façon de faire n'a plus lieu d'être en C99, on peut préfixer sans problème n'importe quelle déclaration de variable globale avec extern. Mais en C90, c'était obligatoire me semble t-il.

15/06/2010, 12h00
Bktero

Ah oui le code ressemblait à ton sharable.h!

Je crois que j'ai compris le principe. Du coup, tu peux toujours inclure ta liste de variables globales. Dans le code que j'avais vu, il me semble qu'il y avait un fichier avec une fonction pour initialiser ces variables globales. Dans ton exemple, ça doit correspondre à sharable.c.

Si c'est bien ça, je vais m'empresser de retenir cette méthode. Je la trouve propre et élégante :)

Merci bien ! :D

ha voila, cette solution ressemble effectivement à ce que je voulais faire. J'aime bien cette solution ou les variables ne sont définies qu'une et une seule fois dans un seul fichier.

Pour le problème de l'initialisation des variables, tu peux utiliser cette solution la, toujours dans le meme exemple:

Dans "sharable.h", on aurait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #ifndef SHARABLE_HEADER #define SHARABLE_HEADER #ifdef SHARABLE_PRIVATE #define EXTERN #else #define EXTERN extern #endif #ifdef SHARABLE_PRIVATE EXTERN int toto = 0; EXTERN int tata = 0; #else EXTERN int toto; EXTERN int tata; #endif #undef EXTERN #endif

Du coup, ca suffirait juste ça non ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef SHARABLE_HEADER
#define SHARABLE_HEADER
 
#ifdef SHARABLE_PRIVATE
  int toto = 0;
  int tata = 0;
#else
  extern int toto;
  extern int tata;
#endif
 
#endif

15/06/2010, 15h36
cauriera

Oui en effet, sur cet exemple, cela revient exactement au même.

Mouais mouais mouais.... J'ai appliqué cette technique et j'ai passé une heure à comprendre pourquoi mon projet ne voulait plus linker. J'ai réussi à le faire linker, mais c'est un peu du bricolage. Et surtout, ça pose un problème de "conception" de mes inclusions de fichiers.

Voici les différents fichiers que j'ai créé sous Codeblock (Windows XP).

1) Le fichier avec les déclarations des variables globales:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #ifndef GLOBALES_H #define GLOBALES_H #ifdef INIT_GLOBALES char g_strFoo[100] = "Bonjour !\nJe suis une chaine globale :)\n\n"; #else extern char g_strFoo[100]; #endif #endif
2) Un fichier source faisant un appel à cette variable globale :
Code:

1 2 3 4 5 6 #include "appel.h" void modifierGlobales(void) { strcpy(g_strFoo,"Et du coup tout le monde peut me modifier :/"); }
3) Le header l'accompagnant :
Code:

1 2 3 4 5 6 7 8 9 #ifndef APPEL_H #define APPEL_H #include "globales.h" #include <string.h> void modifierGlobales(void); #endif
4) Un fichier source main pour faire travailler tout ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 #include "main.h" int main(void) { puts(g_strFoo); modifierGlobales(); puts(g_strFoo); return 0; }
5) Et enfin le header du main. Celui qui pose problème :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef MAIN_H #define MAIN_H #include <stdio.h> // A faire en second #include "appel.h" // A faire en premier #define INIT_GLOBALES #include "globales.h" #endif
Les commentaires parlent d'eux mêmes : si je fais dans le bon ordre, ça link ; dans le mauvais, ça ne link pas. Je vois d'où vient le problème : #include appel.h inclue le fichier "globales.h" avec les extern puisque INIT_GLOBALES n'est à ce moment pas défini. Donc les variables globales ne passent pas par la phase d'initialisation.

Le seul truc, c'est que ça me gêne un peu de réfléchir à l'ordre d'inclusions de fichiers. J'estime que si c'était bien fait, je n'aurais pas à m'occuper de ça. Plusieurs questions se posent alors :

Je respecte bien les règles d'inclusion des headers, au niveau des gardes ?
Même pour le fichier main.h ?
Le problème vient-il de la déclaration / définition des globales ?
Comment faire alors ?

Mon idée est qu'il faut définir les globales dans un fichier *.c et garder le coup du :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #ifndef SHARABLE_HEADER #define SHARABLE_HEADER #ifdef SHARABLE_PRIVATE #define EXTERN #else #define EXTERN extern #endif EXTERN int toto; EXTERN int tata; #undef EXTERN #endif
Juste ou faux ? :?

Encore merci pour vos éclaircissements ;)

Alors ej ne suis pas un expert pour ce qui est respect des règles et autres, donc je ne peux pas te répondre.
Par contre, une option pour garder ta première solution:

Au début de ton main.c tu fais un:
Code:

1 2 #define MAIN_C
Et dans ton global.h, tu fais un:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #ifndef GLOBALES_H #define GLOBALES_H #ifdef MAIN_C #define EXTERN #else #define EXTERN extern #endif #ifdef MAIN_C EXTERN int toto = 0; EXTERN int tata = 0xFF; #else EXTERN int toto; EXTERN int tata; #endif #endif
Dans ce cas la, quand le main est compilé, les variables ne sont pas en externes et sont initialisées, et sinon non!!

16/06/2010, 19h55
gl

Citation:

Envoyé par Bktero

Mouais mouais mouais.... J'ai appliqué cette technique et j'ai passé une heure à comprendre pourquoi mon projet ne voulait plus linker. J'ai réussi à le faire linker, mais c'est un peu du bricolage.

Si tu souhaites utiliser cette méthode, il ne faut pas définir INIT_GLOBALES dans un .h mais dans un et seul .c qui inclue globales.h et le define doit nécessairement être avant tout .h qui pourrait inclure globales.h.

Citation:

Envoyé par Bktero

J'estime que si c'était bien fait, je n'aurais pas à m'occuper de ça.

Tu as tout à fait raison. Ton premier post ne parlait pas d'initialiser une variable, mais de comprendre le EXTERN. Personnellement, je ferai comme ça pour le h:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef SHARABLE_HEADER #define SHARABLE_HEADER // // section commune avec les typedef, protos de fonctions etc... // #ifndef SHARABLE_PRIVATE extern int toto; extern int tata; #endif #endif
Et comme ca pour le c:
Code:

1 2 3 4 5 #define SHARABLE_PRIVATE #include "sharable.h" int toto = 0; int tata = 0;
Ça permet de mettre dans le h tout ce qui est prototype de fonctions, typedef et define, mais ça oblige comme tu peux le constater à avoir 2 déclarations distinctes pour les variables globales, ce qui est je pense incontournable et lié aux globales. Ce n'est pas forcément la meilleure méthode (qui serait en fait de ne pas avoir de globales). S'il y a mieux, je suis preneur.

Citation:
Envoyé par pfeuh
Tu as tout à fait raison. Ton premier post ne parlait pas d'initialiser une variable, mais de comprendre le EXTERN. Personnellement, je ferai comme ça pour le h:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef SHARABLE_HEADER #define SHARABLE_HEADER // // section commune avec les typedef, protos de fonctions etc... // #ifndef SHARABLE_PRIVATE extern int toto; extern int tata; #endif #endif
Et comme ca pour le c:
Code:

1 2 3 4 5 #define SHARABLE_PRIVATE #include "sharable.h" int toto = 0; int tata = 0;
SHARABLE_PRIVATE est totalement inutile ici (tu peux tout à fait avec la déclaration avec extern et la définition dans la même unité de compilation).

Et c'est la méthode que j'avais expliqué dans le premier message, l'initialisation en plus (initialisation qui n'est d'ailleurs pas obligatoire dans le cas présent).

17/06/2010, 13h32
pfeuh
Citation:

Envoyé par gl

tu peux tout à fait avec la déclaration avec extern et la définition dans la même unité de compilation

Si je comprends bien ce que tu dis:
Citation:
Envoyé par gl

Code:

1 2 3 4 5 6 7 8 9 //global.h #ifndef GLOBAL_H #define GLOBAL_H extern int myGlobal; ... #endif

Code:

1 2 3 4 5 6 //global.c #include "global.h" int myGlobal; ...
après le travail du préprocesseur, on va avoir dans "global.c" quelque chose comme:
Code:

1 2 extern int myGlobal; int myGlobal;
Je pensais que le compilo ou le linker râlerait, mais non, je viens d'essayer.Merci gl, je viens d'apprendre quelque chose. ;)

Au final, j'avais tenté hier soir la solution que vient de poster GL, à peu de chose près (je n'incluais pas "global.h" dans "global.c"). Ca semble le plus simple dans mon cas.

Si je suis bien, ce code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #ifndef GLOBALES_H #define GLOBALES_H #ifdef MAIN_C #define EXTERN #else #define EXTERN extern #endif #ifdef MAIN_C EXTERN int toto = 0; EXTERN int tata = 0xFF; #else EXTERN int toto; EXTERN int tata; #endif #endif
, et en particulier le EXTERN, n'a pas d'intérêt non plus ?

Le coup du EXTERN ne sert que si l'initialisation des variables est fait ailleurs (et pas au moment d'une déclaration) ?