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

J'ai un projet où la structure du répertoire est comme ceci:

                         $projectroot
                              |
              +---------------+----------------+
              |               |                |
            part1/          part2/           part3/
              |               |                |
       +------+-----+     +---+----+       +---+-----+
       |      |     |     |        |       |         |
     data/   src/  inc/  src/     inc/   src/       inc/

Comment dois-je écrire un makefile qui serait dans la partie / src (ou n'importe où vraiment) qui pourrait compléter / lien sur les fichiers source c / c ++ en partie? / Src?

Puis-je faire quelque chose comme -I $ projectroot / part1 / src -I $ projectroot / part1 / inc -I $ projectroot / part2 / src ...

Si cela fonctionne, y a-t-il un moyen plus simple de le faire. J'ai vu des projets où il y a un makefile dans chacune des parties correspondantes? Dossiers. [dans cet article, j'ai utilisé le point d'interrogation comme dans la syntaxe bash]

La manière traditionnelle est d'avoir un Makefiledans chacun des sous - répertoires ( part1, part2, etc.) vous permettant de les construire de manière indépendante. De plus, ayez un Makefiledans le répertoire racine du projet qui construit tout. La "racine" Makefileressemblerait à ceci:

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

Puisque chaque ligne dans une cible de création est exécutée dans son propre shell, il n'y a pas besoin de s'inquiéter de la remontée de l'arborescence de répertoires ou vers d'autres répertoires.

Je suggère de jeter un œil à la section 5.7 du manuel de création de GNU ; c'est très utile.

Si vous avez du code dans un sous-répertoire dépendant du code dans un autre sous-répertoire, vous êtes probablement mieux avec un seul makefile au niveau supérieur.

Voir Récursif Rendre considéré comme nocif pour la justification complète, mais en gros, vous voulez faire en sorte d'avoir toutes les informations dont il a besoin pour décider si un fichier doit être reconstruit ou non, et il ne l'aura pas si vous lui dites seulement environ un tiers de votre projet.

Le lien ci-dessus ne semble pas accessible. Le même document est accessible ici:

• aegis.sourceforge.net
• lcgapp.cern.ch

L'option VPATH peut s'avérer utile, car elle indique à make quels répertoires rechercher le code source. Cependant, vous aurez toujours besoin d'une option -I pour chaque chemin d'inclusion. Un exemple:

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

OutputExecutable: part1api.o part2api.o part3api.o

Cela trouvera automatiquement les fichiers partXapi.cpp correspondants dans l'un des répertoires spécifiés par VPATH et les compilera. Cependant, cela est plus utile lorsque votre répertoire src est divisé 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, surtout si chaque partie peut être autonome.

Vous pouvez ajouter des règles à votre Makefile racine afin de compiler les fichiers cpp nécessaires dans d'autres répertoires. L'exemple Makefile ci-dessous devrait être un bon début pour vous amener là où vous voulez être.

CC = g ++
TARGET = cppTest
OTHERDIR = .. / .. / un autre chemin / dans / projet / src

SOURCE = cppTest.cpp
SOURCE = $ (OTHERDIR) /file.cpp

## Définition des sources de fin
INCLUDE = -I./ $ (AN_INCLUDE_DIR)  
INCLUDE = -I. $ (OTHERDIR) /../ inc
## end more comprend

VPATH = $ (OTHERDIR)
OBJ = $ (join $ (ajouteuffix ../obj/, $ (dir $ (SOURCE))), $ (notdir $ (SOURCE: .cpp = .o))) 

## Correction de la destination de dépendance comme étant ../.dep par rapport au répertoire src
DEPENDS = $ (join $ (ajouteuffix ../.dep/, $ (dir $ (SOURCE))), $ (notdir $ (SOURCE: .cpp = .d)))

## Règle par défaut exécutée
tout: $ (TARGET)
        @vrai

## Règle propre
nettoyer:
        @ -rm -f $ (TARGET) $ (OBJ) $ (DEPEND)


## Règle de création de la cible réelle
$ (CIBLE): $ (OBJ)
        @echo "============="
        @echo "Lier la cible $ @"
        @echo "============="
        @ $ (CC) $ (CFLAGS) -o $ @ $ ^ $ (LIBS)
        @echo - Lien terminé -

## Règle de compilation générique
% .o:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo "Compilation de $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @


## Règles pour les fichiers objets des fichiers cpp
## Le fichier objet de chaque fichier est placé dans le répertoire obj
## un niveau au-dessus du répertoire source réel.
../obj/%.o:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo "Compilation de $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @

# Règle pour "autre répertoire" Vous en aurez besoin d'une par "autre" répertoire
$ (OTHERDIR) /../ obj /%. O:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo "Compilation de $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @

## Définir des règles de dépendance
../.dep/%.d:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo Construire un fichier de dépendances pour $ *. o
        @ $ (COQUE) -ec '$ (CC) -M $ (CFLAGS) $ <| sed "s ^ $ *. o ^ .. / obj / $ *. o ^"> $ @ '

## Règle de dépendance pour "autre" répertoire
$ (OTHERDIR) /../. Dep /%. D:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo Construire un fichier de dépendances pour $ *. o
        @ $ (COQUE) -ec '$ (CC) -M $ (CFLAGS) $ <| sed "s ^ $ *. o ^ $ (AUTRE REP) /../ obj / $ *. o ^"> $ @ '

## Inclut les fichiers de dépendance
-inclut $ (DÉPEND)

Si les sources sont réparties dans de nombreux dossiers et qu'il est logique d'avoir des Makefiles individuels, comme suggéré précédemment, la création récursive est une bonne approche, mais pour les petits projets, je trouve plus facile de lister tous les fichiers source dans le Makefile avec leur chemin relatif au Makefile comme ceci:

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

Je peux ensuite définir de VPATHcette façon:

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

Ensuite, je construis 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 création 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 VPATHautomatiser la génération en:

VPATH := $(dir $(COMMON_SRC))

Ou en utilisant le fait qui sortsupprime les doublons (bien que cela ne devrait pas avoir d'importance):

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

Je pense qu'il est préférable de souligner que l'utilisation de Make (récursif ou non) est quelque chose que vous voudrez peut-être généralement éviter, car par rapport aux outils d'aujourd'hui, il est difficile à apprendre, à maintenir et à faire évoluer.

C'est un outil merveilleux mais son utilisation directe devrait être considérée comme obsolète en 2010+.

Sauf si, bien sûr, vous travaillez dans un environnement spécial, c'est-à-dire avec un projet hérité, etc.

Utilisez un IDE, CMake ou, si vous êtes un noyau dur, les Autotools .

(édité en raison de votes négatifs, ty Honza pour le souligner)

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

Dans parentDir, ayez un tas de répertoires contenant des fichiers source: dirA, dirB, dirC. Différents fichiers dépendent des fichiers objet dans d'autres répertoires, donc je voulais pouvoir créer un fichier à partir d'un répertoire et le faire créer cette dépendance en appelant le makefile associé à cette dépendance.

Essentiellement, j'ai créé un Makefile dans parentDir qui avait (parmi beaucoup d'autres choses) une règle générique similaire à celle de RC:

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

Chaque sous-répertoire incluait ce makefile de niveau supérieur afin d'hériter de cette règle générique. Dans le Makefile de chaque sous-répertoire, j'ai écrit une règle personnalisée pour chaque fichier afin de pouvoir garder une trace de tout ce dont chaque fichier individuel dépendait.

Chaque fois que j'avais besoin de créer un fichier, j'utilisais (essentiellement) cette règle pour créer de manière récursive toutes les dépendances. Parfait!

NOTE: il y a un utilitaire appelé "makepp" qui semble faire cette tâche même de manière encore plus intuitive, mais pour des raisons de portabilité et ne dépendant pas d'un autre outil, j'ai choisi de le faire de cette façon.

J'espère que cela t'aides!

Utilisation récursive de Make

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

Cela permet de makese diviser en travaux et d'utiliser plusieurs cœurs

Je cherchais quelque chose comme ça et après quelques essais et chutes je crée mon propre makefile, je sais que ce n'est pas la "manière idiomatique" mais c'est un début pour comprendre make et ça marche pour moi, peut-être que tu pourrais essayer dans ton 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, mes indicateurs sont faux, mais comme je l'ai dit, c'est mon premier Makefile à compiler mon projet dans plusieurs répertoires et à lier le tout ensemble pour créer mon bac.

J'accepte les suggestions: D

Je suggère d'utiliser autotools:

//## Placez les fichiers objets générés (.o) dans le même répertoire que leurs fichiers source, afin d'éviter les collisions lorsque make non récursif est utilisé.

AUTOMAKE_OPTIONS = subdir-objects

juste l'inclure dans Makefile.amles autres trucs assez simples.

Voici le tutoriel .