什么是makefile的C++的

Question

格式我以前用过类似

g++ myfile.cpp -o myoutput 

命令来编译我的C++代码，但我想转移到使用的makefile。所以我不知道天气我听起来愚蠢或不是，制造文件的简单格式是什么

就像我有一个名为template.cpp的cpp文件，我该如何编译它使用make？

Answer 1

最简单的makefile，你问什么，看起来是这样的：

myfile: myfile.cpp 
    g++ myfile.cpp -o myfile 

请注意，这是第二行的硬标签。如果你在一个名为makefile的文件中有这个，那么你可以从终端运行make来编译你的代码。

顺便说一句，this是写makefiles的绝好教程 - 非常值得一读。

Answer 2

我推荐你这个链接。它向你介绍轻松学习如何为CPP做的makefile makefiles easy

我也建议您在此模板，我弗朗在这里使用template

# A sample Makefile 
# This Makefile demonstrates and explains 
# Make Macros, Macro Expansions, 
# Rules, Targets, Dependencies, Commands, Goals 
# Artificial Targets, Pattern Rule, Dependency Rule. 

# Comments start with a # and go to the end of the line. 

# Here is a simple Make Macro. 
LINK_TARGET = test_me.exe 

# Here is a Make Macro that uses the backslash to extend to multiple lines. 
OBJS = \ 
Test1.o \ 
Test2.o \ 
Main.o 

# Here is a Make Macro defined by two Macro Expansions. 
# A Macro Expansion may be treated as a textual replacement of the Make Macro. 
# Macro Expansions are introduced with $ and enclosed in (parentheses). 
REBUILDABLES = $(OBJS) $(LINK_TARGET) 

# Here is a simple Rule (used for "cleaning" your build environment). 
# It has a Target named "clean" (left of the colon ":" on the first line), 
# no Dependencies (right of the colon), 
# and two Commands (indented by tabs on the lines that follow). 
# The space before the colon is not required but added here for clarity. 
clean : 
    rm -f $(REBUILDABLES) 
    echo Clean done 

# There are two standard Targets your Makefile should probably have: 
# "all" and "clean", because they are often command-line Goals. 
# Also, these are both typically Artificial Targets, because they don't typically 
# correspond to real files named "all" or "clean". 

# The rule for "all" is used to incrementally build your system. 
# It does this by expressing a dependency on the results of that system, 
# which in turn have their own rules and dependencies. 
all : $(LINK_TARGET) 
    echo All done 

# There is no required order to the list of rules as they appear in the Makefile. 
# Make will build its own dependency tree and only execute each rule only once 
# its dependencies' rules have been executed successfully. 

# Here is a Rule that uses some built-in Make Macros in its command: 
# $@ expands to the rule's target, in this case "test_me.exe". 
# $^ expands to the rule's dependencies, in this case the three files 
# main.o, test1.o, and test2.o. 
$(LINK_TARGET) : $(OBJS) 
    g++ -g -o $@ $^ 

# Here is a Pattern Rule, often used for compile-line. 
# It says how to create a file with a .o suffix, given a file with a .cpp suffix. 
# The rule's command uses some built-in Make Macros: 
# $@ for the pattern-matched target 
# $< for the pattern-matched dependency 
%.o : %.cpp 
    g++ -g -o $@ -c $< 

# These are Dependency Rules, which are rules without any command. 
# Dependency Rules indicate that if any file to the right of the colon changes, 
# the target to the left of the colon should be considered out-of-date. 
# The commands for making an out-of-date target up-to-date may be found elsewhere 
# (in this case, by the Pattern Rule above). 
# Dependency Rules are often used to capture header file dependencies. 
Main.o : Main.h Test1.h Test2.h 
Test1.o : Test1.h Test2.h 
Test2.o : Test2.h 

# Alternatively to manually capturing dependencies, several automated 
# dependency generators exist. Here is one possibility (commented out)... 
# %.dep : %.cpp 
# g++ -M $(FLAGS) $< > $@ 
# include $(OBJS:.o=.dep)