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 Online-Beispiele enthalten mehr Details als ich brauche und sind verwirrend! Ich möchte nur, dass die beiden gccZeilen ausgeführt werden. 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 möchten keine fortgeschrittenen Inhalte, aber Sie könnten sie auch basierend auf einigen Standardregeln so kürzen.

all: program1 program2

program1: program1.c
program2: program2.c

Mit Musterregeln können Sie mehrere c-Dateien kompilieren, für die dieselben Kompilierungsbefehle erforderlich sind, und zwar makewie folgt:

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 eher die ansi und pedantisch, eine bessere Kontrolle für Ihr Programm. Sie können nicht kompilieren, solange Sie noch Warnungen haben !!

Der Kompilierungsworkflow eines einfachen Programms ist einfach. Ich kann ihn als kleines Diagramm zeichnen: Quelle -> [Kompilierung] -> Objekt [Verknüpfung] -> ausführbare Datei. In diesem Diagramm befinden sich Dateien (Quelle, Objekt, ausführbare Datei) und Regeln ( Terminologie von make ). Dieses Diagramm wird im Makefile definiert .

Wenn Sie make starten, wird Makefile gelesen und nach geänderten Dateien gesucht . Wenn es welche gibt, löst es die Regel aus , die davon abhängt. Die Regel kann weitere Dateien erzeugen / aktualisieren , wodurch andere Regeln usw. ausgelöst werden können . Wenn Sie ein gutes Makefile erstellen, werden nur die erforderlichen Regeln (Compiler- / Link-Befehle) ausgeführt, die aus der geänderten Datei im Abhängigkeitspfad "zum nächsten" stehen.

Wählen Sie ein Beispiel- Makefile aus , lesen Sie das Handbuch für die Syntax (es ist auf den ersten Blick klar, ohne Handbuch) und zeichnen Sie das Diagramm . Sie müssen die Compileroptionen 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 machen)! Sie können make mitteilen , welche Regel Ihr Ziel ist , sodass nur die links stehenden Dateien als Auslöser verwendet werden.

Nochmals: Zeichnen Sie die Grafik !

Dadurch werden alle *.cDateien makezu ausführbaren Dateien ohne die .cErweiterung wie in kompiliert gcc program.c -o program.

makefügt automatisch alle Flags hinzu, die Sie hinzufügen CFLAGSmöchten CFLAGS = -g Wall.

Wenn Sie keine Flags benötigen, CFLAGSkönnen Sie diese leer lassen (siehe unten) oder ganz weglassen.

SOURCES = $(wildcard *.c)
EXECS = $(SOURCES:%.c=%)
CFLAGS = 

all: $(EXECS)

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 setzen CXXund CXXFLAGSVariablen makeverwenden sie.