Makefiles พร้อมไฟล์ต้นฉบับในไดเรกทอรีที่แตกต่างกัน

ฉันมีโครงการที่โครงสร้างไดเรกทอรีเป็นเช่นนี้:

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

ฉันจะเขียน makefile ที่จะอยู่ใน part / src (หรือที่ไหนก็ได้) ที่สามารถ comple / link บนไฟล์ต้นฉบับ c / c ++ ในบางส่วนได้อย่างไร / src?

ฉันสามารถทำสิ่งที่ชอบ -I $ projectroot / part1 / src -I $ projectroot / part1 / inc -I $ projectroot / part2 / src ...

หากได้ผลมีวิธีที่ง่ายกว่านี้ไหม ฉันเคยเห็นโครงการที่มี makefile ในแต่ละส่วนที่เกี่ยวข้องหรือไม่ โฟลเดอร์ [ในโพสต์นี้ฉันใช้เครื่องหมายคำถามเช่นในไวยากรณ์ bash]

วิธีแบบดั้งเดิมคือการมีMakefileในแต่ละไดเรกทอรีย่อย ( part1, part2ฯลฯ ) ช่วยให้คุณสามารถสร้างพวกเขาเป็นอิสระ นอกจากนี้มีMakefileในไดเรกทอรีรากของโครงการที่สร้างทุกอย่าง "ราก" Makefileจะมีลักษณะดังนี้:

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

เนื่องจากแต่ละบรรทัดใน make target ถูกรันในเชลล์ของตัวเองจึงไม่จำเป็นต้องกังวลเกี่ยวกับการย้อนกลับข้อมูลไดเร็กทอรีทรีหรือไดเร็กทอรีอื่น

ฉันขอแนะนำให้ดูที่GNU make manual ส่วน 5.7 ; เป็นประโยชน์มาก

หากคุณมีโค้ดในไดเร็กทอรีย่อยหนึ่งขึ้นอยู่กับโค้ดในไดเร็กทอรีย่อยอื่นคุณน่าจะดีกว่าด้วย makefile เดียวที่ระดับบนสุด

ดูการทำซ้ำถือว่าเป็นอันตรายสำหรับเหตุผลทั้งหมด แต่โดยพื้นฐานแล้วคุณต้องการให้มีข้อมูลทั้งหมดที่จำเป็นในการตัดสินใจว่าจะต้องสร้างไฟล์ใหม่หรือไม่และจะไม่มีสิ่งนั้นหากคุณบอกเพียงหนึ่งในสามของ โครงการของคุณ

ดูเหมือนว่าลิงก์ด้านบนจะไม่สามารถเข้าถึงได้ เอกสารเดียวกันสามารถเข้าถึงได้ที่นี่:

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

ตัวเลือก VPATH อาจมีประโยชน์ซึ่งจะบอกให้ทราบว่าไดเรกทอรีใดที่จะค้นหาซอร์สโค้ด คุณยังต้องการตัวเลือก -I สำหรับแต่ละเส้นทางรวม ตัวอย่าง:

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

OutputExecutable: part1api.o part2api.o part3api.o

สิ่งนี้จะค้นหาไฟล์ partXapi.cpp ที่ตรงกันโดยอัตโนมัติในไดเร็กทอรีที่ระบุ VPATH และคอมไพล์ อย่างไรก็ตามสิ่งนี้มีประโยชน์มากกว่าเมื่อไดเร็กทอรี src ของคุณแบ่งออกเป็นไดเร็กทอรีย่อย สำหรับสิ่งที่คุณอธิบายตามที่คนอื่น ๆ บอกคุณน่าจะดีกว่าด้วย makefile สำหรับแต่ละส่วนโดยเฉพาะอย่างยิ่งถ้าแต่ละส่วนสามารถยืนอยู่คนเดียวได้

คุณสามารถเพิ่มกฎใน Makefile รูทของคุณเพื่อคอมไพล์ไฟล์ cpp ที่จำเป็นในไดเร็กทอรีอื่น ๆ ตัวอย่าง Makefile ด้านล่างนี้ควรเป็นจุดเริ่มต้นที่ดีในการพาคุณไปยังที่ที่คุณต้องการ

CC = กรัม ++
target = cppTest
OTHERDIR = .. / .. / someotherpath / ใน / โครงการ / src

SOURCE = cppTest.cpp
แหล่งที่มา = $ (OTHERDIR) /file.cpp

## นิยามแหล่งที่มาปลายทาง
รวม = -I./ $ (AN_INCLUDE_DIR)  
รวม = -I. $ (OTHERDIR) /../ inc
## จบเพิ่มเติมรวม

VPATH = $ (OTHERDIR)
OBJ = $ (เข้าร่วม $ (addsuffix ../obj/, $ (dir $ (SOURCE))), $ (notdir $ (SOURCE: .cpp = .o))) 

## แก้ไขปลายทางการอ้างอิงให้เป็น ../.dep สัมพันธ์กับ src dir
DEPENDS = $ (เข้าร่วม $ (addsuffix ../.dep/, $ (dir $ (SOURCE))), $ (notdir $ (SOURCE: .cpp = .d)))

## กฎเริ่มต้นดำเนินการ
ทั้งหมด: $ (เป้าหมาย)
        @true

## กฎความสะอาด
สะอาด
        @ -rm -f $ (เป้าหมาย) $ (OBJ) $ (DEPENDS)


## กฎสำหรับการกำหนดเป้าหมายที่แท้จริง
$ (เป้าหมาย): $ (OBJ)
        @echo "============="
        @echo "เชื่อมโยงเป้าหมาย $ @"
        @echo "============="
        @ $ (CC) $ (CFLAGS) -o $ @ $ ^ $ (LIBS)
        @echo - ลิงค์เสร็จแล้ว -

## กฎการคอมไพล์ทั่วไป
% .o:% .cpp
        @mkdir -p $ (ผ $ @)
        @echo "============="
        @echo "รวบรวม $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @


## กฎสำหรับไฟล์ออบเจ็กต์จากไฟล์ cpp
## ไฟล์ออบเจ็กต์สำหรับแต่ละไฟล์จะอยู่ในไดเร็กทอรี obj
## หนึ่งระดับขึ้นจากไดเร็กทอรีต้นทางจริง
../obj/%.o:% .cpp
        @mkdir -p $ (ผ $ @)
        @echo "============="
        @echo "รวบรวม $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @

# กฎสำหรับ "ไดเรกทอรีอื่น" คุณจะต้องมีหนึ่งข้อต่อผบ. "อื่น ๆ "
$ (OTHERDIR) /../ obj /%. o:% .cpp
        @mkdir -p $ (ผ $ @)
        @echo "============="
        @echo "รวบรวม $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @

## สร้างกฎการพึ่งพา
../.dep/%.d:% .cpp
        @mkdir -p $ (ผ $ @)
        @echo "============="
        @echo สร้างไฟล์อ้างอิงสำหรับ $ *. o
        @ $ (SHELL) -ec '$ (CC) -M $ (CFLAGS) $ <| sed "s ^ $ *. o ^ .. / obj / $ *. o ^"> $ @ '

## กฎการอ้างอิงสำหรับไดเรกทอรี "อื่น ๆ "
$ (OTHERDIR) /../. dep /%. d:% .cpp
        @mkdir -p $ (ผ $ @)
        @echo "============="
        @echo สร้างไฟล์อ้างอิงสำหรับ $ *. o
        @ $ (SHELL) -ec '$ (CC) -M $ (CFLAGS) $ <| sed "s ^ $ *. o ^ $ (OTHERDIR) /../ obj / $ *. o ^"> $ @ '

## รวมไฟล์อ้างอิง
- รวม $ (DEPENDS)

หากแหล่งที่มาถูกกระจายไปในหลายโฟลเดอร์และเป็นเรื่องที่สมเหตุสมผลที่จะมี Makefiles แต่ละรายการตามที่แนะนำไว้ก่อนหน้านี้การสร้างซ้ำเป็นแนวทางที่ดี แต่สำหรับโปรเจ็กต์ขนาดเล็กฉันพบว่าการแสดงรายการไฟล์ต้นฉบับทั้งหมดในMakefileนั้นง่ายกว่าด้วยพา ธ สัมพัทธ์ ไปยังMakefileดังนี้:

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

จากนั้นฉันสามารถตั้งค่าVPATHวิธีนี้:

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

จากนั้นฉันสร้างวัตถุ:

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

ตอนนี้กฎนั้นง่ายมาก:

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

และการสร้างผลลัพธ์นั้นง่ายยิ่งขึ้น:

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

เราสามารถทำให้การVPATHสร้างเป็นแบบอัตโนมัติโดย:

VPATH := $(dir $(COMMON_SRC))

หรือใช้ข้อเท็จจริงที่sortลบรายการที่ซ้ำกัน (แม้ว่าจะไม่สำคัญก็ตาม):

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

ฉันคิดว่าเป็นการดีกว่าที่จะชี้ให้เห็นว่าการใช้ Make (เรียกซ้ำหรือไม่) เป็นสิ่งที่คุณอาจต้องการหลีกเลี่ยงเนื่องจากเมื่อเทียบกับเครื่องมือในปัจจุบันแล้วการเรียนรู้ดูแลรักษาและปรับขนาดทำได้ยาก

เป็นเครื่องมือที่ยอดเยี่ยม แต่การใช้งานโดยตรงควรถือว่าล้าสมัยในปี 2010+

เว้นแต่คุณกำลังทำงานในสภาพแวดล้อมพิเศษเช่นกับโครงการเดิมเป็นต้น

ใช้ IDE, CMakeหรือหากคุณกำลัง cored หนักAutotools

(แก้ไขเนื่องจาก downvotes ty Honza เพื่อชี้ให้เห็น)

โพสต์ของ RC มีประโยชน์มาก ฉันไม่เคยคิดเกี่ยวกับการใช้ฟังก์ชัน $ (dir $ @) แต่มันทำในสิ่งที่ฉันต้องการให้ทำ

ใน parentDir มีไดเร็กทอรีจำนวนมากที่มีไฟล์ต้นฉบับอยู่ในนั้น: dirA, dirB, dirC ไฟล์ต่างๆขึ้นอยู่กับไฟล์อ็อบเจ็กต์ในไดเร็กทอรีอื่นดังนั้นฉันจึงต้องการสร้างไฟล์หนึ่งไฟล์จากภายในไดเร็กทอรีเดียวและทำให้การอ้างอิงนั้นขึ้นอยู่กับการเรียก makefile ที่เกี่ยวข้องกับการอ้างอิงนั้น

โดยพื้นฐานแล้วฉันสร้าง Makefile หนึ่งรายการใน parentDir ที่มีกฎทั่วไปคล้ายกับ RC:

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

ไดเร็กทอรีย่อยแต่ละรายการรวม makefile ระดับบนเพื่อสืบทอดกฎทั่วไปนี้ ใน Makefile ของไดเร็กทอรีย่อยแต่ละรายการฉันได้เขียนกฎที่กำหนดเองสำหรับแต่ละไฟล์เพื่อให้ฉันสามารถติดตามทุกอย่างที่แต่ละไฟล์ขึ้นอยู่กับ

เมื่อใดก็ตามที่ฉันต้องการสร้างไฟล์ฉันใช้ (โดยพื้นฐาน) กฎนี้เพื่อสร้างการอ้างอิงใด ๆ / ทั้งหมดซ้ำ ที่สมบูรณ์แบบ!

หมายเหตุ: มียูทิลิตี้ที่เรียกว่า "makepp" ซึ่งดูเหมือนจะทำงานนี้ได้อย่างสังหรณ์ใจมากขึ้น แต่เพื่อประโยชน์ในการพกพาและไม่ได้ขึ้นอยู่กับเครื่องมืออื่นฉันเลือกที่จะทำด้วยวิธีนี้

หวังว่านี่จะช่วยได้!

การใช้ Make ซ้ำ

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

สิ่งนี้ช่วยให้makeสามารถแยกออกเป็นงานและใช้หลายคอร์ได้

ฉันกำลังมองหาบางอย่างเช่นนี้และหลังจากลองผิดลองถูกฉันสร้าง makefile ของตัวเองฉันรู้ว่านั่นไม่ใช่ "วิธีการใช้สำนวน" แต่เป็นการเริ่มต้นที่จะเข้าใจการสร้างและวิธีนี้ได้ผลสำหรับฉันบางทีคุณอาจลองทำโครงการ

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!

ฉันรู้ว่ามันง่ายและสำหรับบางคนแฟล็กของฉันผิด แต่อย่างที่บอกว่านี่เป็น Makefile ตัวแรกของฉันที่รวบรวมโปรเจ็กต์ของฉันในไดร์หลาย ๆ อันและเชื่อมโยงทั้งหมดเข้าด้วยกันเพื่อสร้างถังขยะของฉัน

ฉันยอมรับข้อเสนอแนะ: D

ฉันแนะนำให้ใช้autotools:

//## วางอ็อบเจ็กต์ไฟล์ที่สร้างขึ้น (.o) ไว้ในไดเร็กทอรีเดียวกันกับไฟล์ต้นทางเพื่อหลีกเลี่ยงการชนกันเมื่อใช้การสร้างแบบไม่เรียกซ้ำ

AUTOMAKE_OPTIONS = subdir-objects

เพียงแค่รวมไว้ในMakefile.amสิ่งที่ค่อนข้างง่ายอื่น ๆ

นี่คือการกวดวิชา