Makefile - Guide rapide

Compiler les fichiers de code source peut être fatigant, en particulier lorsque vous devez inclure plusieurs fichiers source et taper la commande de compilation à chaque fois que vous devez compiler. Les makefiles sont la solution pour simplifier cette tâche.

Les makefiles sont des fichiers de format spécial qui aident à construire et à gérer les projets automatiquement.

Par exemple, supposons que nous ayons les fichiers source suivants.

• main.cpp
• hello.cpp
• factorial.cpp
• functions.h

main.cpp

Voici le code du fichier source main.cpp -

#include <iostream>

using namespace std;

#include "functions.h"

int main(){
   print_hello();
   cout << endl;
   cout << "The factorial of 5 is " << factorial(5) << endl;
   return 0;
}

hello.cpp

Le code donné ci-dessous est pour le fichier source hello.cpp -

#include <iostream>

using namespace std;

#include "functions.h"

void print_hello(){
   cout << "Hello World!";
}

factorial.cpp

Le code pour factorial.cpp est donné ci-dessous -

#include "functions.h"

int factorial(int n){
   
   if(n!=1){
      return(n * factorial(n-1));
   } else return 1;
}

functions.h

Ce qui suit est le code pour fnctions.h -

void print_hello();
int factorial(int n);

Le moyen le plus simple de compiler les fichiers et d'obtenir un exécutable consiste à exécuter la commande -

gcc  main.cpp hello.cpp factorial.cpp -o hello

Cette commande génère bonjour binaire. Dans cet exemple, nous n'avons que quatre fichiers et nous connaissons la séquence des appels de fonction. Par conséquent, il est possible de taper la commande ci-dessus et de préparer un binaire final.

Cependant, pour un grand projet où nous avons des milliers de fichiers de code source, il devient difficile de maintenir les versions binaires.

le makeLa commande vous permet de gérer de grands programmes ou des groupes de programmes. Lorsque vous commencez à écrire de grands programmes, vous remarquez que la recompilation de grands programmes prend plus de temps que la recompilation de programmes courts. De plus, vous remarquez que vous ne travaillez généralement que sur une petite section du programme (comme une seule fonction) et qu'une grande partie du programme restant reste inchangée.

Dans la section suivante, nous verrons comment préparer un makefile pour notre projet.

le makeprogramme vous permet d'utiliser des macros, qui sont similaires aux variables. Les macros sont définies dans un Makefile comme = paires. Un exemple a été montré ci-dessous -

MACROS  = -me
PSROFF  = groff -Tps
DITROFF = groff -Tdvi
CFLAGS  = -O -systype bsd43
LIBS    = "-lncurses -lm -lsdl"
MYFACE  = ":*)"

Macros spéciales

Avant d'émettre une commande dans un ensemble de règles cible, certaines macros spéciales sont prédéfinies -

• $ @ est le nom du fichier à créer.

• $? correspond aux noms des personnes à charge modifiées.

Par exemple, nous pourrions utiliser une règle comme suit -

hello: main.cpp hello.cpp factorial.cpp
   $(CC) $(CFLAGS) $? $(LDFLAGS) -o $@

Alternatively:

hello: main.cpp hello.cpp factorial.cpp
   $(CC) $(CFLAGS) [email protected] $(LDFLAGS) -o $@

Dans cet exemple, $ @ représente bonjour et $? ou $ @. cpp récupère tous les fichiers source modifiés.

Il existe deux autres macros spéciales utilisées dans les règles implicites. Ils sont -

• $ <le nom du fichier associé qui a provoqué l'action.

• $ * le préfixe partagé par les fichiers cibles et dépendants.

La règle implicite commune est pour la construction de fichiers .o (objet) à partir de .cpp (fichiers source).

.cpp.o:
   $(CC) $(CFLAGS) -c $<

Alternatively:

.cpp.o:
   $(CC) $(CFLAGS) -c $*.c

Macros conventionnelles

Il existe différentes macros par défaut. Vous pouvez les voir en tapant "make -p" pour afficher les valeurs par défaut. La plupart sont assez évidents d'après les règles dans lesquelles ils sont utilisés.

Ces variables prédéfinies, c'est-à-dire les macros utilisées dans les règles implicites, se répartissent en deux classes. Ils sont les suivants -

• Macros qui sont des noms de programmes (tels que CC)

• Macros contenant des arguments des programmes (tels que CFLAGS).

Vous trouverez ci-dessous un tableau de certaines des variables courantes utilisées comme noms de programmes dans les règles intégrées de makefiles -

Sr.Non	Variables et description
1	AR Programme de conservation des archives; la valeur par défaut est «ar».
2	AS Programme de compilation de fichiers d'assemblage; la valeur par défaut est «as».
3	CC Programme de compilation de programmes C; la valeur par défaut est «cc».
4	CO Programme d'extraction de fichiers depuis RCS; la valeur par défaut est «co».
5	CXX Programme de compilation de programmes C ++; la valeur par défaut est «g ++».
6	CPP Programme pour exécuter le préprocesseur C, avec des résultats à la sortie standard; La valeur par défaut est «$ (CC) -E».
sept	FC Programme de compilation ou de prétraitement des programmes Fortran et Ratfor; la valeur par défaut est «f77».
8	GET Programme pour extraire un fichier de SCCS; la valeur par défaut est «get».
9	LEX Programme à utiliser pour transformer les grammaires Lex en code source; la valeur par défaut est «lex».
dix	YACC Programme à utiliser pour transformer les grammaires Yacc en code source; la valeur par défaut est «yacc».
11	LINT Programme à utiliser pour exécuter lint sur le code source; la valeur par défaut est «lint».
12	M2C Programme à utiliser pour compiler le code source de Modula-2; la valeur par défaut est «m2c».
13	PC Programme de compilation de programmes Pascal; la valeur par défaut est «pc».
14	MAKEINFO Programme pour convertir un fichier source Texinfo en un fichier Info; la valeur par défaut est «makeinfo».
15	TEX Programme pour créer des fichiers TeX dvi à partir de la source TeX; la valeur par défaut est «tex».
16	TEXI2DVI Programme pour créer des fichiers TeX dvi à partir de la source Texinfo; la valeur par défaut est «texi2dvi».
17	WEAVE Programme pour traduire le Web en TeX; la valeur par défaut est «tissage».
18	CWEAVE Programme pour traduire C Web en TeX; la valeur par défaut est «cweave».
19	TANGLE Programme de traduction du Web en Pascal; la valeur par défaut est «enchevêtrement».
20	CTANGLE Programme pour traduire C Web en C; la valeur par défaut est «ctangle».
21	RM Commande pour supprimer un fichier; la valeur par défaut est «rm -f».

Voici un tableau de variables dont les valeurs sont des arguments supplémentaires pour les programmes ci-dessus. Sauf indication contraire, les valeurs par défaut pour tous ces éléments sont la chaîne vide.

Sr.No.	Variables et description
1	ARFLAGS Drapeaux pour donner le programme de maintenance des archives; la valeur par défaut est «rv».
2	ASFLAGS Indicateurs supplémentaires à donner à l'assembleur lorsqu'il est explicitement appelé sur un fichier `.s 'ou` .S'.
3	CFLAGS Drapeaux supplémentaires à donner au compilateur C.
4	CXXFLAGS Drapeaux supplémentaires à donner au compilateur C.
5	COFLAGS Drapeaux supplémentaires à donner au programme RCS co.
6	CPPFLAGS Drapeaux supplémentaires à donner au préprocesseur C et aux programmes qui l'utilisent (comme les compilateurs C et Fortran).
sept	FFLAGS Drapeaux supplémentaires à donner au compilateur Fortran.
8	GFLAGS Drapeaux supplémentaires à donner au programme get SCCS.
9	LDFLAGS Des indicateurs supplémentaires à donner aux compilateurs lorsqu'ils sont censés invoquer l'éditeur de liens, `ld '.
dix	LFLAGS Drapeaux supplémentaires à donner à Lex.
11	YFLAGS Drapeaux supplémentaires à donner à Yacc.
12	PFLAGS Drapeaux supplémentaires à donner au compilateur Pascal.
13	RFLAGS Drapeaux supplémentaires à donner au compilateur Fortran pour les programmes Ratfor.
14	LINTFLAGS Drapeaux supplémentaires à donner aux peluches.

NOTE - Vous pouvez annuler toutes les variables utilisées par les règles implicites avec l'option '-R' ou '--no-builtin-variables'.

Vous pouvez également définir des macros sur la ligne de commande comme indiqué ci-dessous -

make CPP = /home/courses/cop4530/spring02

Il est très courant qu'un binaire final dépende de divers fichiers de code source et d'en-tête source. Les dépendances sont importantes car elles laissentmakeConnu sur la source de n'importe quelle cible. Prenons l'exemple suivant -

hello: main.o factorial.o hello.o
   $(CC) main.o factorial.o hello.o -o hello

Ici, nous disons au makeque bonjour dépend des fichiers main.o, factorial.o et hello.o. Par conséquent, chaque fois qu'il y a un changement dans l'un de ces fichiers objets,make prendra des mesures.

En même temps, nous devons dire au makecomment préparer les fichiers .o. Par conséquent, nous devons définir ces dépendances également comme suit -

main.o: main.cpp functions.h
   $(CC) -c main.cpp

factorial.o: factorial.cpp functions.h
   $(CC) -c factorial.cpp

hello.o: hello.cpp functions.h
   $(CC) -c hello.cpp

Nous allons maintenant apprendre les règles de Makefile.

La syntaxe générale d'une règle cible Makefile est -

target [target...] : [dependent ....]
[ command ...]

Dans le code ci-dessus, les arguments entre crochets sont facultatifs et les points de suspension signifient un ou plusieurs. Ici, notez que l'onglet précédant chaque commande est obligatoire.

Un exemple simple est donné ci-dessous où vous définissez une règle pour rendre votre cible bonjour à partir de trois autres fichiers.

hello: main.o factorial.o hello.o
   $(CC) main.o factorial.o hello.o -o hello

NOTE - Dans cet exemple, vous devrez donner des règles pour créer tous les fichiers objets à partir des fichiers source.

La sémantique est très simple. Lorsque vous dites "ciblez", lemaketrouve la règle cible qui s'applique; et, si l'une des personnes à charge est plus récente que la cible,makeexécute les commandes une par une (après substitution de macro). Si des dépendants doivent être créés, cela se produit en premier (vous avez donc une récursivité).

Makese termine si une commande renvoie un état d'échec. La règle suivante sera affichée dans ce cas -

clean:
   -rm *.o *~ core paper

Makeignore l'état renvoyé sur les lignes de commande commençant par un tiret. Par exemple, qui se soucie s'il n'y a pas de fichier de base?

Makefait écho aux commandes, après la substitution de macro pour vous montrer ce qui se passe. Parfois, vous voudrez peut-être désactiver cela. Par exemple -

install:
   @echo You must be root to install

Les gens s'attendent à certaines cibles dans Makefiles. Vous devez toujours naviguer en premier. Cependant, il est raisonnable de s'attendre à ce que toutes les cibles (ou simplement créer), installer et nettoyer soient trouvées.

• make all - Il compile tout pour que vous puissiez faire des tests locaux avant d'installer des applications.

• make install - Il installe les applications aux bons endroits.

• make clean - Il nettoie les applications, supprime les exécutables, les fichiers temporaires, les fichiers objets, etc.

Règles implicites Makefile

La commande est celle qui devrait fonctionner dans tous les cas où nous construisons un exécutable x à partir du code source x.cpp. Cela peut être énoncé comme une règle implicite -

.cpp:
   $(CC) $(CFLAGS) [email protected] $(LDFLAGS) -o $@

Cette règle implicite indique comment créer x à partir de xc - exécuter cc sur xc et appeler la sortie x. La règle est implicite car aucune cible particulière n'est mentionnée. Il peut être utilisé dans tous les cas.

Une autre règle implicite courante est la construction de fichiers .o (objets) à partir de .cpp (fichiers sources).

.cpp.o:
   $(CC) $(CFLAGS) -c $<

alternatively

.cpp.o:
   $(CC) $(CFLAGS) -c $*.cpp

Makepeut créer automatiquement un fichier ao, en utilisant cc -c sur le fichier .c correspondant. Ces règles sont intégrées aumake, et vous pouvez profiter de cet avantage pour raccourcir votre Makefile. Si vous indiquez uniquement les fichiers .h dans la ligne de dépendance du Makefile dont dépend la cible actuelle,makesaura que le fichier .c correspondant est déjà requis. Vous n'avez pas besoin d'inclure la commande du compilateur.

Cela réduit davantage le Makefile, comme indiqué ci-dessous -

OBJECTS = main.o hello.o factorial.o
hello: $(OBJECTS)
   cc $(OBJECTS) -o hello
hellp.o: functions.h

main.o: functions.h 
factorial.o: functions.h

Makeutilise une cible spéciale, nommée .SUFFIXES pour vous permettre de définir vos propres suffixes. Par exemple, reportez-vous à la ligne de dépendance donnée ci-dessous -

.SUFFIXES: .foo .bar

Il informe make que vous utiliserez ces suffixes spéciaux pour créer vos propres règles.

Similaire à comment makesait déjà créer un fichier .o à partir d'un fichier .c , vous pouvez définir des règles de la manière suivante -

.foo.bar:
   tr '[A-Z][a-z]' '[N-Z][A-M][n-z][a-m]' < $< > $@
.c.o:
   $(CC) $(CFLAGS) -c $<

La première règle vous permet de créer un fichier .bar à partir d'un fichier .foo . Cela brouille essentiellement le fichier. La deuxième règle est la règle par défaut utilisée parmakepour créer un fichier .o à partir d'un fichier .c .

Il existe de nombreuses directives disponibles sous diverses formes. lemakeprogramme sur votre système peut ne pas prendre en charge toutes les directives. Veuillez donc vérifier si votremake soutient les directives que nous expliquons ici. GNU make soutient ces directives.

Directives conditionnelles

Les directives conditionnelles sont -

• le ifeqdirective commence le conditionnel et spécifie la condition. Il contient deux arguments, séparés par une virgule et entourés de parenthèses. La substitution de variable est effectuée sur les deux arguments, puis ils sont comparés. Les lignes du makefile suivant l'ifeq sont respectées si les deux arguments correspondent; sinon, ils sont ignorés.

• le ifneqdirective commence le conditionnel et spécifie la condition. Il contient deux arguments, séparés par une virgule et entourés de parenthèses. La substitution de variable est effectuée sur les deux arguments, puis ils sont comparés. Les lignes du makefile suivant l'ifneq sont respectées si les deux arguments ne correspondent pas; sinon, ils sont ignorés.

• le ifdefdirective commence le conditionnel et spécifie la condition. Il contient un seul argument. Si l'argument donné est vrai, la condition devient vraie.

• le ifndefdirective commence le conditionnel et spécifie la condition. Il contient un seul argument. Si l'argument donné est faux, la condition devient vraie.

• le elsedirective entraîne le respect des lignes suivantes si le conditionnel précédent a échoué. Dans l'exemple ci-dessus, cela signifie que la deuxième commande de liaison alternative est utilisée chaque fois que la première alternative n'est pas utilisée. Il est facultatif d'avoir un else dans un conditionnel.

• le endifdirective met fin au conditionnel. Chaque conditionnel doit se terminer par un endif.

Syntaxe des directives conditionnelles

La syntaxe d'un conditionnel simple sans autre est la suivante -

conditional-directive
   text-if-true
endif

Le text-if-true peut être n'importe quelle ligne de texte, à considérer comme faisant partie du makefile si la condition est vraie. Si la condition est fausse, aucun texte n'est utilisé à la place.

La syntaxe d'un conditionnel complexe est la suivante -

conditional-directive
   text-if-true
else
   text-if-false
endif

Si la condition est vraie, text-if-true est utilisé; sinon, text-if-false est utilisé. Le text-if-false peut être n'importe quel nombre de lignes de texte.

La syntaxe de la directive conditionnelle est la même que le conditionnel soit simple ou complexe. Il existe quatre directives différentes qui testent diverses conditions. Ils sont comme donnés -

ifeq (arg1, arg2)
ifeq 'arg1' 'arg2'
ifeq "arg1" "arg2"
ifeq "arg1" 'arg2'
ifeq 'arg1' "arg2"

Les directives opposées des conditions ci-dessus sont les suivantes -

ifneq (arg1, arg2)
ifneq 'arg1' 'arg2'
ifneq "arg1" "arg2"
ifneq "arg1" 'arg2'
ifneq 'arg1' "arg2"

Exemple de directives conditionnelles

libs_for_gcc = -lgnu
normal_libs =

foo: $(objects)
ifeq ($(CC),gcc)
   $(CC) -o foo $(objects) $(libs_for_gcc)
else
   $(CC) -o foo $(objects) $(normal_libs)
endif

La directive inclure

le include directive permet makepour suspendre la lecture du makefile courant et lire un ou plusieurs autres makefiles avant de continuer. La directive est une ligne dans le makefile qui ressemble à -

include filenames...

Les noms de fichiers peuvent contenir des modèles de noms de fichiers shell. Les espaces supplémentaires sont autorisés et ignorés au début de la ligne, mais une tabulation n'est pas autorisée. Par exemple, si vous avez trois fichiers `.mk ', à savoir,` a.mk', `b.mk ', et` c.mk', et $ (bar) alors il se développe en bish bash, puis ce qui suit expression.

include foo *.mk $(bar)

is equivalent to:

include foo a.mk b.mk c.mk bish bash

Quand le maketraite une directive d'inclusion, il suspend la lecture du makefile et lit tour à tour chaque fichier répertorié. Quand c'est fini,make reprend la lecture du makefile dans lequel la directive apparaît.

La directive dérogatoire

Si une variable a été définie avec un argument de commande, les affectations ordinaires dans le makefile sont ignorées. Si vous voulez définir la variable dans le makefile même si elle a été définie avec un argument de commande, vous pouvez utiliser une directive override, qui est une ligne qui ressemble à la suite -

override variable = value

or

override variable := value

le makeprogramme est un utilitaire intelligent et fonctionne en fonction des modifications que vous effectuez dans vos fichiers source. Si vous avez quatre fichiers main.cpp, hello.cpp, factorial.cpp et functions.h, alors tous les fichiers restants dépendent de functions.h et main.cpp dépend à la fois de hello.cpp et factorial.cpp. Par conséquent, si vous apportez des modifications à functions.h, alors lemakerecompile tous les fichiers source pour générer de nouveaux fichiers objets. Cependant, si vous apportez des modifications à main.cpp, car cela ne dépend d'aucun autre fichier, seul le fichier main.cpp est recompilé, et help.cpp et factorial.cpp ne le sont pas.

Lors de la compilation d'un fichier, le makevérifie son fichier objet et compare les horodatages. Si le fichier source a un horodatage plus récent que le fichier objet, il génère un nouveau fichier objet en supposant que le fichier source a été modifié.

Éviter la recompilation

Il peut y avoir un projet composé de milliers de fichiers. Parfois, vous avez peut-être modifié un fichier source mais vous ne souhaiterez peut-être pas recompiler tous les fichiers qui en dépendent. Par exemple, supposons que vous ajoutiez une macro ou une déclaration à un fichier d'en-tête, dont dépendent les autres fichiers. Être conservateur,make suppose que tout changement dans le fichier d'en-tête nécessite une recompilation de tous les fichiers dépendants, mais vous savez qu'ils n'ont pas besoin de recompilation et vous préférez ne pas perdre votre temps à attendre qu'ils soient compilés.

Si vous anticipez le problème avant de modifier le fichier d'en-tête, vous pouvez utiliser l'indicateur `-t '. Ce drapeau ditmakenon pas pour exécuter les commandes dans les règles, mais plutôt pour marquer la cible à jour en changeant sa date de dernière modification. Vous devez suivre cette procédure -

• Utilisez la commande `make 'pour recompiler les fichiers source qui ont vraiment besoin d'une recompilation.

• Apportez les modifications aux fichiers d'en-tête.

• Utilisez la commande «make -t» pour marquer tous les fichiers objets comme à jour. La prochaine fois que vous exécutez make, les modifications apportées aux fichiers d'en-tête n'entraînent aucune recompilation.

Si vous avez déjà modifié le fichier d'en-tête à un moment où certains fichiers nécessitent une recompilation, il est trop tard pour le faire. À la place, vous pouvez utiliser l'indicateur `-o file ', qui marque un fichier spécifié comme" ancien ". Cela signifie que le fichier lui-même ne sera pas refait, et rien d'autre ne sera refait sur son compte. vous devez suivre cette procédure -

• Recompilez les fichiers source qui ont besoin de compilation pour des raisons indépendantes du fichier d'en-tête particulier, avec `make -o header file '. Si plusieurs fichiers d'en-tête sont impliqués, utilisez une option `-o 'distincte pour chaque fichier d'en-tête.

• Mettez à jour tous les fichiers objets avec `make -t '.

Dans ce chapitre, nous examinerons diverses autres fonctionnalités de Makefile.

Utilisation récursive de Make

Utilisation récursive de make signifie utiliser makeen tant que commande dans un makefile. Cette technique est utile lorsque vous voulez des fichiers Make séparés pour différents sous-systèmes qui composent un système plus grand. Par exemple, supposons que vous ayez un sous-répertoire nommé `subdir 'qui a son propre makefile, et que vous souhaitiez que le makefile du répertoire contenant s'exécutemakedans le sous-répertoire. Vous pouvez le faire en écrivant le code ci-dessous -

subsystem:
   cd subdir && $(MAKE)

or, equivalently:
 	
subsystem:
   $(MAKE) -C subdir

Vous pouvez écrire récursif makecommandes simplement en copiant cet exemple. Cependant, vous devez savoir comment ils fonctionnent et pourquoi, et comment la sous-marque est liée à la marque de niveau supérieur.

Communication de variables à une sous-marque

Valeurs variables du niveau supérieur makepeut être passé au sous-make via l'environnement par requête explicite. Ces variables sont définies par défaut dans la sous-marque. Vous ne pouvez pas remplacer ce qui est spécifié dans le makefile utilisé par le makefile du sous-make à moins d'utiliser le commutateur `-e '.

Pour transmettre ou exporter une variable, makeajoute la variable et sa valeur à l'environnement pour exécuter chaque commande. La sous-marque, à son tour, utilise l'environnement pour initialiser sa table de valeurs de variables.

Les variables spéciales SHELL et MAKEFLAGS sont toujours exportées (sauf si vous les annulez). MAKEFILES est exporté si vous le définissez sur quelque chose.

Si vous souhaitez exporter des variables spécifiques vers une sous-marque, utilisez la directive d'exportation, comme indiqué ci-dessous -

export variable ...

Si vous souhaitez empêcher l'exportation d'une variable, utilisez la directive unxport, comme indiqué ci-dessous -

unexport variable ...

La variable MAKEFILES

Si la variable d'environnement MAKEFILES est définie, makeconsidère sa valeur comme une liste de noms (séparés par un espace) de makefiles supplémentaires à lire avant les autres. Cela fonctionne un peu comme la directive include: dans divers répertoires sont recherchés ces fichiers.

L'utilisation principale de MAKEFILES est la communication entre les invocations récursives du make.

Inclure le fichier d'en-tête de différents répertoires

Si vous avez placé les fichiers d'en-tête dans différents répertoires et que vous exécutez makedans un répertoire différent, il est alors nécessaire de fournir le chemin des fichiers d'en-tête. Cela peut être fait en utilisant l'option -I dans makefile. En supposant que le fichier functions.h est disponible dans le dossier / home / tutorialspoint / header et que le reste des fichiers est disponible dans le dossier / home / tutorialspoint / src /, alors le makefile serait écrit comme suit -

INCLUDES = -I "/home/tutorialspoint/header"
CC = gcc
LIBS =  -lm
CFLAGS = -g -Wall
OBJ =  main.o factorial.o hello.o

hello: ${OBJ}
   ${CC} ${CFLAGS} ${INCLUDES} -o $@ ${OBJS} ${LIBS}
.cpp.o:
   ${CC} ${CFLAGS} ${INCLUDES} -c $<

Ajouter plus de texte aux variables

Il est souvent utile d'ajouter plus de texte à la valeur d'une variable déjà définie. Vous faites cela avec une ligne contenant `+ = ', comme indiqué -

objects += another.o

Il prend la valeur des objets variables et y ajoute le texte «another.o», précédé d'un seul espace comme indiqué ci-dessous.

objects = main.o hello.o factorial.o
objects += another.o

Le code ci-dessus définit les objets sur `main.o hello.o factorial.o another.o '.

L'utilisation de `+ = 'est similaire à:

objects = main.o hello.o factorial.o
objects := $(objects) another.o

Ligne de continuation dans Makefile

Si vous n'aimez pas les lignes trop grandes dans votre Makefile, vous pouvez couper votre ligne en utilisant une barre oblique inverse "\" comme indiqué ci-dessous -

OBJ =  main.o factorial.o \
   hello.o

is equivalent to

OBJ =  main.o factorial.o hello.o

Exécution de Makefile à partir de l'invite de commande

Si vous avez préparé le Makefile avec le nom "Makefile", écrivez simplement make à l'invite de commande et il exécutera le fichier Makefile. Mais si vous avez donné un autre nom au Makefile, utilisez la commande suivante -

make -f your-makefile-name

Voici un exemple du Makefile pour compiler le programme hello. Ce programme se compose de trois fichiers main.cpp , factorial.cpp et hello.cpp .

# Define required macros here
SHELL = /bin/sh

OBJS =  main.o factorial.o hello.o
CFLAG = -Wall -g
CC = gcc
INCLUDE =
LIBS = -lm

hello:${OBJ}
   ${CC} ${CFLAGS} ${INCLUDES} -o $@ ${OBJS} ${LIBS}

clean:
   -rm -f *.o core *.core

.cpp.o:
   ${CC} ${CFLAGS} ${INCLUDES} -c $<

Vous pouvez maintenant créer votre programme hello en utilisant le make. Si vous émettez une commandemake clean puis il supprime tous les fichiers objets et fichiers core disponibles dans le répertoire courant.