Ubuntu下面Makefile的使用方法

运行可执行文件hello

./hello

移除文件 rm hello

编译文件得到可执行文件的同时，保留产生的中间文件

g++ -save-temps hello_world.cpp -o hello

单个文件编译过程：

实际的编译过程：预处理，对应临时文件hello_world.ii

g++ -E hello_world.cpp -o preprocessed.ii

cat preprocessed.ii

预处理的工作主要包含去掉注释，然后将我们include的库tack上，以上过程使我们自己主动调用预处理器的过程

cat hello_world.ii

则展示了我们在第5)中编译时保留的中间文件，两者是一样的

实际的编译过程：这是真正的编译过程compilation step，对应临时文件hello_world.s（assembly code）

我们自己把.ii文件进行assembly code得到.s的方法。

g++ -S preprocessed.ii -o complied.s

.s文件是高级语言和机器语言之间的中间环节

实际的编译过程：Assembly，将.s对应的assembly code转换成.o对应的机器语言的过程，也叫machine-readable code或者object code

让编译器将.s文件assembly起来

g++ -c complied.s -o assembled.o

实际的编译过程：最后一步Linking，产生最终的可执行文件。

"Undefined reference" errors are pretty much always linking errors, and you will probably have them. Remember this.

我们通搭和答过连接一堆.o文件，得到.exe文件的过程，命令：

g++ assembled.o -o hello_manual

多个文件编译过程：

举例，如果我们棚物有定义一个class，然后我们的文件中包含dog.hpp，dog.cpp和main.cpp三个文件，然后我们只使用以下两个命令：

g++ -c main.cpp -o main.o

g++ main.o dog_program

的话就会出错，告诉我们undefined reference of dog::bark()

因为对于不同的.cpp文件，都要生成一个object file，也就是.o文件。所以如果我们用以下命令：

g++ -c main.cpp -o main.o

g++ -c dog.cpp

g++ dog.o main.o -o dog_program

的话，就不会出错。

我们如果修改main.cpp中的内容的话，我们只需要重新用最后一个连接命令。但是，如果我们修改了dog class本身的内知慧容的话，例如添加一个函数，我们就需要重新产生object file of dog.cpp，然后重新连接。

关于Make的介绍

用自己常用的记事本创建一个Makefile，并注意大小写。在program对应的目录下面。

gedit Makefile

Makefile里面语句的书写规则是

Target: tgt_dependency1 tgt_dependency2 ……

Command

所以dog.o和main.o对应的语句分别是：

dog.o: dog.hpp dog.cpp

g++ -c dog.cpp

main.o: main.cpp

g++ -c main.cpp

在Makefile中Tab是很重要的，所以不要忘记在command对应的第二行加Tab

Makefile的编译顺序

如果Makefile中有如下语句

animal_assembly : moose goose cat

command

moose : antlers hooves fur

command

goose : beak wings webbed_feet interest_in_bread

command

cat : whiskers evil_personality

command

我们可以看到animal_assembly的dependency是 moose goose cat。如果文件夹中存在moose goose cat的话，make命令只需要执行第一句就可以了。如果文件夹中缺少moose goose cat中的一个或者几个，make命令执行的时候，需要先找到moose goose cat的生成方法，然后执行对应的命令，最后执行animal_assembly生成的命令。

moose : antlers hooves fur

command

animal_assembly : moose goose cat

command

goose : beak wings webbed_feet interest_in_bread

command

cat : whiskers evil_personality

command

如果Makefille是以上形式的话，我们只运行make的话，Makefile会只执行第一句，因为第一句的dependency都存在了，所以只把moose生成的命令执行完就好了。如果我们要生成animal_assembly，就要运行命令make animal_assembly。所以，我们需要把最重要的命令，我们最重要生成的object file对应的命令放在第一行。

所以我们的dog_program的完整的Makefile文件应该是：

dog_program: dog.o main.o

g++ dog.o main.o -o dog_program

dog.o: dog.hpp dog.cpp

g++ -c dog.cpp

main.o: main.cpp

g++ -c main.cpp

在Makefile的最后写clean语句。

clean:

rm dog_program *.o

然后我们在命令窗口运行make clean的话，就会删除文件夹中生成的可执行文件，和所有过程中产生的副产品。

对于Makefile中的dependency list，我们需要将每个object file的dependency list都写好。因为make不负责检查文件中的具体的语句，只负责执行Makefile中的语句。

dog_program:

g++ dog.o main.o -o dog_program

dog.o: dog.hpp dog.cpp

g++ -c dog.cpp

main.o: main.cpp

g++ -c main.cpp

如果像上面所示去掉dog_program的dependency list的话，运行make就会出错，因为main是依赖于dog.cpp的。

如果文件中本身就存在dog.o和main.o的话，运行make不会出错，因为make就是先check dog.o main.o是否存在，存在的话就直接运行。

所以，我们如果修改了main.cpp或者dog.cpp的话，我们需要重新生成dog.o和main.o。因为make是不管这个问题的。

make这个命令的功能就是执行Makefile中我们要求执行的语句，对结果没有任何的预期，也不会检查命令有没有问题。所以，我们必须遵守Makefile书写中的一些规则。

all : fill_file_with_nonsense

echo "I have mostly created a lot of junk today!"

fill_file_with_nonsense : create_file

echo "Hello, there is nothing important here" >silly_file

create_file :

touch silly_file touch是Unix中的典型命令，用于生成空的文件

move_file :

mv silly_file silly_file_new_name

delete_file :

rm _file

open_file :

gedit another_silly_file

clean :

touch junk1 junk2 junk3 junk4 junk5

really_clean :

rm junk*

如果想体验的更加清楚，就可以运行这个文件中的内容，然后就知道make完全不会管结果是什么，只是没有脑子的执行命令。

解释上面的内容：

Makefile的书写规则。all: 放在第一句，把所以我们要生成executable依赖的Targets列出来，这样我们需要的所有的文件都可以生成。我们看到all对应的dependency是file_file_with_nonsense，就去找file_file_with_nonsense的生成语句，发现它的dependency是create_file，然后去找create_file的生成语句，就到touch silly_file，touch是Unix中的典型命令，用于生成空的文件。create_file的语句执行完之后，回到file_file_with_nonsense，执行echo "Hello, there is nothing important here" >silly_file，就把"Hello, there is nothing important here" 写入silly_file中，file_file_with_nonsense的语句也执行完之后，我们就返回到all，然后在命令行输出"I have mostly created a lot of junk today!"。

因为其他的target，不在all的dependency list中，也不在all的dependency的dependency当中，所以只能通过make target的形式来调用对应的命令。

Marvelous macros(宏)

一个宏的示例，宏就是Makefile中的variables，用来定义我们需要的 *** 作，一些变量之类的

CXX = clang++

FLAGS = -O

hello : hello_world.cpp

$(CXX) $(FLAGS) $? -o $@

clean :

rm hello

CXX，这是一个预定义的宏，default value是g++。这里把CXX定义成clang++了。

FLAGS，这里定义的是-O。FLAGS也不一定非得定义成-o，也可以是some moose have large antlers，但是这样定义的话，就会导致调用的时候出错。

对于上面的文件，我们在命令行输入make的时候，实际运行的是clang++ -O hello_world.cpp -o hello。

如果我们把CXX=clang++这一行删掉的话，在命令行输入make，实际运行的就是g++ -O hello_world.cpp -o hello。

定义好macro宏，我们使用的时候，就要用$(MACRO)这样的形式，这是makefile语言的一种语法。我们注意到MACRO全部用的大写，虽然不是明确规定的，但是通常情况下用大写。

$?和$@是makefile language里面特别的预定义的宏。$?是指的"names of the dependencies(newer than the target)"，$@是指的"name of the target"。

Complier and liner flags in CS 225

CXX = clang++ LD = clang++

CXXFLAGS = -std=c++1y -stdlib=libc++ -c -g -O0 -Wall -Wextra -Werror -pedantic

LDFLAGS = -std=c++1y -stdlib=libc++ -lpng -lc++abi

当我们写的程序文件比较少的时候，敲入gcc

/g++,当你在大型工程中，在一个个编译文件的话，你可能就会很郁闷。linux有一个自带的make命令，它让你的工作省去了很大的力气，但是你要学习如何编写makefile文件。

makefile是一种特殊的文件格式，他将会帮你自动管理你的项目，很强大。

下面通过实例一步步讲解如何使用makefile。下面的四段代码。

[cpp] view

plaincopyprint?

/////main.cpp

#include "functions.h"

int main()

{

print_hello()

cout <<endl

cout <<"The factorial of 5 is " <<factorial(5) <<endl

return 0

}

///hello.cpp

#include "functions.h"

void print_hello()

{

cout <<"Hello World!"

}

///factorial.cpp

#include "functions.h"

int factorial(int n)

{

if(n!=1)

{ return(n * factorial(n-1))}

else return 1

}

//functions.h

void

print_hello()

int factorial(int n)

/////main.cpp

#include "functions.h"

int main()

{

print_hello()

cout <<endl

cout <<"The factorial of 5 is " <<factorial(5) <<endl

return 0

}

///hello.cpp

#include "functions.h"

void print_hello()

{

cout <<"Hello World!"

}

///factorial.cpp

#include "functions.h"

int factorial(int n)

{

if(n!=1)

{ return(n * factorial(n-1))}

else return 1

}

//functions.h

void

print_hello()

int factorial(int n)

请将以上文件放到一个目录下。

请注意: 我用的是g++进行编译的，你也可以按照你自己的选择来编译程序

make的作用

如果你运行：make命令，

它将会自动的在你的目录下寻找makefile文件，然后执搭败大行它，如果你几个makefile文件，你可以指定某一个特定的makefile文件

使用如下命令：

make -f mymakefile

如果你想知道更多的make 用法，可以执行man make 命令

执行过程

编译器将会编译你的枯芹源文件，然后输出目标文件

链接器执行目标文件然后创建一个可执行文件。

手动编译

最不理想的一种执行方式就是

g++ main.cpp hello.cpp factorial.cpp -o hello

akefile 基本规则

makefile的基本规则是有以下构成：

target: dependencies

[tab] system command

利用以上语法编写如下

all:

g++main.cpp hello.cpp factorial.cpp -o hello

然后运行你的makefile，如下

make -f Makefile-1

如上代码叙述，所写的目标是all，all是makefile默认的目标，如果没有其他规定，make语法将要执行这个目标文件。

我们还发现，all 目标并没有依赖的，所以按照命令让他安全的执行。

最后，make 通过 我们给的命令进行编译程序

使用依赖

这是因为,如果你修改一个单独的文件在你的项目,你不必重新编译一切,只有你知竖修改。 请看下边的例子

[plain] view

plaincopyprint?

all: hello

hello: main.o factorial.o hello.o

g++ main.o factorial.o hello.o -o hello

main.o: main.cpp

g++ -c main.cpp

factorial.o: factorial.cpp

g++ -c factorial.cpp

hello.o: hello.cpp

g++ -c hello.cpp

clean:

rm -rf *o hello

all: hello

hello: main.o factorial.o hello.o

g++ main.o factorial.o hello.o -o hello

main.o: main.cpp

g++ -c main.cpp

factorial.o: factorial.cpp

g++ -c factorial.cpp

hello.o: hello.cpp

g++ -c hello.cpp

clean:

rm -rf *o hello

我们看到目标all

只有依赖，没有系统命令。为了去执行正确，它必须满足所有的目标所依赖的。目标都回去搜索所有的依赖，然后去执行它。

在例子中，我们看到了clean的目标，clean 这个目标就是清楚中间生成的.o文件和那些可执行文件

使用变量和注释

当你写makefil文件的时候，当你想改变一些编译的一些选项的时候，他是非常有用处的。

[plain] view

plaincopyprint?

# 这是注释，CC 编译器.

CC=g++

# CFLAGS 是选项

CFLAGS=-c -Wall

# 目标文件

OBJECTS=main.o factorial.o hello.o

all: hello

hello: $(OBJECTS)

$(CC) main.o factorial.o hello.o -o hello

main.o: main.cpp

$(CC) $(CFLAGS) main.cpp

factorial.o: factorial.cpp

$(CC) $(CFLAGS) factorial.cpp

hello.o: hello.cpp

$(CC) $(CFLAGS) hello.cpp

clean:

rm -rf *o hello

# 这是注释，CC 编译器.

CC=g++

# CFLAGS 是选项

CFLAGS=-c -Wall

# 目标文件

OBJECTS=main.o factorial.o hello.o

all: hello

hello: $(OBJECTS)

$(CC) main.o factorial.o hello.o -o hello

main.o: main.cpp

$(CC) $(CFLAGS) main.cpp

factorial.o: factorial.cpp

$(CC) $(CFLAGS) factorial.cpp

hello.o: hello.cpp

$(CC) $(CFLAGS) hello.cpp

clean:

rm -rf *o hello

你可以看到，使用这些有时候是非常有用的。你可以使用它们，赋值，当你想改变一些变量值的时候，然后你可以使用$(var),

来应用这些变量

如何继续下去

通过以上简要的介绍，你就可以简要的去编写一些更加复杂的makefile来运行你的复杂的程序了。上边讲的只是冰山一角

，你可以通过差一些make的文档来写。

[plain] view

plaincopyprint?

CC=g++

CFLAGS=-c -Wall

LDFLAGS=

SOURCES=main.cpp hello.cpp factorial.cpp

OBJECTS=$(SOURCES:.cpp=.o)

EXECUTABLE=hello

all: $(SOURCES) $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS)

$(CC) $(LDFLAGS) $(OBJECTS) -o $@

.cpp.o:

$(CC) $(CFLAGS) {1}lt-o $@

CC=g++

CFLAGS=-c -Wall

LDFLAGS=

SOURCES=main.cpp hello.cpp factorial.cpp

OBJECTS=$(SOURCES:.cpp=.o)

EXECUTABLE=hello

all: $(SOURCES) $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS)

$(CC) $(LDFLAGS) $(OBJECTS) -o $@

.cpp.o:

$(CC) $(CFLAGS) {1}lt-o $@

通过以上简要的介绍，你就可以简要的去编写一些更加复杂的makefile来运行你的复杂的程序了。上边讲的只是冰山一角

，你可以通过差一些make的文档来写。

---