variables globales extern & implicite target Makefile ;
Salut les C,
J'ai un programme de plusieurs fichiers sources ayant chacun sont header et j'utilise un Makefile pour compiler chaque fichier *.c.
D'abords le sujet N° 1: les variables externes marqué extern.
J'ai une structure de type GUI ressemblant a ceci:
Code:
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
| /** File gui_structure.h . **/
typedef struct {
GtkWidget *icon ;
GtkWidget *label ;
GtkWidget *accel_label ;
} MenuItem ;
/** etc more typedef struct { ... } **/
typedef struct {
MenuItem files ;
MenuItem action ;
GtkWidget *hbox ;
// etc...
} GUI ;
// Etc... |
Puis j'ai un fichier de déclaration de variables globale:
Code:
1
2
3
| /** Files global_variables.h **/
GUI *gui ; |
Puis je me retrouve souvent a n'avoir besoin que de gui->notebook_editor ou gui->notebook_terminals, dans mes fichiers.
Alors dans mes fonctions je déclare:
Code:
1
2
3
4
5
6
7
8
| void callback(GtkWidget *widget, gpointer user_data) {
extern GUI *gui ;
// ...
return ;
} |
Alors j'ai un doute: est que ça serai mieux de déclarer un alias de gui->notebook_editor sous forme de pointeur déclarer comme une variable globale ?
Je ne le fait pas pour l'instant car je pense que si je déclare:
cela revient au même: copier l'adresse du pointeur de toute la structure GUI *gui c.a.d la taille d'un pointeur.
A la place d'utiliser un pointeur alias sur un seule GtkWidget *.
NOTE: je ne peut pas passer la variable gui par l'argument user_data.
Sinon j'ai un problème avec le Makefile.
Quand j'ajoute un fichier je l'ajoute a une liste (a savoir que l'arborescence est complexe).
Et j'aimerai utiliser le feature de règle implicite...
Code:
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
|
SRC_FILES = ./folder1/file1.c \
./folder2/file2.c \
./folder3/subfolder1/file3.c
TMP = $(notdir $(SRC_FILES:.c=.o))
OBJECTS = $(TMP:%=./build/%)
prgname: $(OBJECTS)
$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LDLIBS)
$(word 1, $(OBJECTS)): $(word 1, $(SRC_FILES))
$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LDLIBS)
# Etc ...
# My try for implicite rules build:
VPATH = ./folder1 ./folder2 ./folder3/subfolder1 ./build
%o: %c $(SRC_FILES) $(OBJECTS)
$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LDLIBS)
# What lack me to success implicte build ? |
Vous avez remarquer que j'utilise un dossier pour le build ce qui rend la chose plus difficile.
Merci pour vos réponses éclairées et votre précieuse aide.
Comment ont fait alors ???
Citation:
Citation Envoyé par Luke spywoker
Sinon je n'ai aucun problème avec mon programme et mes variables globales
Citation:
Tu n'en as pas parce que ton compilateur est « sympa » (ou pas) et qu'il considère la définition de gui inclue plusieurs fois comme une déclaration. Le mode par défaut de l'éditeur de liens doit faire le reste. C'est toutefois une erreur d'après la norme.
Bon merci, mais si je veut pas que mon compilateur soit `sympa' et respecter la norme y a t-il une options a passer a gcc a fin qu'il soit moins permissif ?
Je résume j'ai un fichier d'en-tête qui `déclare' mes variables globales comme la variable de type GUI que j'inclus dans les fichiers *.c ou j'ai besoin de ces variables globales.
Puis je les déclares comme extern dans les fonctions ou j'en ai besoin.
Je compiles plusieurs fichiers objet comme cela. Comment fait ont alors pour le faire correctement (ou plutôt selon la norme) ?
Car pour moi c'est déjà un petit exploit de compiler plusieurs fichiers objets en référençant toujours la même instance de variable globale...
PS: je l'ai dit plus haut il ne m'est pas toujours possible de passer en argument avec GTK+3.0.
Concernant make je ne comprends pas pas trop:
Citation:
Parmi tous les langages imbitables sortis des méandres des cerveaux névrosés des programmeurs, celui de Make est bien l'un des pires. Peu lisible, « error-prone »... De plus il n'est pas normalisé - contrairement à un système de build de haut niveau - ce qui signifie que tu n'as aucune garantie que ton makefile fonctionne ailleurs que sur ta distribution de développement.
Car les autotools se basent sur l'outil make, par le biais automake, sans compter ceux que je connais pas (Cmake) ???
J'ai lu le GNU Coding Standards et je pense que l'équipe de Stallman a écrit ce(s) document(s) afin de mettre en place des conventions afin que justement le programme soit le plus portable possible (je parle du système de build).
Mais je vous rassure mes projets n'ont pas besoins des autotools pour la phase de développement, et même:
Distribuer un Makefile.in écrit a la mains est dans la norme du GNU Coding standards, cela va avec la taille de mes projets et un peu de bon sens dans l'écriture du Makefile.
J'attends vos réponses éclairées avec impatience.
Mouarfs je vient de relire tout le poste et je me demande si j'inclue la définition aussi ou seulement dans le fichier main.c...
merci de m'avoir éclairé.
Merci pour vos explications.
J'ai compris le principe des variables globales et de extern.
En faîte on peut créer un fichier global_vars.c avec la définitions des variables globales (sans extern) que l'on va compiler.
Et créer un header passe partout avec les variables globales déclaré avec extern.
Merci d'avoir éclaircis ce point, vous pouvez allez vérifier si j'ai fait cela correctement dans mon dernier projet en développement.
Merci pour vos réponses éclairées illuminant les ténèbres de mon ignorance.
