Jak Mogę mieć plik Makefile automatycznie odbudowujący pliki źródłowe zawierające zmodyfikowany plik nagłówkowy? (W C / C++)

Możesz dodać polecenie 'make depend', jak stwierdzili inni, ale dlaczego nie dostać gcc do tworzenia zależności i kompilacji w tym samym czasie:

DEPS := $(COBJS:.o=.d)

-include $(DEPS)

%.o: %.c
    $(CC) -c $(CFLAGS) -MM -MF $(patsubst %.o,%.d,$@) -o $@ $<

Parametr '-MF ' Określa plik do przechowywania zależności.

Myślnik na początku '- include ' mówi Make, aby kontynuował, gdy .plik d nie istnieje (np. przy pierwszej kompilacji).

Uwaga w gcc pojawił się błąd dotyczący opcji-o. Jeśli ustawisz nazwę pliku obiektu na obj/_file__c.o, wygenerowany _file_.d nadal będzie zawierać _file_.o, NIE obj/_file_c.o.

Jest to odpowiednik odpowiedzi Chrisa Dodda , ale używa innej konwencji nazewnictwa (i przypadkowo nie wymaga magii sed. Skopiowany z późniejszy duplikat.

JeĹ "li uĺźywasz kompilatora GNU, kompilator moĹźe zgromadziÄ ‡ dla Ciebie listÄ ™ zaleĹźnoĹ" ci. Fragment Makefile:

depend: .depend

.depend: $(SOURCES)
        rm -f ./.depend
        $(CC) $(CFLAGS) -MM $^>>./.depend;

include .depend

Jest też narzędzie makedepend, ale nigdy nie podobało mi się tak bardzo, jak gcc -MM

Będziesz musiał stworzyć indywidualne cele dla każdego pliku C, a następnie wymienić plik nagłówkowy jako zależność. Możesz nadal używać ogólnych celów i po prostu umieścić .h zależności, w ten sposób:

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

foo.c: bar.h
# And so on...

Poza tym, co powiedział @mipadi, możesz również zbadać użycie opcji '-M ' do wygenerowania rekordu zależności. Możesz nawet wygenerować je do osobnego pliku (być może 'depend.mk"), które następnie umieszczasz w pliku makefile. Możesz też znaleźć regułę ' make depend', która edytuje plik makefile z poprawnymi zależnościami(Google terms: "DO not remove this line" and depend).

Zasadniczo, musisz dynamicznie utworzyć reguły makefile, aby odbudować pliki obiektowe, gdy zmienią się pliki nagłówkowe. Jeśli używasz gcc i gnumake, jest to dość proste; wystarczy umieścić coś w stylu:

$(OBJDIR)/%.d: %.c
        $(CC) -MM -MG $(CPPFLAGS) $< | sed -e 's,^\([^:]*\)\.o[ ]*:,$(@D)/\1.o $(@D)/\1.d:,' >$@

ifneq ($(MAKECMDGOALS),clean)
include $(SRCS:%.c=$(OBJDIR)/%.d)
endif

W Twoim pliku makefile.

Żadna z odpowiedzi nie zadziałała. Na przykład odpowiedź Martina Fido sugeruje, że gcc może tworzyć plik zależności, ale kiedy próbowałem generować puste (zerowe bajty) pliki obiektowe dla mnie bez żadnych ostrzeżeń i błędów. To może być błąd gcc. Jestem na

$ gcc --version gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-16)

Oto mój kompletny Makefile, który działa dla mnie; jest to kombinacja rozwiązań + coś, o czym nikt inny nie wspomniał (np. " sufiks reguła zastępcza " określona jako. cc. o:):

CC = g++
CFLAGS = -Wall -g -std=c++0x
INCLUDES = -I./includes/

# LFLAGS = -L../lib
# LIBS = -lmylib -lm

# List of all source files
SRCS = main.cc cache.cc

# Object files defined from source files
OBJS = $(SRCS:.cc=.o)

# # define the executable file 
MAIN = cache_test

#List of non-file based targets:
.PHONY: depend clean all

##  .DEFAULT_GOAL := all

# List of dependencies defined from list of object files
DEPS := $(OBJS:.o=.d)

all: $(MAIN)

-include $(DEPS)

$(MAIN): $(OBJS)
    $(CC) $(CFLAGS) $(INCLUDES) -o $(MAIN) $(OBJS) $(LFLAGS) $(LIBS)

#suffix replacement rule for building .o's from .cc's
#build dependency files first, second line actually compiles into .o
.cc.o:
    $(CC) $(CFLAGS) $(INCLUDES) -c -MM -MF $(patsubst %.o,%.d,$@) $<
    $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $<

clean:
    $(RM) *.o *~ $(MAIN) *.d

Notice I used. cc .. Powyższy plik Makefile można łatwo dostosować .pliki C.

Należy również zwrócić uwagę na znaczenie tych dwóch linii:

$(CC) $(CFLAGS) $(INCLUDES) -c -MM -MF $(patsubst %.o,%.d,$@) $<
$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $<

Więc gcc jest wywoływany raz, aby najpierw zbudować plik zależności, a następnie faktycznie skompilować plik. cc. I tak dalej dla każdego pliku źródłowego.

Prostsze rozwiązanie: wystarczy użyć Makefile, aby mieć .c do .o reguła kompilacji zależy od Pliku (ów) nagłówka i cokolwiek innego jest istotne w projekcie jako zależność.

Np. w Makefile gdzieś:

DEPENDENCIES=mydefs.h yourdefs.h Makefile GameOfThrones.S07E01.mkv

::: (your other Makefile statements like rules 
:::  for constructing executables or libraries)

# Compile any .c to the corresponding .o file:
%.o: %.c $(DEPENDENCIES)
        $(CC) $(CFLAGS) -c -o $@ $<

Wierzę, że polecenie mkdep jest tym, czego chcesz. To skanuje .pliki c dla linii #include i tworzy dla nich drzewo zależności. Uważam, że projekty Automake / Autoconf używają tego domyślnie.