Les Makefiles avec la source des fichiers dans des répertoires différents

La manière traditionnelle est d'avoir un Makefile dans chacun des sous-répertoires (part1, part2, etc.) vous permettant de construire de manière indépendante. De plus, avoir un Makefile dans le répertoire racine du projet, qui s'appuie tout. La "racine" de Makefile ressemblerait à quelque chose comme ce qui suit:

all:
    +$(MAKE) -C part1
    +$(MAKE) -C part2
    +$(MAKE) -C part3

Depuis chaque ligne dans une cible est exécuté dans sa propre coquille, il n'y a pas besoin de s'inquiéter à propos de la traversée de sauvegarder l'arborescence de répertoires ou d'autres répertoires.

Je suggère de prendre un coup d'oeil à la GNU make manuel de la section 5.7; il est très utile.

La VPATH option pourrait venir dans maniable, qui dit de faire ce que les répertoires de regarder dans le code source. Vous auriez encore besoin d'une option-I pour chaque chemin, cependant. Un exemple:

CXXFLAGS=-Ipart1/inc -Ipart2/inc -Ipart3/inc
VPATH=part1/src:part2/src:part3/src

OutputExecutable: part1api.o part2api.o part3api.o

Cela va automatiquement trouver la correspondance partXapi.cpp fichiers dans l'un des VPATH les répertoires spécifiés et les compiler. Cependant, c'est plus utile lorsque votre répertoire src est décomposé en sous-répertoires. Pour ce que vous décrivez, comme d'autres l'ont dit, vous êtes probablement mieux avec un makefile pour chaque partie, en particulier si chaque partie de manière autonome.

Si les sources sont réparties dans de nombreux dossiers, et il est logique de se Makefiles puis comme suggéré précédemment, version récursive est une bonne approche, mais pour les petits projets que je trouve plus facile de la liste de tous les fichiers source dans le Makefile avec leur chemin d'accès relatif à la Makefile comme ceci:

# common sources
COMMON_SRC := ./main.cpp \
              ../src1/somefile.cpp \
              ../src1/somefile2.cpp \
              ../src2/somefile3.cpp \

Je pouvez ensuite définir VPATH de cette façon:

VPATH := ../src1:../src2

Puis-je construire les objets:

COMMON_OBJS := $(patsubst %.cpp, $(ObjDir)/%$(ARCH)$(DEBUG).o, $(notdir $(COMMON_SRC)))

Maintenant, la règle est simple:

# the "common" object files
$(ObjDir)/%$(ARCH)$(DEBUG).o : %.cpp Makefile
    @echo creating $@ ...
    $(CXX) $(CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<

Et la construction de la sortie est encore plus facile:

# This will make the cbsdk shared library
$(BinDir)/$(OUTPUTBIN): $(COMMON_OBJS)
    @echo building output ...
    $(CXX) -o $(BinDir)/$(OUTPUTBIN) $(COMMON_OBJS) $(LFLAGS)

On peut même faire de la VPATH génération automatisée par:

VPATH := $(dir $(COMMON_SRC))

Ou en utilisant le fait que sort supprime les doublons (même s'il ne devrait pas d'importance):

VPATH := $(sort  $(dir $(COMMON_SRC)))

RC post a été SUPER utile. Je n'ai jamais pensé à utiliser le $($dir@) de la fonction, mais il a fait exactement ce dont j'avais besoin qu'il fasse.

Dans parentDir, ont un tas de répertoires avec les fichiers source en eux: dirA, dirB, dirC. Divers fichiers dépendent de l'objet des fichiers dans d'autres répertoires, si je voulais être en mesure de faire un fichier dans un répertoire, et l'avoir de cette dépendance en appelant le makefile associés à cette dépendance.

Essentiellement, j'ai fait un Makefile dans parentDir qui avait (entre autres choses) un générique règle analogue à celle de RC:

%.o : %.cpp
        @mkdir -p $(dir $@)
        @echo "============="
        @echo "Compiling $<"
        @$(CC) $(CFLAGS) -c $< -o $@

Chaque sous-répertoire inclus ce niveau supérieur makefile afin d'hériter de ce générique de la règle. Dans chaque sous-répertoire du Makefile, j'ai écrit une règle personnalisée pour chaque fichier afin que je puisse garder une trace de tout ce que chaque fichier en dépendait.

Chaque fois que je besoin de créer un fichier, j'ai utilisé (pour l'essentiel) de la présente règle récursive de faire tout/toutes les dépendances. Parfait!

REMARQUE: il y a un utilitaire appelé "makepp" qui semble faire de cette tâche encore plus intuitive, mais pour des raisons de portabilité et non pas en fonction d'un autre outil, j'ai choisi de faire de cette façon.

Espérons que cette aide!

Je cherchais quelque chose comme ça, et après quelques tentatives, et tombe, je créer mon propre makefile, je sais que ce n'est pas le "idiomatiques façon", mais c'est un début pour comprendre faire et cela fonctionne pour moi, peut-être que vous pouvez essayer dans votre projet.

PROJ_NAME=mono

CPP_FILES=$(shell find . -name "*.cpp")

S_OBJ=$(patsubst %.cpp, %.o, $(CPP_FILES))

CXXFLAGS=-c \
         -g \
        -Wall

all: $(PROJ_NAME)
    @echo Running application
    @echo
    @./$(PROJ_NAME)

$(PROJ_NAME): $(S_OBJ)
    @echo Linking objects...
    @g++ -o $@ $^

%.o: %.cpp %.h
    @echo Compiling and generating object $@ ...
    @g++ $< $(CXXFLAGS) -o $@

main.o: main.cpp
    @echo Compiling and generating object $@ ...
    @g++ $< $(CXXFLAGS)

clean:
    @echo Removing secondary things
    @rm -r -f objects $(S_OBJ) $(PROJ_NAME)
    @echo Done!

Je sais que c'est simple et pour certaines personnes, mon indicateurs sont mauvais, mais comme je l'ai dit c'est mon premier Makefile pour compiler mon projet dans plusieurs répertoires et les relier tous ensemble à la création de mon bac.

Je suis accepter les suggestions 😀