web-dev-qa-db-fra.com

Makefile pour compiler plusieurs programmes en C?

C'est une question incroyablement simple, mais je suis novice dans les makefiles. J'essaie de créer un fichier Make qui compilera deux programmes indépendants:

program1:
    gcc -o prog1 program1.c

program2:
    gcc -o prog2 program2.c

Tous les exemples en ligne contiennent plus de détails que nécessaire et sont source de confusion! Tout ce que je veux vraiment, c’est d’exécuter les deux lignes gcc. Qu'est-ce que je fais mal?

cmakefile
50
Sarah

Faites-le comme ça

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 de matériel avancé, mais que vous pourriez aussi le raccourcir en fonction de certaines règles par défaut.

all: program1 program2

program1: program1.c
program2: program2.c
54
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
21
Robert

Règles de modèle vous permettent de compiler plusieurs fichiers c qui nécessitent les mêmes commandes de compilation en utilisant make comme suit:

objects = program1 program2
all: $(objects)

$(objects): %: %.c
        $(CC) $(CFLAGS) -o $@ $<
13
hmofrad
all: program1 program2

program1:
    gcc -Wall -o prog1 program1.c

program2:
    gcc -Wall -o prog2 program2.c
10
Erik

Le processus de compilation d'un programme simple est simple, je peux le dessiner sous forme de petit graphique: source -> [compilation] -> objet [lien] -> exécutable. Il y a fichiers (source, objet, exécutable) dans ce graphique et rules (terminologie de make). Ce graphique est défini dans le fichier Makefile. 

Lorsque vous lancez make, il lit Makefile et recherche les fichiers modifiés. S'il y en a, il déclenche la rule, qui en dépend. La règle peut produire/mettre à jour davantage de fichiers, ce qui peut déclencher d'autres règles et ainsi de suite. Si vous créez un bon fichier make, seul le nécessaire rules (commandes du compilateur/link) sera exécuté, ce qui signifie "to next" du fichier modifié dans le chemin de dépendance.

Choisissez un exemple Makefile, lisez le manuel pour la syntaxe (de toute façon, c'est clair pour la première fois, sans manuel), et tracez le graphique . Vous devez comprendre les options du compilateur afin de trouver les noms des fichiers de résultats.

Le graphique de création doit être aussi complexe que vous le souhaitez. Vous pouvez même faire des boucles infinies (ne pas faire)! Vous pouvez indiquer make, quelle règle est votre target, de sorte que seuls les files conservés à gauche [] seront utilisés comme déclencheurs.

Encore une fois: trace le graphique !.

1
ern0
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 les variables CXX et CXXFLAGS, make les utilisera.

0
Misha Tavkhelidze
all: program1 program2

program1:
    gcc -Wall -ansi -pedantic -o prog1 program1.c

program2:
    gcc -Wall -ansi -pedantic -o prog2 program2.c

Je préfère l'ansi et le pédant, un meilleur contrôle pour votre programme. Il ne vous laissera pas compiler tant que vous aurez encore des avertissements !!

0
Master C