Discussion :

[Misaki43]

Bonjour,

J'ai beau avoir cherché dans tous les sens je ne trouve pas de solution à mon problème.
à partir d'un fichier menu.c je veux appeler une fonction de forme "fifo(int P[], int nb)" qui se trouve dans un fichier "fifo.c".

On m'a dit que le fichier fifo.c ne doit pas contenir de main, car ce n'est pas le "fichier principal" : je suis censé me débrouillé avec uniquement le fichier sous forme "fifo.o"

Donc voilà je ne sais pas à partir du main du fichier menu.c appeler cette fonction. Pouvez vous m'aider?

(j'ai cru comprendre qu'il fallait utiliser la fonction execlp j'ai essayé execlp("./fifo.o", "fifo.o", "P[]", "n", 0) mais ça ne marche pas : ce n'est pas des "char" que je veux transmettre du coup ça pose un problème.

Voilà, merci de votre aide!

Misaki

[Neckara]

Bonjour,

Il faut que tu aie un fichier d'en-tête (.h) pour ton fichier fifo.c (donc fifo.h).
Cet en-tête devra déclarer les prototype des fonctions de fifo.c que tu souhaites utiliser ailleurs.
Il te suffit alors de faire un #include "fifo.h" dans ton fichier menu.c puis de compiler avec :

gcc menu.c fifo.c -o menu

si tu le fait en ligne de commande.

[Misaki43]

Bonjour Neckara,

Merci de votre réponse : j'y ai pensé mais sachant qu'on doit faire plusieurs fonctions de ce type (fifo.c sjf.c ... on en a 5,6) et que j'utilise déjà des .h je voulais éviter pour ne pas surcharger de bibliothèques mon programme.

N'y a t'il pas un autre moyen, avec notamment les execlp etc?

En tout cas maintenant j'ai déjà une solution, merci beaucoup!

[jabbounet]

Bonjour Neckara,

Merci de votre réponse : j'y ai pensé mais sachant qu'on doit faire plusieurs fonctions de ce type (fifo.c sjf.c ... on en a 5,6) et que j'utilise déjà des .h je voulais éviter pour ne pas surcharger de bibliothèques mon programme.

N'y a t'il pas un autre moyen, avec notamment les execlp etc?

En tout cas maintenant j'ai déjà une solution, merci beaucoup!

Attention au sens du mot bibliothèque aussi appelé librairie, car il a un sens un peu différent que celui que tu emploie en développement.

La solution indiquée par neckara ne crée pas de bibliothèque elle intègre les parties binaires relative a fifo directement dans l’exécutable.

Ensuite un programme peut être lié à une ou plusieurs bibliothèques de façon statique (le link statique est proche de la solution de neckara sauf qu'il n'y a pas de lib statique mais un .o) ou dynamique.

Sous linux tu trouvera les extension .so pour les librairies dynamiques et .a pour les libraries statiques.

il y'a beaucoup de littérature sur le net sur ces deux type de libraires.

[jabbounet]

(j'ai cru comprendre qu'il fallait utiliser la fonction execlp j'ai essayé execlp("./fifo.o", "fifo.o", "P[]", "n", 0) mais ça ne marche pas : ce n'est pas des "char" que je veux transmettre du coup ça pose un problème.

hello,

Pour compléter:
Execlp sert à appeler des programmes.

exemple:

Code :

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

1
2
 
 execlp( "ls",  "ls", "-l", "/usr", NULL );

la page de man est ici
http://linux.die.net/man/3/execlp

Donc, si tu souhaite passer par execlp pour utiliser fifo, il te faudra créer un programme avec fifo et donc un fonction main qui fasse la lecture des arguments et qui appelle les fonction de fifo en fonction de ces dernier.

je pense que la solution de neckara reste la plus simple et la plus courante pour le cas que tu décrit.

[ternel]

si tu veux expliciter la compilation

Préprocesseur et compilation:
"gcc fifo.c -c" génère fifo.o
"gcc main.c -c" génère main.o

édition de lien:
"gcc main.o fifo.o -o myapply" constitue l'exécutable myapply à partir des deux morceaux.

"gcc fifo.c main.c -o myapply" est un raccourci, qui ne laisse pas les fichiers .o (voire qui ne les crée qu'en ram)

[Misaki43]

Bonjour,

Merci pour toutes vos réponses!

j'ai essayé un makefile avec ce que vous dites mais ça ne marche pas le compilateur ne reconnait pas "myapply", après je me suis peu être trompée sur le makefile :

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
 
all :fifo SJF RR lecture
 
File.o : File.h File.c
	gcc -c File.c
File.a : File.o File.h
	ar -q File.a File.o
fifo : fifo.o File.a
	gcc -o fifo fifo.c File.a
SJF : SJF.o File.a 
	gcc -o SJF SJF.c File.a
RR : RR.o File.a
	gcc -o RR RR.c File.a
lecture : lecture.o File.a fifo.o SJF.o RR.o
	gcc fifo.c SJF.c RR.c -o lec lecture.c File.a myapply
clean :
	rm -f fifo.o RR.o SJF.o lecture.o File.o File.a fifo SJF RR lec

[ternel]

Quels sont les messages de la commande make?

J'ai l'impression qu'il ne peut pas compiler du tout, faute de savoir générer les .o

Par ailleurs, myapply est un nom arbitraire, qui vaut tes SJF, RR ou fifo

[kwariz]

Bonjour,

Merci pour toutes vos réponses!

j'ai essayé un makefile avec ce que vous dites mais ça ne marche pas le compilateur ne reconnait pas "myapply", après je me suis peu être trompée sur le makefile :

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
 
all :fifo SJF RR lecture
 
File.o : File.h File.c
	gcc -c File.c
File.a : File.o File.h
	ar -q File.a File.o
fifo : fifo.o File.a
	gcc -o fifo fifo.c File.a
SJF : SJF.o File.a 
	gcc -o SJF SJF.c File.a
RR : RR.o File.a
	gcc -o RR RR.c File.a
lecture : lecture.o File.a fifo.o SJF.o RR.o
	gcc fifo.c SJF.c RR.c -o lec lecture.c File.a myapply
clean :
	rm -f fifo.o RR.o SJF.o lecture.o File.o File.a fifo SJF RR lec

Ton makefile est certainement faux, en fait ce n'est pas le makefile mais ton découpage ou ta compréhension qui sont incorrects.

Peux-tu décrire où se trouve le main et ce que c'est myapply ?

Edit: oops, grillé par leternel !
Mais ce n'est pas une question de ne pouvoir compiler les .o (il y a les règles implicites).

[Misaki43]

Bonsoir,

Oui après coup j'ai compris que myappli était juste un exemple de nom de programme (au début je pensais que c'était une commande spéciale)
Désolé, j'assure pas avec les makefile : j'ai essayer de bien tout comprendre en cherchant sur internet mais rien à faire je m'embrouille. Maintenant le makefile compile bien mais je n'arrive pas a l'utiliser : je comprend pas bien ce que fait "myapply" il y a quoi dedans ?
moi ce que j'aimerais c'est dans lecture.c pouvoir appeler fifo.o en lui donnant en plus un paramètre en entrée : c'est possible avec ce que j'ai fait ?
Si vous avez un bon cours sur les makefile etc. pour éviter que je vous pause des questions bêtes je suis prenante (j'ai cherché mais j'ai pas compris grand chose et ya jamais d'exemple d'utilisation)
Enfin voilà mon makefile modifié :

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
 
all : lecture
 
File.o : File.h File.c
	gcc -c File.c
File.a : File.o File.h
	ar -q File.a File.o
fifo.o : fifo.c fifo.h File.a
	gcc -c fifo.c File.a
fifo.a : fifo.o fifo.h File.a
	ar -q fifo.a fifo.o File.a 
SJF.o : SJF.c SJF.h File.a
	gcc -c SJF.c File.a
SJF.a : SJF.o SJF.h File.a
	ar -q SJF.a SJF.o File.a 
RR.o : RR.c RR.h File.a
	gcc -c RR.c File.a 
RR.a : RR.o RR.h File.a
	ar -q RR.a RR.o File.a
lecture : lecture.o File.a fifo.a RR.a SJF.a
	gcc -o lecture lecture.c File.a fifo.a RR.a SJF.a
clean :
	rm -f *.o *.a

*edit : j'ai de nouveau modifié mon makefile avec que j'ai compris... j'ai fait à chaque fois des fifo.h sjf.h etc. mais le probleme est que ça ne compile pas on me dit que les types dans "File.h" sont redefinie plusieurs fois : du coup j'ai essayé en laissant "#include "File.h" que dans le programme principal mais ça ne marche pas mieux...

Resumé : si j'enleve "#include "File.h" des fifo.h etc. il reconnait plus les structures de File.h, si je les laisse le compilateur rale parce qu'il y a redefinition de File.h

Pouvez vous m'aider ?

[kwariz]

Bon, on "appelle" pas un fichier objet (.o). Un fichier objet ce n'est qu'un fichier qui contient le code compilé trouvé dans un fichier source.
Pour simplifier le process ressemble à :

1 fichier source .c ---[préprocesseur + compilateur]---> 1 fichier objet .o
plusieurs fichiers objets .o ---[éditeur de liens]---> 1 exécutable

Un fichier objet n'est qu'un fichier qui contient le code compilé des fonctions définies dans le fichier source. Quand tu crées un fichier objet, le source associé peut faire appel à des fonctions qu'il ne connait que de nom (ce qui est déclaré dans le header .h), ce sera l'éditeur de liens (qui porte bien son nom) qui fera le lien entre les appels et le code.

Donc une bonne pratique pour débuter en makefile est de simplement décrire tout ça :

Code :

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

1
2
3
4
5
File.o: File.h File.c
        gcc -c File.c
....
lecture.o: lecture.c File.h fifo.h RR.h SJF.h
        gcc -c lecture.c

C'est la partie qui crée tous les fichiers objets.

Ensuite tu décris comment construire l'exécutable :

Code :

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

1
2
lecture: lecture.o File.o fifo.o RR.o SJF.o
        gcc -o lecture lecture.o File.o fifo.o RR.o SJF.o

Bon c'est brut de décoffrage car la syntaxe des makefile te permet plus de choses (définir des variables, des comportements par défauts, ...)

Oublie les bibliothèques statiques (.a) pour l'instant.

Ensuite as-tu bien dans chaque header les balises qui empèchent les inclusions multiples ? Par exemple au début de File.h tu dois avoir :

Code :

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

1
2
#ifndef __file_h__
#define __file_h__

et en fin :

Code :

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

#endif /* __file_h__ */

(où le symbole définit est différent pour chaque header). Tu comprends comment cela fonctionne ?

[ternel]

En fait, les questions, ce sont: comprends-tu comment fonctionne un include? et comment fonctionne la compilation?

Le préprocesseur remplace un #include est directement par le fichier inclus, puis continue son travail avec la ligne actuelle: la première du fichier inclus, donc.

La compilation génère des fichiers .o (dit "objets") qui sont ensuite assemblé en un exécutable.
La commande gcc permet de ne pas conserver (voire ne pas créer sur le disque) ces fichiers .o, quand on compile directement l'executable.

Pour make, il faut comprendre la philosophie
make est un exécuteur de makefiles, qui sont des descriptions de relations de dépendance et des scripts.

en gros, la commande make construit la première cible du makefile, tandis que make cible1 cible2 ne construit que les cibles cible1 et cible2.

la structure du makefile est donc:

Code :

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

1
2
3
4
cible : prérequis1 prérequis2 ...
	première commande à exécuter pour établir cible
	deuxième commande à exécuter pour établir cible
	...

Une cible est constructible que si ses dépendances sont construites.
Une cible est considéré construite:

• si le fichier nommé par la cible est plus récent que chacun des fichiers nommés par ses dépendances
• ou si la cible a été construite par l'exécution courante du makefile

Les commandes de constructions peuvent être n'importe lesquelles, mais l'ensemble des commandes d'une cible devrait aboutir à la création d'un fichier portant le nom de la cible.

Il est possible d'avoir des cibles sans commandes pour établir des dépendances. Il ne peut y avoir qu'une seule définition de cible possédant des commandes.
Pour plus d'informations sur make, regarde le man de make ou les cours de Emmanuel Delahaye et un autre collaborateur (pardon de ne pas avoir trouvé son nom)

[Misaki43]

Bonjour,

Je viens de lire vos deux posts, ils sont très complet, merci beaucoup!
C'est exactement de ça que j'avais besoin, un récapitulatif de l'utilisation du makefile, après je n'ai pas traité en cours les

Code :

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

1
2
#ifndef __file_h__
#define __file_h__

je les avais juste vu dans les corrections des professeurs sans en comprendre l'intérêt : ça parait logique que ce soit ça mon problème :

Bref, encore une fois un grand merci je trouve ça limpide, maintenant je vais essayer de tout refaire le makefile, on verra si c'est aussi simple que ça n'y parait (j'éditerais pour vous ternir au courant)

EDIT : Bon et bien j'ai essayé mais il y a des problèmes :
Finalement pas sure d'avoir compris :
- le #ifndef__file_h__ est que dans file.h mais dans chaque "fifo.h" et companie il y a un " #ifndef __fifo_h__" c'est ça ? ça permet d'éviter d'essayer de redefinir plusieurs fois les fonctions du fichiers c'est ça ?

En tout cas là il y a écrit pour chaque .c : "undefined reference to 'fonctionDeFile.h' "
Pourtant dans chaque entête j'ai "#include "File.h" " donc je ne comprend pas.
C'est pas parce que j'ai plus de librairie File.a par hasard ?

2e edit : (désolé) En fait j'avais oublié de mettre file.h... ça a l'air de bien fonctionner, merci beaucoup!

[kwariz]

...
EDIT : Bon et bien j'ai essayé mais il y a des problèmes :
Finalement pas sure d'avoir compris :
- le #ifndef__file_h__ est que dans file.h mais dans chaque "fifo.h" et companie il y a un " #ifndef __fifo_h__" c'est ça ? ça permet d'éviter d'essayer de redefinir plusieurs fois les fonctions du fichiers c'est ça ?

Oui c'est ça. Juste qu'en général, mais ce n'est qu'une question de vocabulaire, on parle de déclarations quand on a que le prototype comme dans les header. Tu déclares qu'une fonction nommée XXX existe et qu'elle tels types de paramètre et qu'elle renvoie tel type.
Ensuite dans un fichier source tu définis la fonction : tu en donnes le code.

En tout cas là il y a écrit pour chaque .c : "undefined reference to 'fonctionDeFile.h' "
Pourtant dans chaque entête j'ai "#include "File.h" " donc je ne comprend pas.
C'est pas parce que j'ai plus de librairie File.a par hasard ?

Balance ton code parce que là c'est vague et on parle dans le vide.

[Misaki43]

Je crois que vous n'avez pas vu mon troisième "edit" maintenant ça marche : dans le makefile j'avais oublié de mettre dans les "prérequis" pour la création de lecture le "File.h" d'où le fait qu'il ne trouve pas la déclaration des fonctions de File.h

En tout cas merci, ça a l'air de marcher!

[ternel]

On est bien d'accord que le .h est dans les dépendance indiquées dans le makefile uniquement pour s'assurer que le code soit bien recompilé si l'entête change?

[Misaki43]

Bonjour!

Je n'ai pas compris votre question : quelle entête

[ternel]

Le seul que tu aies: File.h.

Un .h (h pour header) ne doit contenir que des déclarations et des définitions de macros, donc il n'est pas compilé pour lui-même, et n'ai dans le makefile pour dire que tel .o utilise (entre autres) cet en-tête.