Makefile pour compiler plusieurs programmes en C?

C'est un incroyablement simple question, mais je suis nouveau sur makefiles. Je suis en train de faire un makefile qui va compiler les deux programmes indépendants:

program1:
    gcc -o prog1 program1.c

program2:
    gcc -o prog2 program2.c

Tous les exemples en ligne aller dans la façon dont plus de détails que j'ai besoin et qui sont source de confusion! Tout ce que je veux vraiment faire est d'exécuter les deux gcc lignes. Ce que je fais mal?

Les réponses ci-dessous sont très claires, mais vous pouvez aussi exécuter la ligne de commande: make program1 program2 qui invoque à la fois la cible dans l'exemple que vous avez donné vous-même. Si vous voulez juste program1, vous pouvez exécuter simplement make (il sera exécuté la première cible). Si vous voulez juste program2, exécutez make program2. Vous avez plus de contrôle. Et bien sûr, une cible all: program1 program2 permettra de faire exactement cela (le fait d'être la première, l'exécution de vos 2 autres objectifs). Fait.

InformationsquelleAutor Sarah | 2011-05-10

59

Faire comme si
```
all: program1 program2

program1: program1.c
    gcc -o program1 program1.c

program2: program2.c
    gcc -o program2 program2.c
```
Vous avez dit que vous ne voulez pas avancé, mais vous pouvez également raccourcir comme cela repose sur quelques règles par défaut.
```
all: program1 program2

program1: program1.c
program2: program2.c
```
- Notez que si vous voulez les deux programmes construits automatiquement, le all cible doit apparaître avant le programmes individuels dans le fichier makefile, et être la première cible dans le makefile.
- Vous pouvez mettre all ou toute autre cible où vous le souhaitez et d'en faire la valeur par défaut pour la cible de moins en moins (ce que vous avez appelé "automatique"), qui s'exécute de make à l'aide de .DEFAULT_GOAL:=all.
InformationsquelleAutor cnicutar

############################################################################
# 'A Generic Makefile for Building Multiple main() Targets in $PWD'
# Author:  Robert A. Nader (2012)
# Email: naderra at some g
# Web: xiberix
############################################################################
#  The purpose of this makefile is to compile to executable all C source
#  files in CWD, where each .c file has a main() function, and each object
#  links with a common LDFLAG.
#
#  This makefile should suffice for simple projects that require building
#  similar executable targets.  For example, if your CWD build requires
#  exclusively this pattern:
#
#  cc -c $(CFLAGS) main_01.c
#  cc main_01.o $(LDFLAGS) -o main_01
#
#  cc -c $(CFLAGS) main_2..c
#  cc main_02.o $(LDFLAGS) -o main_02
#
#  etc, ... a common case when compiling the programs of some chapter,
#  then you may be interested in using this makefile.
#
#  What YOU do:
#
#  Set PRG_SUFFIX_FLAG below to either 0 or 1 to enable or disable
#  the generation of a .exe suffix on executables
#
#  Set CFLAGS and LDFLAGS according to your needs.
#
#  What this makefile does automagically:
#
#  Sets SRC to a list of *.c files in PWD using wildcard.
#  Sets PRGS BINS and OBJS using pattern substitution.
#  Compiles each individual .c to .o object file.
#  Links each individual .o to its corresponding executable.
#
###########################################################################
#
PRG_SUFFIX_FLAG := 0
#
LDFLAGS := 
CFLAGS_INC := 
CFLAGS := -g -Wall $(CFLAGS_INC)
#
## ==================- NOTHING TO CHANGE BELOW THIS LINE ===================
##
SRCS := $(wildcard *.c)
PRGS := $(patsubst %.c,%,$(SRCS))
PRG_SUFFIX=.exe
BINS := $(patsubst %,%$(PRG_SUFFIX),$(PRGS))
## OBJS are automagically compiled by make.
OBJS := $(patsubst %,%.o,$(PRGS))
##
all : $(BINS)
##
## For clarity sake we make use of:
.SECONDEXPANSION:
OBJ = $(patsubst %$(PRG_SUFFIX),%.o,$@)
ifeq ($(PRG_SUFFIX_FLAG),0)
BIN = $(patsubst %$(PRG_SUFFIX),%,$@)
else
BIN = $@
endif
## Compile the executables
%$(PRG_SUFFIX) : $(OBJS)
$(CC) $(OBJ)  $(LDFLAGS) -o $(BIN)
##
## $(OBJS) should be automagically removed right after linking.
##
veryclean:
ifeq ($(PRG_SUFFIX_FLAG),0)
$(RM) $(PRGS)
else
$(RM) $(BINS)
endif
##
rebuild: veryclean all
##
## eof Generic_Multi_Main_PWD.makefile

Merci pour le code ci-dessus. Je l'utilise pour compiler mon .c fichiers. Mais si je change mes myHeader.h les fichiers, puis j'ai besoin de ré-enregistrer le .c fichier avant d'utiliser "faire" ou bien il montre "faire: Rien à faire pour "all"." alors que des changements ont été fait dans la .h fichier. Peut-on modifier le fichier make pour compiler après tout changement .h les fichiers sans les ré-enregistrer le .c fichier? et merci pour le code ci-dessus!!!
Grâce attribuer. C'était très utile pour moi 🙂
Merci, c'est ce que je cherchais!
"$(OBJS) devrait être automatiquement supprimé juste après la liaison." N'est-ce pas conduire à d'inutiles recompilation et, par conséquent, la plupart vaincre le point de make?
Pourquoi avez-vous nee .SECONDEXPANSION?
Dans Linux, macOS, il est inutile de PRG_SUFFIX. Si vous ne voulez pas de suffixe, ensemble PRG_SUFFIX="". Sinon, si vous définissez PRG_SUFFIX= ou de supprimer cette ligne comme #PRG_SUFFIX=.exe, vous obtiendrez la error: no such file or directory: 'all.o' erreur.

InformationsquelleAutor Robert

18

Modèle de règles vous permettent de compiler plusieurs c les fichiers qui nécessitent les mêmes commandes de compilation à l'aide de make comme suit:
```
objects = program1 program2
all: $(objects)
$(objects): %: %.c
$(CC) $(CFLAGS) -o $@ $<
```
InformationsquelleAutor hmofrad

all: program1 program2
program1:
gcc -Wall -o prog1 program1.c
program2:
gcc -Wall -o prog2 program2.c

InformationsquelleAutor Erik

1

Un programme simple compilation de flux de travail est simple, je peux le dessiner comme un petit graphique: source -> [compilation] -> object [liaison] -> fichier exécutable. Il y a fichiers (source, objet, exécutable) dans ce graphique, et règles (faire's de la terminologie). Ce graphe est défini dans les Makefile.

Lorsque vous lancez le faire, il lit Makefile, et vérifie changé fichiers. Si il y a de tout, il déclenche la règle, qui en dépend. Le règle peut produire/mise à jour fichiers, qui peuvent déclencher d'autres règles et ainsi de suite. Si vous créez un bon makefile, seulement le nécessaire règles (compilateur/lien commandes) sera exécuté, ce qui signifie "à côté" du fichier modifié dans la dépendance de chemin.

Choisir un exemple Makefile, lisez le manuel de syntaxe (de toute façon, il est évident première vue, w/o mode d'emploi), et dessiner le graphe. Vous devez comprendre les options du compilateur afin de trouver les noms des fichiers de résultats.

Le faire graphique doit être aussi complexe, tout comme vous le souhaitez. Vous pouvez même faire des boucles infinies (ne pas faire)! Vous pouvez dire faire, dont la règle est de votre cible, de sorte que seule la gauche debout fichiers seront utilisés comme déclencheurs.

De nouveau: dessiner le graphe!.

InformationsquelleAutor ern0
0
```
all: program1 program2
program1:
gcc -Wall -ansi -pedantic -o prog1 program1.c
program2:
gcc -Wall -ansi -pedantic -o prog2 program2.c
```
J'ai plutôt l'ansi et pédant, un meilleur contrôle de votre programme. Il ne vous laissera pas de compilation que vous avez encore des avertissements !!
- Ce n'est pas ce -pedantic est pour. -pedantic va supprimer toute non-fonctionnalités ansi que même -ansi permis.
- Pour ajouter à cnicutar commentaire, -Werror va changer les avertissements d'erreurs.
InformationsquelleAutor Master C

SRC = a.cpp b.cpp
BIN = $(patsubst %.cpp,%,$(SRC))
all: $(BIN)
clean:
rm -f $(BIN)
.PHONY: all clean

make all fera:

c++     a.cpp   -o a
c++     b.cpp   -o b

Si vous définissez CXX et CXXFLAGS variables make les utiliser.

Vouliez-vous dire a.cpp -o a?
Oui, merci. Fixe.

InformationsquelleAutor Misha Tavkhelidze

Vous devez vous connecter pour publier un commentaire.