Makefile zum Kompilieren mehrerer C-Programme?

Dies ist eine unglaublich einfache Frage, aber ich bin neu in Makefiles. Ich versuche, ein Makefile zu erstellen, das zwei unabhängige Programme kompiliert:

program1:
    gcc -o prog1 program1.c

program2:
    gcc -o prog2 program2.c

Alle Beispiele online gehen viel mehr ins Detail als ich brauche und sind verwirrend! Alles, was ich wirklich will, ist, die beiden laufen zu lassen gcc Linien. Was mache ich falsch?

Mach es so

all: program1 program2

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

program2: program2.c
    gcc -o program2 program2.c

Sie sagten, Sie wollen keine fortgeschrittenen Sachen, aber Sie könnten es auch so kürzen, basierend auf einigen Standardregeln.

all: program1 program2

program1: program1.c
program2: program2.c

Musterregeln können Sie mehrere c-Dateien kompilieren, die dieselben Kompilierungsbefehle erfordern make folgendermaßen:

objects = program1 program2
all: $(objects)

$(objects): %: %.c
        $(CC) $(CFLAGS) -o $@ $<

############################################################################
# '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

all: program1 program2

program1:
    gcc -Wall -o prog1 program1.c

program2:
    gcc -Wall -o prog2 program2.c

all: program1 program2

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

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

Ich bevorzuge die Ansi und Pedantik, eine bessere Kontrolle für dein Programm. Es lässt Sie nicht kompilieren, solange Sie noch Warnungen haben !!

Der Kompilierungs-Workflow eines einfachen Programms ist einfach, ich kann es als kleine Grafik zeichnen: Quelle -> [compilation] -> Objekt [linking] -> ausführbar. Es gibt Dateien (Quelle, Objekt, ausführbare Datei) in diesem Diagramm und Regeln (machenTerminologie von ). Dieser Graph ist in definiert Makefile.

Wenn Sie make starten, wird es angezeigt Makefileund prüft auf geändert Dateien. Wenn es welche gibt, löst es die aus Regel, was davon abhängt. Das Regel kann weiter produzieren/aktualisieren Dateiendie andere auslösen können Regeln usw. Wenn Sie ein gutes Makefile erstellen, nur das Notwendige Regeln (Compiler/Link-Kommandos) ausgeführt wird, was aus der modifizierten Datei im Abhängigkeitspfad “to next” steht.

Wählen Sie ein Beispiel aus Makefilelesen Sie das Handbuch für die Syntax (wie auch immer, es ist auf den ersten Blick klar, ohne Handbuch), und Zeichnen Sie die Grafik. Sie müssen Compiler-Optionen verstehen, um die Namen der Ergebnisdateien herauszufinden.

Das Make-Diagramm sollte so komplex sein, wie Sie möchten. Sie können sogar Endlosschleifen machen (nicht tun)! Du kannst sagen machenwelche Regel ist Ihre Zielalso nur der Linksstehende Dateien werden als Trigger verwendet.

Wieder: Zeichnen Sie die Grafik!.

SRC = a.cpp b.cpp
BIN = $(patsubst %.cpp,%,$(SRC))

all: $(BIN)

clean:
    rm -f $(BIN)

.PHONY: all clean

make all Wird besorgt:

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

Wenn Sie einstellen CXX und CXXFLAGS Variablen make werde sie verwenden.