it-swarm.dev

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 erstellt:

program1:
    gcc -o prog1 program1.c

program2:
    gcc -o prog2 program2.c

Alle Online-Beispiele zeigen viel mehr Details als ich brauche und sind verwirrend! Alles, was ich wirklich will, ist, die beiden gcc-Zeilen auszuführen. Was mache ich falsch?

50
Sarah

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 kein fortgeschrittenes Zeug, aber Sie könnten es auch auf der Grundlage einiger Standardregeln so verkürzen.

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

Musterregeln Sie können mehrere c-Dateien kompilieren, für die dieselben Kompilierungsbefehle erforderlich sind. Verwenden Sie make wie folgt:

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

Der Kompilierungsworkflow eines einfachen Programms ist einfach, ich kann ihn als kleine Grafik zeichnen: source -> [compilation] -> object [linking] -> ausführbare Datei. In diesem Diagramm befinden sich files (Quelle, Objekt, ausführbare Datei) und rules (Terminologie von make). Dieser Graph ist im Makefile definiert. 

Wenn Sie make starten, liest es Makefile und sucht nach geänderten files. Wenn es welche gibt, wird die rule ausgelöst, die davon abhängt. Die rule kann weitere files erzeugen/aktualisieren, wodurch andere rules usw. ausgelöst werden. Wenn Sie ein gutes Makefile erstellen, werden nur die erforderlichen rules (Compiler-/Link-Befehle) ausgeführt, die "to next" aus der geänderten Datei im Abhängigkeitspfad stehen.

Wählen Sie ein Beispiel Makefile aus, lesen Sie das Handbuch zur Syntax (zumindest ist es für den ersten Blick klar, ohne Handbuch) und zeichnen Sie die Grafik . Sie müssen die Compiler-Optionen verstehen, um die Namen der Ergebnisdateien herauszufinden.

Das Make-Diagramm sollte so komplex sein, wie Sie es möchten. Sie können sogar unendliche Loops ausführen (tun Sie dies nicht)! Sie können make sagen, welche Regel Ihr target ist, so dass nur die verbleibenden files als Auslöser verwendet werden.

Nochmals: Zeichne die Grafik !.

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

all: $(BIN)

clean:
    rm -f $(BIN)

.PHONY: all clean

make all wird Folgendes tun:

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

Wenn Sie CXX und CXXFLAGS Variablen setzen, verwendet make diese.

0
all: program1 program2

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

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

Ich habe eher die Ansi und Pedantik, eine bessere Kontrolle für Ihr Programm. Es lässt dich nicht kompilieren, solange du noch Warnungen hast !!

0
Master C