vcsmakefile怎么写_育才学习网

下面我给出一个我写的一个简单的 Makefile 给你参考一下吧：# Makefile for 'kmp'CC=gccCFLAGS=-gkmp: kmpindex.o getnext.o main.o $(CC) -o kmp kmpindex.o getnext.o main.okmpindex.o: kmpindex.c kmp.h $(CC) -c kmpindex.cgetnext.o: getnext.c kmp.h $(CC) -c getnext.cmain.o: main.c kmp.h $(CC) -c main.cclean: rm -f *.o# END没有太多的注释，因为是用于小测试的。希望对你有所帮助。

3.eclipse CDT配置好了怎么写makefile

CDT配置好了编写makefile的方法：

在建立工程的时候选择makefile工程。

这是上面那个程序的Makefile文件：

main:main.o mytool1.o mytool2.o

gcc -o main main.o mytool1.o mytool2.o

main.o:main.c mytool1.h mytool2.h

gcc -c main.c

mytool1.o:mytool1.c mytool1.h

gcc -c mytool1.c

mytool2.o:mytool2.c mytool2.h

gcc -c mytool2.c

4.makefile：多个目录下makefile 的写法

1、假定.h文件在Header目录里，.c文件在Source目录里，这两个目录文件在Myapp中，Makefile也在Myapp中。

2、Makefile如下。

----------------------------------------------------------------------------------

all: myapp

myapp: main.o b.o c.o

gcc -o myapp main.o b.o c.o

main.o: ./Source/main.c ./Header/a.h

gcc -c ./Source/main.c -I./Header

b.o: ./Source/b.c ./Header/a.h ./Header/b.h

gcc -c ./Source/b.c -I./Header

c.o: ./Source/c.c ./Header/b.h ./Header/c.h

gcc -c ./Source/c.c -I./Header

clean:

rm -f *.o

------------------------------------------------------------

3、话说回来，这样做太麻烦。

5.如何使用cmake编译java工程

Cmake的介绍和使用 Cmake实践 Cmake优点：1. 开发源代码，实用类BSD许可发布。

2. 跨平台，并可以生成native编译配置文件，在linux/unix平台，生成makefile，在mac平台可以生成xcode，在windows平台可以生成msvc工程的配置文件。3. 能够管理大型项目4. 简化编译构建过程和编译过程，只需要cmake+make就可以5. 高效率6. 可扩展，可以为cmake编写特定功能的模块，扩充cmake功能如何安装cmake1. Cmake的安装可以使用autotools进行安装，点击cmake-2.8.6.tar.gz 链接，可以对软件进行下载。

2. ./configure3. make4. sudo make install Cmake的原理 Helloworld cmake//main.cpp#include int main() { printf("helloworld from main\n"); return 0； } 创建CMakeLists.txt（注意大小写一个字母都不能错）向该文件中加入以下几行（稍后会做解释） PROJECT (HELLO) SET(SRC_LIST main.cpp) MESSAGE(STATUS "This is BINARY dir" ${HELLO_BINARY_DIR}) MESSAGE(STATUS "This is SOURCE dir"${HELLO_SOURCE_DIR}) ADD_EXECUTABLE(hello ${SRC_LIST}) 运行以下命令：cmake . （别忘记加上这个点，表示当前目录）注意执行完这句话之后会生成几个文件如下：CMakeFiles, CMakeCache.txt, cmake_installNaNake等文件，并且生成了Makefile 然后执行make 就可以生成可执行文件hello 这是当前目录下就会生成可执行文件如下图：对例子的解释：CMakeLists.txt的内容如下：PROJECT (HELLO) SET(SRC_LIST main.cpp) MESSAGE(STATUS "This is BINARY dir" ${HELLO_BINARY_DIR}) MESSAGE(STATUS "This is SOURCE dir "${HELLO_SOURCE_DIR}) ADD_EXECUTABLE(hello ${SRC_LIST}) Project的指令的语法是：PROJECT(projectname [CXX] [C] [JAVA]) 这个执行是用来定义工程的名称的和定义工程支持的语言。这个指令也隐式的定义了两个cmake变量：_BINARY_DIR以及_BINARY_DIR，这里就是HELLO_BINARY_DIR和HELLO_SOURCE_DIR，两个变量指的都是当前工程的路径。

SET指令的语法：SET(VAR[VALUE] [CACHE TYPE DOCSTRING [FORCE]]) Set指令是用来显式的定义变量的，我们之前用到的是SET(SRC_LIST main.cpp)如果有多个源文件，也可以定义成SET(SRC_LISTmain.cpp t1.cpp t2.cpp)。MESSAGE指令的语法是：MESSAGE([SEND_ERROR | STATUS | FATAL_ERROR]"message to display" 。

) 这个指令用于向终端输出用户信息，包含三种类型：SEND_ERROR，产生错误，生成过程被跳过。SATUS，输出前缀为-的信息。

FATAL_ERROR，立即终止所有cmake过程。我们在这里使用的是STATUS信息输出，显示了由PROJECT指令顶一顶两个饮食变量HELLO_BINARY_DIR和HELLO_SOURCE_DIR。

ADD_EXECUTABLE(hello ${SRC_LIST}) 定义了这个工程会生成一个文件名为hello的可执行文件，相关的源文件是SRC_LIST中定义的源文件列表，本例中你可以直接写成ADD_EXECUTABLE(hellomain.c)。将本例改写成一个最简化的CMakeLists.txt:PROJECT(HELLO) ADD_EXECUTABLE(hello main.c) 下面我们介绍一个比较实用的例子，即包含生成静态库又包含引入外部头文件和链接库的cmakedemo。

先按照工程规范建立工程目录，并编写代码，以下面的工程目录为例进行解释这个例子，工程的目录结构为：编译工程要实现的目标：1. 添加子目录doc，用以放置这个工程的文档hello.txt2. 生成hello的静态库，并在main可执行程序链接hello静态库3. 在这个工程中添加COPYRIGHT,README4. 在工程目录中添加一个run.sh的脚本，用以调用生成的二进制可执行文件5. 将生成的二进制文件生成到bin子目录中6. 编写安装程序1. 编写CMakeLists.txt 由于一个工程目录中包含多个项目，其中在此项目中包含util项目和main项目，其中util项目是用以生成main程序需要的静态库，main是用以生成可执行文件。在工程项目中的父目录向有一个CMakeLists.txt是用以声明定义工程需要的Cmake设置还定义了子目录src，用以递归的调用src中的MakeLists.txt。

其中工程目录的CMakeLists.txt内容定义如下：PROJECT(HELLO) ADD_SUBDIRECTORY(src) 在src里面的CMakeLists.txt是用以定义src目录包含的两个工程的依赖关系分别进行编译。util目录里面的CMakeLists.txt是用以定义生成util静态库的规则，其中内容如下：SET(LIBRARY_OUTPUT_PATH ${HELLO_SOURCE_DIR}/lib) SET(CMAKE_C_COMPILER g++) SET(SRC_LIST hello.c) INCLUDE_DIRECTORIES(${HELLO_SOURCE_DIR}/include) ADD_LIBRARY(util STATIC ${SRC_LIST}) 其中SET(LIBRARY_OUTPUT_PATH ${HELLO_SOURCE_DIR}/lib)定义了库生成的路径，LIBRARY_OUTPUT_PATH是一个内部变量，存放库生成路径。

SET(SRC_LIST hello.c)是用来定义库文件需要的源文件。INCLUDE_DIRECTORIES(${HELLO_SOURCE_DIR}/include)是用来定义非标准库头文件要搜索的。

6.编写一个实现Hello World简单显示功能的Makefile文件

#########################################################

.suffixes:.c

.suffixes:.o

.c.o:

gcc -o -c $#########################################################

os=unix

workdir=$(home)

makefile = makefile

incl=$(workdir)

lib =

obj=mytest.o

all: mytest

@echo " "

@echo " 编译成功！ "

@echo " "

mytest: $(obj)

@echo "compiling。"

@gcc -o $@ $(obj) $(lib)

@rm *.o

@echo " "

7.怎样用 vim 编写 Java?

你得先装好JDK，什么系统乌班图吗？

先下个JDK,linux版本的JDK貌似是解压即使用的，然后设置系统路径，最后JAVA-VISION看一下

给你个参考地址

这会你就可以用VIM编辑JAVA文件了，和C语言编辑差不多，不过VIM好像没有插件就不识别JAVA的关键字，

/articles/um2QNr

这个微博会交你如何用插件

最后开发好的程序编译就是在终端输入JAVAC这类的编译命令了

比如

我有一个test.java源文件

javac test.java

生成一个class

java test

就输出了

java也支持MAKEFILE 但那是**

你可以上网查查ANT构建JAVA项目

javamakefile怎么写

makefileclean怎么写

1.如何写Makefile

hello: hello.o

gcc -o hello hello.o

hello.o: hello.c

gcc -c hello.c

clean:

rm -f hello *.o *.bak *~这就是最简单的helloworld的makefile有三个目标：hello、hello.o、clean，最上面的那个是默认目标，make不带参数时，找的就是这个目标。目标回溯过程：

目标hello =>；依赖于hello.o =>；目标hello.o =>；依赖于 hello.c => hello.c =>；成功

目标生成过程：

gcc -c hello.c =>；得到hello.o =>；执行gcc -o hello hello.o =>；得到hello => make成功！示例：

make

make hello.o

make clean

2.linux makefile怎么写

INC_PATH := -I./include/

LIB_PATH := -L./lib/

LIBS := $(LIB_PATH) -lerr -larm

CC := gcc

LD := gcc

CFLAGS := -O2 -Wall $(INC_PATH)

SRC_PATH := ./source

SOURCE := $(SRC_PATH)/a.c\

$(SRC_PATH)/b.c\

$(SRC_PATH)/c.c

TARGET := target

OBJS := a.o b.o c.o

$(TARGET): $(OBJS)

$(LD) -O2 -o $(TARGET) $(OBJS) $(LIBS)

a.o : $(SRC_PATH)/a.c

$(CC) $(CFLAGS) -c -o $@ $

3.如何自己编写Makefile

相信很多朋友都有过这样的经历，看着开源项目中好几页的makefile文件，不知所云。

在日常学习和工作中，也有意无意的去回避makefile，能改就不写，能用ide就用ide。其实makefile并没有想象的那么难写，只要你明白了其中的原理，自己实践几次。

你也可以自己写makefile，让别人对你头来羡慕的目光。下面本人介绍一下自己的学习成果，初学阶段，欢迎大家多多指正。

简单的说，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至可以在makefile中执行shell脚本。makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。

关于程序的编译和链接一般来说，无论是C还是C++，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动作叫做编译（compile），一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。

编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。

链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File），也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。

下面我们开始看看如何自己写出makefile。 Makefile的规则目标：需要的条件（注意冒号两边有空格）命令（注意前面用tab键开头）解释一下： 1 目标可以是一个或多个，可以是Object File，也可以是执行文件，甚至可以是一个标签。

2 需要的条件就是生成目标所需要的文件或目标 3 命令就是生成目标所需要执行的脚本总结一下，就是说一条makefile规则规定了编译的依赖关系，也就是目标文件依赖于条件，生成规则用命令来描述。在编译时，如果需要的条件的文件比目标更新的话，就会执行生成命令来更新目标。

下面举个简单的例子说明。如果一个工程有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文件中，然后执行make就可以进行编译，执行make clean就可以删除所有目标文件。解释一下，也就是说生成最终的目标文件edit，依赖于一系列的.o目标文件，而这些.o文件又是需要用源文件来编译生成的。

需要注意的是，clean后面没有条件，而clean本身也不是文件，它只不过是一个动作名字，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。 make是如何工作的在默认的方式下，也就是我们只输入make命令。

那么， 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了。 makefile中使用变量前面的知识已经足以让你自己完成一个简单的makefile了，不过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 。

4.这个makefile文件怎么写

obj-m =xxx.o

KDIR=xxx

PWD =$(shell pwd)

all:

make -C $(KDIR) M=$(PWD) modules

clean:

@rm -vf *.o *.ko *. *.mod.c *.order *.mod.o *.symvers *~

其中的xxx.o需要你自己填写，比如你这个文件是hello.c，那就写成hello.o，然后KDIR=xxx，这个xxx是linux源码目录，比如/home/xxx/kernel，那就写成KDIR = /home/xxx/kernel，然后在Makefile的目录下执行make就行了

5.怎么写这个程序的Makefile文件

Makefile文件名字，放在这个你这个程序的目录中：

prog=app

OBJS=sin_value.o cos_value.o haha.o main.c

LDFLAGS：= #这个是编译参数例：-lpthread 线程库

CFLAGS:= -g -Wall #可调式，以及编译警告通知

all:$(prog)

sin_value.o:sin_value.c

$(CXX) $(CFLAGS) -c -o $@ $^

cos_value.o:cos_value.c

$(CXX) $(CFLAGS) -c -o $@ $^

haha.o: haha.c

$(CXX) $(CFLAGS) -c -o $@ $^

main.o:main.c

$(CXX) $(CFLAGS) -c -o $@ $^

install:

cp $(prog) /bin

clean:

rm -rf *.o *~

rm -rf $(prog)

rm -rf /bin/$(prog)

$(prog):$(OBJS)

$(CXX) $(LDFLAGS) -o $@ $^

6.如何写Makefile

hello: hello.o gcc -o hello hello.ohello.o: hello.c gcc -c hello.cclean: rm -f hello *.o *.bak *~这就是最简单的helloworld的makefile有三个目标：hello、hello.o、clean，最上面的那个是默认目标，make不带参数时，找的就是这个目标。

目标回溯过程：目标hello => 依赖于hello.o => 目标hello.o => 依赖于 hello.c => hello.c => 成功目标生成过程： gcc -c hello.c => 得到hello.o =>执行gcc -o hello hello.o => 得到hello => make成功！示例：makemake hello.omake clean。

7.makefile怎么写

makefileclean怎么写

linuxmakefile怎么写

1.使用linux编程怎么写makefile

Makefile语法基础

在Linux下，自动化编译工具是通过make命令来完成的（一些工具厂商也提供了它们自己的make命令，如gmake等），make命令的基本格式如下：

make [-f makefile] [label]

它可以通过-f参数指定输入文件，当省略-f参数时，默认输入文件名为Makefile，由于我们通常不用这个-f参数，往往就用默认的Makefile文件名。

Makefile是一个文本文件，它是基于一定的语法规则的，它的基本执行规则定义如下：

target : [prerequisites]

command

target 标签，用于标志当前构建的规则，它也可以是文件。

prerequisites 依赖项，在构建该标签的时候先执行的规则

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

注意：Makefile的target是顶格写的，而Command需要加一个Tab键。我这里为了排版看起来舒服点，每一行都多加了一个Tab键，如果要使用本文的Makefile示例，请去掉各行的第一个Tab键，否则make的时候报错。

例如，我们编写一个简单的Makefile:

clean:

@echo "clean"

all:

@echo "all"

当我们直接执行make命令的时候，输出如下：

tianfang > make

clean

tianfang > make all

all

tianfang > make clean

clean

从中我们可以看到：默认情况下构建第一个标签。可以通过在命令行参数中通过参数构建指定标签。

2.linux下makefile用什么写

1234567891011121314151617181920212223INC_PATH := -I./include/LIB_PATH := -L./lib/LIBS := $(LIB_PATH) -lerr -larmCC := gccLD := gccCFLAGS := -O2 -Wall $(INC_PATH)SRC_PATH := ./sourceSOURCE := $(SRC_PATH)/a.c\ $(SRC_PATH)/b.c\ $(SRC_PATH)/c.cTARGET := targetOBJS := a.o b.o c.o$(TARGET): $(OBJS) $(LD) -O2 -o $(TARGET) $(OBJS) $(LIBS)a.o : $(SRC_PATH)/a.c $(CC) $(CFLAGS) -c -o $@ $

3.linux 命令行怎么写make makefile命令

无论是在Linux还是在Unix环境中，make都是一个非常重要的编译命令。不管是自己进行项目开发还是安装应用软件，我们都经常要用到make或make

install。利用make工具，我们可以将大型的开发项目分解成为多个更易于管理的模块，对于一个包括几百个源文件的应用程序，使用make和

makefile工具就可以简洁明快地理顺各个源文件之间纷繁复杂的相互关系。而且如此多的源文件，如果每次都要键入gcc命令进行编译的话，那对程序员

来说简直就是一场灾难。而make工具则可自动完成编译工作，并且可以只对程序员在上次编译后修改过的部分进行编译。因此，有效的利用make和

makefile工具可以大大提高项目开发的效率。同时掌握make和makefile之后，您也不会再面对着Linux下的应用软件手足无措了。

但令人遗憾的是，在许多讲述Linux应用的书籍上都没有详细介绍这个功能强大但又非常复杂的编译工具。在这里我就向大家详细介绍一下make及其描述文件

makefile。

Makefile文件

Make工具最主要也是最基本的功能就是通过makefile文件来描述源程序之间的相互关系并自动维护编译工作。而makefile 文件需要按照某种语法进行编写，文件

中

需要说明如何编译各个源文件并连接生成可执行文件，并要求定义源文件之间的依赖关系。makefile 文件是许多编译器--包括 Windows NT

下的编译器--维护编译信息的常用方法，只是在集成开发环境中，用户通过友好的界面修改 makefile 文件而已。

4.哪位大神帮我下,怎么编写linux下makefile文件

比如，你有个文件 hello.c:

# include <stdio.h>

main()

{

printf("Hello, world!\n");

}

你再写一个 Makefile:

Hello: hello.c

gcc hello.c -o Hello

然后，你直接下命令：

make

你就得到一个叫 Hello 的可执行文件。

最后，你下命令：

./Hello

就可以看到执行结果：

Hello, World

注意：作为执行命令的 “gcc” 前面必须有一个 Tab 键

5.这个makefile文件怎么写

obj-m =xxx.o

KDIR=xxx

PWD =$(shell pwd)

all:

make -C $(KDIR) M=$(PWD) modules

clean:

@rm -vf *.o *.ko *. *.mod.c *.order *.mod.o *.symvers *~

6.如何自己编写Makefile

什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。

这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。

因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make,Visual C++的nmake,Linux下GNU的make。

可见，makefile都成为了一种在工程方面的编译方法。现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。

当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0,make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。

而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。

这里所默认的编译器是UNIX下的GCC和CC。

linuxmakefile怎么写

makefile怎么写install

1. makefile中怎么写 install 格式

.PHONY: install

--------------------

原始内容

--------------------

install: liba.so

cp liba.so /xxx/xxx/xxx/liba.so

只是举了个例子，因为也不知道你的程序，完全不懂make，最好看书。

别人的例子：

使用install的

prefix=/usr/local

install: our_program

install -m 0755 our_program $(prefix)/bin

install -m 0644 *.png $(prefix)/share/our_program/icons

.PHONY: install

2. 此makefile文件中,install部分可以这么写吗

install:

if [ -f /usr/bin/wmctrl ];then \

echo yes \

else \

echo no \

exit 1 \

fi; \

mkdir -p $(BINDIR) \

$(INSTALL) $(PROG_ALL) $(BINDIR)

需要添加 \ 符号。表示install这些命令，按照先后顺序执行。

否则，每个命令都是一个子进程。

3. linux 中的make install

make的原理是执行一个叫Makefile文件里的指令，make的基本用处是自动根据makefile里的指令来编译源文件。它还可以用来做比如安装软件，卸载软件等事情，但前提是作者在makefile里写了。比如makefile里有这么些内容：

install :

然后用make install的话，make程序就会按照上面install：后面的指令执行安装，uninstall也是一样的道理，大部分的作者会写有卸载的部分，这时只要简单地执行make unistall就可以，如果作者懒没有写，那就只有根据make install中的步骤，看它把什么文件拷到哪去了，然后分别手动删除。

还有关键的一点是，编译安装完成后，不要删除源代码，不然就算作者写了unnistall目标，你也没有makefile可以执行了。

4. linux 在哪个目录 make make install

make的当然是在源代码文件的目录，因为make命令执行的，其实是一个名为makefile，或者是名为Makefile(Linux是大小写敏感的)的文件里的内容，这个文件就是你下载的源代码压缩包，解压后的目录里面的，和代码文件位于同一个目录。

而make install执行的其实是Makefile里面的，一个名为“install”的“目标”（“目标”是Makefile里面的一个概念），这个“目标”后面跟的是一段命令，可以理解为“目标”后跟了一段shell脚本，这段命令执行的就是把make好的程序安装到系统的操作。如果你要看看具体install到了那个目录，可以查看这个Makefile文件的内容，看看install这个“目标”中定义的安装目录的宏（“宏”也是Makefile中的一个概念），宏是全部大写的变量，这个宏类似于$（INSTDIR）这种字样。

5. makefile：多个目录下makefile 的写法

1、假定.h文件在Header目录里，.c文件在Source目录里，这两个目录文件在Myapp中，Makefile也在Myapp中。

2、Makefile如下。

----------------------------------------------------------------------------------

all: myapp

myapp: main.o b.o c.o

gcc -o myapp main.o b.o c.o

main.o: ./Source/main.c ./Header/a.h

gcc -c ./Source/main.c -I./Header

b.o: ./Source/b.c ./Header/a.h ./Header/b.h

gcc -c ./Source/b.c -I./Header

c.o: ./Source/c.c ./Header/b.h ./Header/c.h

gcc -c ./Source/c.c -I./Header

clean:

rm -f *.o

------------------------------------------------------------

3、话说回来，这样做太麻烦。

6. 如何写Makefile文件

如果你想写 Makefile 的话，那么你只要用一个不将制表符过滤掉的文本编辑器就可以了，用 vi/vim 可以，用 emacs 可以，用其它的 geditor 也是可以的，只要是文本编辑器就可以了。你在 win 下也可以用记事本写 Makefile ，当然要确保你的系统已经安装了 make 了（最好了 GNU make）。Makefile 是不需要后缀的，也就是说 Makefile 的文件名就是 Makefile。

下面我给出一个我写的一个简单的 Makefile 给你参考一下吧：

# Makefile for 'kmp'

CC=gcc

CFLAGS=-g

kmp: kmpindex.o getnext.o main.o

$(CC) -o kmp kmpindex.o getnext.o main.o

kmpindex.o: kmpindex.c kmp.h

$(CC) -c kmpindex.c

getnext.o: getnext.c kmp.h

$(CC) -c getnext.c

main.o: main.c kmp.h

$(CC) -c main.c

clean:

rm -f *.o

# END

没有太多的注释，因为是用于小测试的。希望对你有所帮助

7. 如何编写makefile

你先用gcc把它给编译出来。然后再想用makefile

gcc最一般的用法就是：

gcc -o 要生成的可执行文件名源代码文件名

如：gcc -o hello.x hello.c

如果一些头文件要指明的话，可以这样：

gcc -o hello.x -I头文件所在的文件夹 -l一些库名 hello.c

最通常，我们用到一些数学库。gcc -o hello.x -lm hello.c

makefile的话，你可以基于上述的语句进行修改：建议你看点资料，或一些典型的例子。但是注意的是规则那一行，得用Tab键打头。

hello.x : hello.o

gcc -o hello.x hello.o （这一行，得用Tab打头）

hello.o : hello.c 头文件

gcc -c hello.o hello.c -I头文件所在目录 -lm （这一行，得用Tab打头）

makefile怎么写install

makefile怎么写

1. makefile怎么写

下面我给出一个我写的一个简单的 Makefile 给你参考一下吧：

# Makefile for 'kmp'

CC=gcc

CFLAGS=-g

kmp: kmpindex.o getnext.o main.o

$(CC) -o kmp kmpindex.o getnext.o main.o

kmpindex.o: kmpindex.c kmp.h

$(CC) -c kmpindex.c

getnext.o: getnext.c kmp.h

$(CC) -c getnext.c

main.o: main.c kmp.h

$(CC) -c main.c

clean:

rm -f *.o

# END

没有太多的注释，因为是用于小测试的。希望对你有所帮助

2. 如何自己编写Makefile

可见，makefile都成为了一种在工程方面的编译方法。现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。

这里所默认的编译器是UNIX下的GCC和CC。

3. 如何写一个简单的makefile

一：makefile 雏形：

#makefile的撰写是基于规则的，当然这个规则也是很简单的，就是：

#target : prerequisites

command //任意的shell 命令

实例如下：

makefile:

helloworld : main.o print.o #helloword 就是我们要生成的目标

# main.o print.o是生成此目标的先决条件

gcc -o helloworld main.o print.o#shell命令，最前面的一定是一个tab键

mian.o : mian.c print.h

gcc -c main.c

print.o : print.c print.h

gcc -c print.c

clean :

rm helloworld main.o print.o

OK，一个简单的makefile制作完毕，现成我们输入 make，自动调用Gcc编译了，

输入 make clean就会删除 hellowworld mian.o print.o

二：小步改进：

在上面的例子中我们可以发现 main.o print.o 被定义了多处，

我们是不是可以向C语言中定义一个宏一样定义它呢？当然可以：

makefile:

objects = main.o print.o #应该叫变量的声明更合适

helloworld : $(objects) //声明了变量以后使用就要$（）了

gcc -o helloworld$(objects)

mian.o : mian.c print.h

gcc -c main.c

print.o : print.c print.h

gcc -c print.c

clean :

rm helloworld $(objects)

修改完毕，这样使用了变量的话在很多文件的工程中就能体现出方便性了。

三：再进一步：

再看一下，为没一个*.o文件都写一句gcc -c main.c是不是显得多余了，

能不能把它干掉？而且 main.c 和print.c都需要print.h，为每一个都写上是

不是多余了，能不能再改进？

能，当然能了：

makefile:

objects = main.o print.o

helloworld : $(objects)

gcc -o helloworld$(objects)

$(objects) : print.h # 都依赖print.h

mian.o : mian.c #干掉了gcc -c main.c 让Gun make自动推导了。

print.o : print.c

clean :

rm helloworld $(objects)

4. 如何编写makefile

你先用gcc把它给编译出来。

然后再想用makefilegcc最一般的用法就是：gcc -o 要生成的可执行文件名源代码文件名如：gcc -o hello.x hello.c如果一些头文件要指明的话，可以这样：gcc -o hello.x -I头文件所在的文件夹 -l一些库名 hello.c最通常，我们用到一些数学库。gcc -o hello.x -lm hello.cmakefile的话，你可以基于上述的语句进行修改：建议你看点资料，或一些典型的例子。

但是注意的是规则那一行，得用Tab键打头。hello.x : hello.o gcc -o hello.x hello.o （这一行，得用Tab打头）hello.o : hello.c 头文件 gcc -c hello.o hello.c -I头文件所在目录 -lm （这一行，得用Tab打头）。

5. 如何写makefile?

CC=gcc

TARGET=compute

DEPEND=compute.o mymath.o

$(TARGET):$(DEPEND)

（这前面是一个TAB键，不要有空格）$（CC） -o $@ $^ -g -Wall

.c.o:

（这前面是一个TAB键，不要有空格） $（CC） -c $^ -g

.PHONY:clean

clean:

（这前面是一个TAB键，不要有空格） rm $(DEPEND)

#下面为说明

#Makefile的格式为Target（目标）：depend（依赖）

# (TAB)command（生成目标的命令）

#其中：%@ 为目标，$^ 为所有的依赖文件，$

6. 如何写一个简单的makefile

一：makefile 雏形：#makefile的撰写是基于规则的，当然这个规则也是很简单的，就是：#target : prerequisitescommand //任意的shell 命令实例如下：makefile:helloworld : main.o print.o #helloword 就是我们要生成的目标# main.o print.o是生成此目标的先决条件gcc -o helloworld main.o print.o#shell命令，最前面的一定是一个tab键mian.o : mian.c print.hgcc -c main.cprint.o : print.c print.hgcc -c print.cclean :rm helloworld main.o print.oOK，一个简单的makefile制作完毕，现成我们输入 make，自动调用Gcc编译了，输入 make clean就会删除 hellowworld mian.o print.o二：小步改进：在上面的例子中我们可以发现 main.o print.o 被定义了多处，我们是不是可以向C语言中定义一个宏一样定义它呢？当然可以：makefile:objects = main.o print.o #应该叫变量的声明更合适helloworld : $(objects) //声明了变量以后使用就要$（）了gcc -o helloworld$(objects)mian.o : mian.c print.hgcc -c main.cprint.o : print.c print.hgcc -c print.cclean :rm helloworld $(objects)修改完毕，这样使用了变量的话在很多文件的工程中就能体现出方便性了。

三：再进一步：再看一下，为没一个*.o文件都写一句gcc -c main.c是不是显得多余了，能不能把它干掉？而且 main.c 和print.c都需要print.h，为每一个都写上是不是多余了，能不能再改进？能，当然能了：makefile:objects = main.o print.ohelloworld : $(objects)gcc -o helloworld$(objects)$(objects) : print.h # 都依赖print.hmian.o : mian.c #干掉了gcc -c main.c 让Gun make自动推导了。print.o : print.cclean :rm helloworld $(objects)。