Réalisation d'un makefile et utilité ?

Bonjour,
Je me permets de me poster un message ici concernant les makefile et leur utilisation. (je suis un néophyte qui débute tout juste le langage C).
J'avais déjà récemment posté un message concernant l’exécution d'un algorithme implémentant la méthode LZW. (https://www.developpez.net/forums/d2...eme-execution/)
Je m'attaque maintenant aux makefile (qui ont l'air souvent utilisés)! De ce que j'ai compris pour le moment, ils servent à "créer" les exécutables des .c lorsqu'ils faut executer plusieurs actions.
Ma question est donc : sont-ils toujours préférables, quelle est leur utilité pour un utilisateur autre que le " créateur" et enfin, comme exemple, comment le réaliser et qu'apporterai-t-il au script LZW que j'ai précédemment évoqué (https://github.com/radekstepan/LZW) dans mon précédent poste.

Merci par avance pour vos retours.
Bonne journée.
Bien cordialement.

Chaka_Sobek

Make est un builder = un programme qui permet de gérer les dépendances entre différents fichiers d'un projet. Il permet de construire ce qu'il faut dans l'ordre et uniquement lorsque cela est nécessaire.
Make n'est pas le seul à faire ça mais c'est le plus ancien et le plus courant (on va dire) sous Unix.

Un makefile est un fichier interprété par Make qui décrit un projet particulier.

Ici on ne parle de script que pour les fichiers interprétés par un shell en général. Les .c sont nommés des sources. Leurs compilations produit des fichiers objets qui seront liés en un exécutable (ou une bibliothèque ou …).

Le plus simple pour apprendre Make est de commencer par la doc dispo ici → https://gl.developpez.com/tutoriel/outil/makefile/

Citation:

---

Envoyé par WhiteCrow

Make est un builder = un programme qui permet de gérer les dépendances entre différents fichiers d'un projet. Il permet de construire ce qu'il faut dans l'ordre et uniquement lorsque cela est nécessaire.
Make n'est pas le seul à faire ça mais c'est le plus ancien et le plus courant (on va dire) sous Unix.

Un makefile est un fichier interprété par Make qui décrit un projet particulier.

Ici on ne parle de script que pour les fichiers interprétés par un shell en général. Les .c sont nommés des sources. Leurs compilations produit des fichiers objets qui seront liés en un exécutable (ou une bibliothèque ou …).

Le plus simple pour apprendre Make est de commencer par la doc dispo ici → https://gl.developpez.com/tutoriel/outil/makefile/

---

Merci pour votre message! :)

Si j'ai bien compris ce que je viens de lire, le makefile donnerait quelque chose du genre :

Code:

---

1 2 3 4 5

lzw : lzw.o gcc -o lzw lzw.o lzw.o : lzw.c algorithms.c gcc -o lzw.o -c lzw.c -c algorithms.c (pas sûr de moi ..) ........ ainsi de suite

---

Pouvez-vous me le confirmer ?
Merci par avance.
Bonne soirée.

Chaka_Sobek

non

Dans un premier temps on définit le compilateur, les options de compilations, d'édition des liens, etc.

Code:

---

1 2 3 4

CC=gcc CFLAGS=-Wall -Wextra -g LDFLAGS=-lm #uniquement dans le cas où c'est nécessaire

---

Une fois cette étape effectuée il est habituel de définir une cible par défaut (pour ne pas avoir à la taper en ligne de commande) :

Code:

---

1 2 3

.PHONY: all all: lzw

---

la directive .PHONY indique à Make que la cible all doit toujours être prise en compte, même si un fichier all existe.

Ensuite il faut décrire le projet

Code:

---

1 2	lzw: lzw.o algorithms.o

---

Ici on indique que l'exécutable lzw sera construit à partir de l'édition des liens de deux fichiers objets : lzw.o et algorithms.o ; en outre il y a aura la prise en compte de la libm (spécifiée dans LDFLAGS).
Il n'y a rien besoin d'autre car Make sait comment faire ça.

Code:

---

1 2	lzw.o: lzw.c lzw.h

---

Ici on indique que le fichier objet est obtenu en compilant le lzw.c, Make à nouveau sait comment faire. On indique en plus que si un des fichiers lzw.c ou lzw.h est modifié par la suite il faudra recompiler lzw.c.

De manière similaire :

Code:

---

1 2	algorithms.o: algorithms.c algorithms.h lzw.h

---

J'extrapole en supposant qu'un fichier algorithms.h existe …

En général on dispose aussi d'une cible permettant de faire le ménage :

Code:

---

1 2 3 4 5 6 7 8

.PHONY: clean clean: <ici il y a une tabulation>${RM} algorithms.o lzw.o   .PHONY: cleanall cleanall: clean <ici il y a une tabulation>${RM} lzw

---

Il y a des moyens un peu plus complexes pour gérer les dépendances automatiquement mais c'est déjà un bon début.

Merci beaucoup!

Cependant, je ne comprends pas pourquoi pour lzw on précise qu'il dépend de lzw.o et algorithms.o mais à l'inverse on ne précise pas que algorithms.o dépend de algorithms.c qui dépend lui même de file.c, array.c, ...

Peux-tu m'éclairer sur ce point ?

Merci par avance.

Si il est bien précisé que algorithms.o dépend non seulement de algorithms.c, pour la compilation, mais également du header (s'il existe) et des headers inclus dans algorithms.c pour déclencher la construction.

Un fichier objet ne dépend (en général) que de son source et des headers inclus dans ce source. C'est le concept même de compilation séparée. Modifier un source ne doit déclencher la recompilation que du fichier objet associé, l'édition des liens se refaisant avec la nouvelle version de cet objet plus tous les autres qui n'ont pas eu besoin d'une recompilation.

Citation:

---

Je m'attaque maintenant aux makefile (qui ont l'air souvent utilisés)!

---

Euh non , a part les débutants qui veulent absolument la mano , personne en pro ne l'utilise (ou des amateur aguerri),il y'a des IDE ou des constructeur mieux foutu comme Cmake ou Xmake (qui permet entre autre de générer des makefile automatiquement ).

Bonjour

Citation:

---

Envoyé par WhiteCrow

Code:

---

lzw.o: lzw.c lzw.h

---

Ici on indique que le fichier objet est obtenu en compilant le lzw.c, Make à nouveau sait comment faire.

---

Moi il me semblait qu'il fallait le spécifier

Code:

---

1 2	lzw.o: lzw.c lzw.h $(CC) $(CFLAGS) -c lzw.c

---

En tout cas j'ai jamais essayé sans. Et malheureusement suis pas chez-moi pour tester... (enfin j'essayerai plus tard).

Normalement il y a les règles par défaut (en tout cas avec gnu make). On peut les consulter avec un make -p et par exemple pour compiler un source en objet on a :

Code:

---

1 2 3 4

%.o: %.c # recipe to execute (built-in): $(COMPILE.c) $(OUTPUT_OPTION) $<

---

avec :

Code:

---

1 2 3 4 5 6

# default OUTPUT_OPTION = -o $@ ... # default COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c

---

Je plussoie aussi à l'utilisation de CMake plutôt que d'écrire manuellement des Makefiles.