Un Makefile con più eseguibili

Question

Sto provando a scrivere un makefile che utilizza le macro per creare più file eseguibili da più file contemporaneamente. Ho provato a cercare tra le domande con risposta precedente ma, dato che sono abbastanza nuovo nella programmazione in C e ho lavorato con gcc, non sono riuscito a trovare una risposta alla mia domanda.

Ecco quello che ho finora:

CC=gcc 
CFLAGS=-I. 
OBJ = ex1.c ex3.c 
EXECUTABLE = ex1 ex3 

$(EXECUTABLE): $(OBJ) 
    gcc -o $@ $^ $(CFLAGS) 

clean: 
    rm -f $(EXECUTABLE) 

Vorrei la linea

$(EXECUTABLE): $(OBJ) 

per creare rispettivamente eseguibili EX1 e EX3 da file ex1.c ex3.c.

Answer 1

Per questo caso particolare, dove ogni eseguibile ha un singolo file sorgente con .c estensione, è sufficiente disporre di una sola riga Makefile:

all: ex1 ex3 

Le regole predefinite incorporate per make poi lavorare già:

$ make 
cc -O2 -pipe ex1.c -o ex1 
cc -O2 -pipe ex3.c -o ex3 

Dietro la scena, make sta usando il POSIXly mandated built-in single suffix rule

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

Variare il comando a proprio piacimento con make CC=gcc CFLAGS=-O2 LDFLAGS=-s e simili.

Curiosità del giorno: in realtà, se si è disposti a nominare i bersagli quando invoca make, è possibile utilizzare un vuoto o addirittura corsa senza alcun Makefile:

$ make -f /dev/null CC=gcc CFLAGS=-O2 LDFLAGS=-s ex1 ex3 
gcc -O2 -s ex1.c -o ex1 
gcc -O2 -s ex3.c -o ex3 
$ rm -f Makefile ex1 ex3 
$ make CC=gcc CFLAGS=-O2 LDFLAGS=-s ex1 ex3 
gcc -O2 -s ex1.c -o ex1 
gcc -O2 -s ex3.c -o ex3 

fare la magia !

Come regola generale, non reinventare la ruota (o le regole), utilizzare le regole che sono già presenti. Semplifica molto la tua vita e la tua vita. Questo rende i piccoli e sexy makefile impressionare le donne con :-)

Answer 2

sei vicino, ma è necessario un modello regola:

$(EXECUTABLE): % : %.c 

E poi una regola di default per renderlo costruire entrambi:

all: $(EXECUTABLE) 

Answer 3

Alcuni suggerimenti (a patto di utilizzare GNU make, non qualcos'altro)

Innanzitutto, eseguire una volta make -p, capirai quali regole incorporate make è sapere. Cercare in particolare per COMPILE.c e LINK.c

Poi, suggerisco

CFLAGS= -g -Wall -I. 

^{(perché si vuole veramente -g per il debug, e -Wall per ottenere la maggior parte delle avvertenze)}

E probabilmente non bisogno

$(EXECUTABLE): $(OBJ) 
    gcc -o $@ $^ $(CFLAGS) 

Tuttavia, suggerisco st aggiungendo prima di molte altre norme

.PHONY: all clean 

all: $(EXECUTABLES) 

In realtà, vorrei codificare il Makefile (per GNUmake!) come segue

# file Makefile 
CC= gcc 
RM= rm -vf 
CFLAGS= -Wall -g 
CPPFLAGS= -I. 
SRCFILES= ex1.c ex2.C## or perhaps $(wildcard *.c) 
OBJFILES= $(patsubst %.c, %.o, $(SRCFILES)) 
PROGFILES= $(patsubst %.c, %, $(SRCFILES)) 

.PHONY: all clean 

all: $(PROGFILES) 
clean: 
    $(RM) $(OBJFILES) $(PROGFILES) *~ 
## eof Makefile 

Ricordate che scheda è un personaggio significativo nella Makefile -s (parte di azione di rules). In questa risposta, le righe che iniziano con almeno quattro spazi dovrebbero in realtà iniziare con una scheda con il carattere.

Una volta che tutto è debug si consiglia di eseguire make clean per pulire tutto, e poi make -j CFLAGS=-O2 all di compilare in ogni cosa in parallelo con le ottimizzazioni.

Finalmente, mi consiglia di utilizzare remake e funzionante remake -x per eseguire il debug complessi Makefile -s

Naturalmente, sto supponendo che la directory ha solo programmi di file singolo.

BTW, ci sono altri programmi di builder. Forse si potrebbe considerare omake

^{Non dimenticare di utilizzare un sistema di controllo versione come git per i file di origine. È anche il momento di imparare un tale strumento.}

Answer 4

La seguente risposta include più eseguibili come initiate, process1, process2, ..., process4.

LOCAL_INCLUDE=./ 

all: clean process_first process_second init 

process_first: 
    gcc -g -o process1 -I$(LOCAL_INCLUDE) process1.c -lzmq -L. -L./. 
    gcc -g -o process2 -I$(LOCAL_INCLUDE) process2.c -lzmq -L. -L./. 

process_second: 
    gcc -g -o process3 -I$(LOCAL_INCLUDE) process3.c -lzmq -L. -L./. 
    gcc -g -o process4 -I$(LOCAL_INCLUDE) process4.c -lzmq -L. -L./. 

init: 
    gcc -g -o initiate -I$(LOCAL_INCLUDE) initiate.c -lzmq -lconfig -lpthread -L. -L./. -ldl -lrt 

clean: 
    rm -rf init_manager.o init_manager 
    rm -rf process1 process2 process3 process4 

NOTA: È buona norma pulire e toccare tutti i file eseguibili prima di rifarli.