本篇文章给大家谈谈makefile怎么使用，使用以及makefiled对应的使用知识点，希望对各位有所帮助，使用不要忘了收藏本站喔。使用

本文目录一览：

• 1、使用linux如何编写并使用makefile
• 2、使用Ubuntu下面Makefile的使用使用方法
• 3、makefile怎样使用？
• 4、使用指定Makefile
• 5、使用linux上的使用makefile怎么使用？

linux如何编写并使用makefile

1、先写Makefile编译出***.ko文件

模板如猛凯下，使用保存到命名为Makefile文件陵知游里，使用放到你代码的使用同级目录下

TARGET=my_proc.ko

LINUXDIR=/lib/modules/$(shell uname -r)/build

PWD=$(shell pwd)

obj-m :=

obj-m += my_proc.o

all: $(TARGET)

$(TARGET): $(OBJS)

make -C $(LINUXDIR) SUBDIRS=$(PWD) modules

clean:

rm -f modules.order Module.symvers $(TARGET) *.mod.c *.o

rm -rf .tmp_versions .mod* Module.markers

2、make

3、使用root权限下用命令插入模尺销块

insmod my_proc.ko

4、使用可以用你写的应用程序打开、操作模块了

5、查看模块命令

lsmod

cat /proc/modules

modinfo my_proc.ko

6、root下卸载模块

rmmod

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

makefile怎样使用？

用 命令： make -f 你的makefile的具体的名字橡销 再拍 Enter 键。

你可以起不同的文件名，例如梁笑游 mkfile1, mkfile2

make -f mkfile1

make -f mkfile2

文件升枝名 可带路径。

指定Makefile

前面我们说过，GNU make找寻默认的Makefile的规则是在当前目录下依次找三个文件——“GNUmakefile”好顷链、“makefile”和“Makefile”。其按顺序找这三个文件，一旦找到，就

开始读取这个文件并执行。

当前，我们也可以给make命令指定一个特殊名字的Makefile。要达到这友孙个功能，我们要使用make的“-f”或是“--file”参数（“-- makefile”参数也行）。例如，我们有个makefile的名字是“hchen.mk”，那么，我们可以这样来让make来执行这个文件：

如果在make的命令行是，你不只一次地使用了“-f”参数，那么，所有指定的makefile将会乎拆被连在一起传递给make执行。

linux上的makefile怎么使用？

一、Makefile的规则

在讲述这个Makefile之前，还是先来粗略地看一看Makefile的规则。

target ... : prerequisites ...

command

.......

target也就是一个目标文件，可以是Object File，也可以是执行文件。还可以是一个标签

（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。

prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。（任意的Shell命令）

这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisi

tes中的文件，其生成规则定义在command中。

二、一个示例

正如前面所说的，如果一个工程有3个头文件，和8个C文件，为了完成前面所述的那三

个规则，的Makefile应该是下面的这个样子的。

edit : main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

cc -o edit main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

main.o : main.c defs.h

cc -c main.c

kbd.o : kbd.c defs.h command.h

cc -c kbd.c

command.o : command.c defs.h command.h

cc -c command.c

display.o : display.c defs.h buffer.h

cc -c display.c

insert.o : insert.c defs.h buffer.h

cc -c insert.c

search.o : search.c defs.h buffer.h

cc -c search.c

files.o : files.c defs.h buffer.h command.h

cc -c files.c

utils.o : utils.c defs.h

cc -c utils.c

clean :

rm edit main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

反斜杠（\）是换行符的意思。这样比较便于Makefile的易读。可以把这个内容保存在

文件为“Makefile”或“makefile”的文件中，然后在该目录下直接输入命令“make”就

可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地

执行一下“make clean”就可以了。

在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依

赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。每一个 .o 文件都有

一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是

说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以

一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管亩运雹执行所定义的命令。m

ake会比悄旁较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期

要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命

令。

这里要说明一点的是，clean不是一个文件迅帆，它只不过是一个动作名字，有点像C语言中的

lable一样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自

动执行其后所定义的命令。要执行其后的命令，就要在make命令后明显得指出这个lable的

名字。这样的方法非常有用，可以在一个makefile中定义不用的编译或是和编译无关

的命令，比如程序的打包，程序的备份，等等。

三、makefile中使用变量

在上面的例子中，先让看看edit的规则：

edit : main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

cc -o edit main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

可以看到[.o]文件的字符串被重复了两次，如果的工程需要加入一个新的[.o]文

件，那么需要在两个地方加（应该是三个地方，还有一个地方在 clean中）。当然，

的makefile并不复杂，所以在两个地方加也不累，但如果makefile变得复杂，那么我

们就有可能会忘掉一个需要加入的地方，而导致编译失败。所以，为了makefile的易维护

，在makefile中可以使用变量。makefile的变量也就是一个字符串，理解成 C语言中

的宏可能会更好。

比如，声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ，反正不管

什么啦，只要能够表示obj文件就行了。在makefile一开始就这样定义：

objects = main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

于是，就可以很方便地在的makefile中以“$(objects)”的方式来使用这个变量

了，于是的改良版makefile就变成下面这个样子：

objects = main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

edit : $(objects)

cc -o edit $(objects)

main.o : main.c defs.h

cc -c main.c

kbd.o : kbd.c defs.h command.h

cc -c kbd.c

command.o : command.c defs.h command.h

cc -c command.c

display.o : display.c defs.h buffer.h

cc -c display.c

insert.o : insert.c defs.h buffer.h

cc -c insert.c

search.o : search.c defs.h buffer.h

cc -c search.c

files.o : files.c defs.h buffer.h command.h

cc -c files.c

utils.o : utils.c defs.h

cc -c utils.c

clean :

rm edit $(objects)

于是如果有新的 .o 文件加入，只需简单地修改一下 objects 变量就可以了。

四、make是如何工作的

在默认的方式下，输入make命令通过makefile编译程序时，具体的内部机制如下：

1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。

2、如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“

edit”这个文件，并把这个文件作为最终的目标文件。

3、如果edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个

文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。

4、如果edit所依赖的.o文件也不存在，那么make会在当前文件中找目标为.o文件的依赖性

，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）

5、当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文件生

命make的终极任务，也就是执行文件edit了。

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第

一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么ma

ke就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理

。make只管文件的依赖性，即，如果在我找了依赖关系之后，冒号后面的文件还是不在，

那么对不起，我就不工作啦。

通过上述分析，知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它

后面所定义的命令将不会被自动执行，不过，可以显示要make执行。即命令——“ma

ke clean”，以此来清除所有的目标文件，以便重编译。

于是在编程中，如果这个工程已被编译过了，当修改了其中一个源文件，比如fi

le.c，那么根据的依赖性，的目标file.o会被重编译（也就是在这个依性关系后

面所定义的命令），于是file.o的文件也是最新的啦，于是file.o的文件修改时间要比ed

it要新，所以edit也会被重新链接了（详见edit目标文件后定义的命令）。

而如果改变了“command.h”，那么，kdb.o、command.o和files.o都会被重编译，并

且，edit会被重链接。

关于makefile怎么使用和makefiled的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。