gcc makefile文件的编写

合集下载

c语言makefile编写实例

c语言makefile编写实例

c语言makefile编写实例Makefile是用来管理程序编译的工具,可以方便地管理程序的编译过程。

使用Makefile可以大大简化程序的编译过程,提高程序的可维护性。

Makefile的语法比较简单,主要由目标、依赖和命令三部分组成。

下面我们以一个简单的C程序为例,来介绍如何使用Makefile进行编译。

假设我们有一个名为hello.c的程序,代码如下:```c#include <stdio.h>int main(){printf("Hello, world!\n");return 0;}```我们需要使用gcc编译器将其编译成可执行文件。

下面是一个简单的Makefile:```makefilehello: hello.cgcc -o hello hello.c```这个Makefile很简单,它定义了一个名为hello的目标,该目标依赖于hello.c文件,并使用gcc命令将其编译成可执行文件。

如果我们在终端中输入make命令,Makefile会自动执行编译过程:```$ makegcc -o hello hello.c```Makefile还可以定义多个目标,每个目标可以有多个依赖和多个命令。

下面是一个稍微复杂一些的Makefile:```makefileCC=gccCFLAGS=-Wall -gall: hello goodbyehello: hello.o$(CC) $(CFLAGS) -o hello hello.ogoodbye: goodbye.o$(CC) $(CFLAGS) -o goodbye goodbye.ohello.o: hello.c$(CC) $(CFLAGS) -c hello.cgoodbye.o: goodbye.c$(CC) $(CFLAGS) -c goodbye.cclean:rm -f *.o hello goodbye```这个Makefile定义了两个目标:all和clean。

交叉编译makefile编写

交叉编译makefile编写

交叉编译makefile编写交叉编译Makefile编写在软件开发中,我们通常会遇到需要在不同平台上编译程序的情况。

当我们需要在一台主机上编译运行另一种架构的程序时,就需要进行交叉编译。

而Makefile作为一种构建工具,可以帮助我们自动化编译过程,提高开发效率。

本文将介绍如何编写适用于交叉编译的Makefile,以实现在不同平台上的程序构建。

一、了解交叉编译概念交叉编译是指在一台主机上编译生成另一种架构的可执行文件。

通常情况下,我们在本机上编写并编译程序,然后在本机上运行。

但是,当我们需要在不同的平台上运行程序时,由于不同平台的指令集、库文件等差异,我们就需要使用交叉编译来生成适用于目标平台的可执行文件。

二、Makefile的基本结构Makefile是一种用于描述程序构建过程的文件,它包含了一系列规则(rules),每个规则由一个或多个目标(target)和依赖项(dependencies)组成。

当某个目标的依赖项发生变化时,Make工具会根据规则自动更新目标文件。

一个基本的Makefile结构如下所示:```target: dependenciescommand```其中,target表示目标文件,dependencies表示目标文件的依赖项,command表示生成目标文件的命令。

三、交叉编译的Makefile编写在编写交叉编译的Makefile之前,我们需要了解目标平台的相关信息,如架构、编译器、库文件等。

以ARM架构为例,我们可以使用arm-linux-gnueabi-gcc作为交叉编译器。

我们需要定义一些变量,用于指定交叉编译工具链和相关参数:```CC = arm-linux-gnueabi-gccCFLAGS = -Wall -O2```其中,CC表示编译器,CFLAGS表示编译参数。

接下来,我们可以定义目标文件和依赖项:```TARGET = myprogramSRCS = main.c foo.c bar.cOBJS = $(SRCS:.c=.o)```其中,TARGET表示目标文件,SRCS表示源文件列表,OBJS表示目标文件列表。

makefile编写规则

makefile编写规则

makefile编写规则⼀、makefile 规则:⼀般开头都是 Tab ,不能空格, include 前⾯不能是 Tab; 1、如果没编译过,将所有的(.c)⽂件编译并且链接; 2、如果有其中的(.c)⽂件改变,编译并链接改变的⽂件; 3、如果(.h)⽂件被修改,编译引⽤相应的(.c)⽂件, 链接; 4、在随意修改时间的情况下,会导致编译过程中⽣成的(.o 中间⽂件)与可执⾏⽂件时间不⼀致,此时会编译相应的⽂件,并链接,最终编译成可执⾏⽂件;⼆、第⼀版 makefile: 例如有2个 .h ⽂件(utils.h, player.h, actor.h)和 3个 .c ⽂件( main.c, player.c, actor.c)需要编译链接:/*****main.c*********/#include "utils.h"#include "player.h"void main() {// do something}/*******player.c**********/#include "utils.h"#include "actor.h"bool create_player() {// do something}/****actor.c************/#include "utils.h"bool create_actor() {// do something}/********* makefile *****************/test : main.o actor.occ -o test main.o actor.omain.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.cclean:rm test ain.o player.o actor.o 优点:可毒性很强,思路清晰明了; 缺点:⿇烦,重复的依赖过多,当需要编译⼤量⽂件时容易出错;第⼆版:利⽤ makefile 的变量;/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较,唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.c .PHONY : clean // 伪⽬标,避免:如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ) // 前⾯的(-)表⽰,执⾏过程中不 care 出错;第三版:利⽤ GUN make 的⾃动推导规则 当 make 看到(.o )⽂件,他会⾃动把(.c)⽂件加上依赖关系,包括执⾏的语句(cc -c xx.c);/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较,唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : utils.h player.h actor.hpalyer.o: player.h actor.h utils.hactor.o: actor.h utils.h .PHONY : clean // 伪⽬标,避免:如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)第四版:对第三版的整理(有⼀些重复的 .h) 公共的⼀起依赖,单独的单独依赖/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较,唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉$(OBJ) : utils.h actor.omain.o player.o .PHONY : clean // 伪⽬标,避免:如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)优点:简洁缺点:不好理解以上的makefike⽂件的基本写法;或许你也发现了,如果有⼏百个源⽂件咋整呢,光是⽬录就要晕死,下⾯就是针对这种情况来说⼀下⼤型⼯程 makefile 的编写设计⼆、⼤型项⽬makefile编写: Makefile 同样也有像 c / c++ 类似的include功能; 例如我们有⼀堆 a.mk , b.mk以及 foo.make和⼀个变量 $(bar),其包含了 e.mk,f.mk, 那么 include foo.make *.mk $(bar) ------- 等价-------》 include foo.make a.mk b.mk e.mk f.mk。

c++的makefile实例

c++的makefile实例

1. 将上述代码保存到一个名为 "Makefile"(注意大小写)的文件中。 2. 将 "your_program" 替换为你的目标程序的名称。 3. 将 "main.cpp"、"file1.cpp" 和 "file2.cpp" 替换为你的源代码文件的名称(如果有更 多文件,可以继续添加)。 4. 运行命令 `make` 来编译和构建你的程序。
c++的makefile实例
- `%.o: %.cpp`:这个规则用于编译每个源代码文件。它将每个 .cpp 文件编译为对应的 .o 文件。
- `clean`:这个规则用于清理生成的目标文件和目标程序。
你可以根据你的实际需要修改和调整这个 Makefile,例如添加其他编译选项、链接库等 。运行命令 `make clean` 可以删除生成的目标文件和目标程序。
all: $(TARGET)
$(TARGET): $(OBJS) $(CC) $(CFLAGS) -o $@ $^
%.o: %.cpp $(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(OBJS) $(TARGET)

c++的makefile实例
在这个示例中,你需要做以下几个步骤:
c++的makefile实例
这个 Makefile 的规则解释如下:
- `CC`:定义了编译器的名称(在这里使用了 g++)。 - `CFLAGS`:定义了编译器的选项(在这里使用了 -std=c++11 和 -Wall)。 - `TARGET`:定义了目标程序的名称。 - `SRCS`:定义了源代码文件的名称。 - `OBJS`:定义了目标文件的名称(通过将源文件的扩展名 .cpp 替换为 .o 而得到)。 - `all`:这是一个默认目标,用于构建目标程序。它依赖于 $(TARGET)。 - `$(TARGET)`:这个规则用于构建目标程序。它依赖于 $(OBJS)。通过 $(CC) 命令将目 标文件链接在一起生成最终的可执行文件。

C++Makefile文件编写

C++Makefile文件编写

C++Makefile⽂件编写
对现有的⼀个C++动态库⽂件和调⽤程序,分别编写Makefile⽂件,从零开始,这⾥把⾃⼰弄明⽩的⼀些东西分享给⼤家。

1、必须明确Linux下,C++的编译器是g++,C语⾔的是gcc。

⽹上⼤多数⼜是以.c⽂件编写的makefile⽰例,所⽤的编译器是gcc,如果
C++写成了gcc,C语⾔中没有类,会显⽰class未知的定义错误。

2、当有⼀个或多个动态库时,应该为每个动态库都写⼀个Makefile⽂件,为调⽤动态库的程序写⼀个Makefile⽂件,⽽不是写在⼀起,这样才⽅便之后的修改维护。

3、Makefile的基本语句是确定的,当我们要使其易修改时,会预先定义⼀些变量,代表⽂件所在的路径,其实路径是可以组合的,我们要写的就是让编译器能找到需要的⽂件。

介绍我需要写makefile⽂件时的情况。

⼀个动态库⽂件,动态库⽂件中引⽤了外部的头⽂件。

Makefile⽂件执⾏编译的时候,先将.cpp⽂件转换成.o⽂件,在这个构成中依赖.cpp⽂件(源⽂件),以及.cpp中引⽤了的头⽂件。

⼀句句解释上⾯这个为动态库⽂件写的Makefile⽂件:
1' CC指定编译器是g++,代表C++编译器,后⾯出现的CC都表⽰g++;
2' INCLUDE指定头⽂件路径,⼀般的,程序⾃⼰写的头⽂件⽤相对路径,如果不是把动态库⽂件的头⽂件复制到⾃⼰写的⼯程⽂件中的话,就⽤绝对路径指向动态库⽂件的头⽂件;有多个头⽂件路径需要添加时,在路径前添加-I,不要有空格;
3' DLL_OBJ代表要⽣成的动态库⽂件
4' 5' 设定⽬录。

makefile编译流程

makefile编译流程

makefile编译流程Makefile是一种用于自动化编译的工具,它可以根据源代码文件的依赖关系自动编译出目标文件。

Makefile的编写需要遵循一定的规则和语法,下面将介绍Makefile的编译流程。

1. 编写Makefile文件Makefile文件是一个文本文件,其中包含了编译的规则和依赖关系。

在编写Makefile文件时,需要遵循一定的语法规则,如使用TAB键缩进、使用变量和函数等。

2. 执行make命令在Makefile文件所在的目录下执行make命令,make会自动读取Makefile文件,并根据其中的规则和依赖关系进行编译。

如果Makefile文件中没有指定目标,则默认编译第一个目标。

3. 分析依赖关系在执行make命令时,make会先分析Makefile文件中的依赖关系,确定哪些文件需要重新编译。

如果某个源文件被修改了,那么与之相关的目标文件也需要重新编译。

4. 编译源文件在确定需要重新编译的文件后,make会依次编译每个源文件,生成对应的目标文件。

编译过程中,make会根据Makefile文件中的规则和命令进行编译。

5. 链接目标文件在所有的源文件都编译完成后,make会将所有的目标文件链接起来,生成最终的可执行文件。

链接过程中,make会根据Makefile文件中的规则和命令进行链接。

6. 完成编译当所有的源文件都编译完成并链接成功后,make会输出编译成功的信息,并生成最终的可执行文件。

如果编译过程中出现错误,make会输出错误信息并停止编译。

总之,Makefile编译流程是一个自动化的过程,它可以大大提高编译的效率和准确性。

在编写Makefile文件时,需要注意语法规则和依赖关系,以确保编译过程的正确性。

makefile基本使用方法

makefile基本使用方法

makefile基本使用方法makefile是一种用来管理和自动化构建程序的工具。

它可以根据源代码文件的依赖关系和编译规则来自动构建目标文件和可执行文件。

makefile的基本使用方法如下:1. 创建makefile文件:在项目的根目录下创建一个名为makefile 的文件。

2. 定义变量:在makefile中,可以使用变量来存储一些常用的参数和路径,以便于后续的使用。

例如,可以定义一个名为CC的变量来指定编译器的名称,如:CC=gcc。

3. 编写规则:在makefile中,可以使用规则来指定如何编译源代码文件和生成目标文件。

一个规则由两部分组成:目标和依赖。

目标是要生成的文件,依赖是生成目标文件所需要的源代码文件。

例如,可以编写以下规则:```target: dependency1 dependency2command1command2```其中,target是目标文件,dependency1和dependency2是依赖的源代码文件,command1和command2是生成目标文件所需要执行的命令。

4. 编写默认规则:在makefile中,可以使用一个默认规则来指定如何生成最终的可执行文件。

默认规则的目标通常是可执行文件,依赖是所有的源代码文件。

例如,可以编写以下默认规则:```all: target1 target2```其中,target1和target2是生成的目标文件。

5. 编写clean规则:在makefile中,可以使用clean规则来清理生成的目标文件和可执行文件。

例如,可以编写以下clean规则: ```clean:rm -f target1 target2```其中,target1和target2是要清理的目标文件。

6. 运行make命令:在命令行中,使用make命令来执行makefile 文件。

make命令会自动根据规则和依赖关系来编译源代码文件和生成目标文件。

例如,可以运行以下命令:``````make命令会根据makefile文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。

MakeFile详解

MakeFile详解

引用其它的Makefile-实例



有这样几个Makefile:a.mk、b.mk、c.mk,还有 一个文件叫foo.make,以及一个变量$(bar),其 包含了e.mk和f.mk,那么,下面的语句: include foo.make *.mk $(bar) 等价于: include foo.make a.mk b.mk c.mk e.mk f.mk

在大多数时候,由于源文件太多,编译生成的中间目标文 件太多,而在链接时需要明显地指出中间目标文件名,这
对于编译很不方便,所以,通常要给中间目标文件打个包,
在Windows 下这种包叫“库文件”(Library File),也就 是 .lib 文件,在UNIX 下,是Archive File,也就是 .a 文件。
定义变量和引用变量
变量的定义和应用与Linux环境变量一样,变量名 要大写,变量一旦定义后,就可以通过将变量名 用圆括号括起来,并在前面加上“$”符号来进行 引用。 变量的主要作用: 1、保存文件名列表 2、保存可执行命令名,如编译器 3、保存编译器的参数 变量一般都在makefile的头部定义。按照惯例, 所有的makefile变量都应该是大写。
者,通常是你需要告诉编译器头文件的所在位置,只要所有的语法正
确,编译器就可以编译出中间目标文件。一般来说,每个源文件都应 该对应于一个中间目标文件(O 文件或是OBJ 文件)。
孙钦东
程序的编译和链接

链接时,主要是链接函数和全局变量。链接器并不管函数
所在的源文件,只管函数的中间目标文件(Object File)。



clean: -rm -f $(EXEC) *.elf *.gdb *.o

makefile gcc编译

makefile gcc编译

makefile gcc编译
Makefile 是一个用来组织代码编译的工具,而 GCC 是一个常用的 C 和 C++ 编译器。

在 Makefile 中使用 GCC 进行编译可以通过以下步骤完成:
1. 创建一个名为 "Makefile" 的文本文件,并确保它位于你的项目根目录下。

2. 在 Makefile 中定义你的编译规则。

例如,假设你有一个名为 "main.c" 的源文件需要编译成可执行文件 "app",你可以这样编写 Makefile:
make.
app: main.c.
gcc -o app main.c.
在这个例子中,我们定义了一个名为 "app" 的目标,它依赖于"main.c" 这个源文件。

当你运行 "make" 命令时,Make 工具会根
据这个规则来执行编译。

3. 打开终端,进入到包含 Makefile 的项目目录下。

4. 运行命令 "make"。

Make 工具会读取 Makefile 文件,并执行其中定义的编译规则。

在这个例子中,它会使用 GCC 编译器来编译 "main.c" 并生成可执行文件 "app"。

需要注意的是,Makefile 可以包含更复杂的规则和变量定义,以及支持多个源文件的编译。

你可以根据你的项目需求来进一步扩展和定制 Makefile 文件。

总之,通过合理编写 Makefile 并结合使用 GCC 编译器,你可以高效地组织和管理你的代码编译过程。

makefile中的gcc -c -o语法

makefile中的gcc -c -o语法

文章标题:深度探讨makefile中的gcc -c -o语法在makefile中,gcc -c -o是一个非常重要的语法结构,用于编译源文件并生成目标文件。

在本文中,我将对这个语法进行深入探讨,帮助你更好地理解它的用途和功能,并运用到实际的项目中。

1. gcc -c -o的基本概念在makefile中,gcc -c -o用于将源文件编译成目标文件。

其中,-c表示编译但不信息,-o用于指定编译后生成的目标文件名。

这个语法结构在实际的项目中非常常见,尤其是在大型的软件开发过程中。

2. 深入理解gcc -c -o的作用通过gcc -c -o,我们可以将源文件编译成目标文件,然后再将多个目标文件信息起来,生成可执行文件。

这样的分步编译方式可以提高编译的效率,尤其是在一个项目中包含大量源文件的情况下。

另外,通过指定-o参数,我们可以自定义目标文件的生成规则和命名规范,让项目结构更加清晰和灵活。

3. 实际应用案例举一个实际的例子,比如我们有一个项目包含多个源文件,分别是main.c、function1.c和function2.c。

我们可以使用gcc -c -o将这些源文件分别编译成目标文件main.o、function1.o和function2.o,然后通过gcc将这些目标文件信息起来,生成可执行文件。

这样的分步编译方式可以提高项目的维护性和灵活性。

4. 对于gcc -c -o的个人观点和理解个人认为,gcc -c -o是一个非常实用的编译选项,尤其是在大型的软件开发项目中。

通过这个选项,我们可以更加灵活地管理项目的结构,提高编译效率,同时也让代码更加清晰和易于维护。

在实际的项目中,我经常使用这个选项来进行分步编译,以便更好地管理和组织代码。

5. 总结通过本文的深入探讨,相信你对makefile中的gcc -c -o语法有了更深入的理解。

这个语法不仅在软件开发中非常常见,而且也非常实用。

通过灵活运用这个选项,我们可以更好地管理和组织项目,提高代码的可维护性和开发效率。

简单制作Makefile方法

简单制作Makefile方法

1.在当前目录下创建一个名为hello的子目录。hello这个目录用于存放hello.c这个程序及相关文件。新建一个源程序文件hello.c
#include <stdio.h>
int main(int argc, char** argv)
{
printf("Welcome to use autoconf and automake\n");
通过以上步骤,在源代码所在目录下自动生成了Makefile文件。
configure.in文件
autoconf提用来产生"configure"文件的工具。"configure"是一个Shell脚本,它可以自动设定一些编译参数使程序能够在不同平台上进行编译。autoconf读取configure.in文件然后产生,"configure"这个Shell脚本。
如何使用产生的Makefile文件
执行configure脚本文件所产生的Makefile文件有几个预定的选项可供使用。
l make all:产生设定的目标,即生成所有的可执行文件。使用make也可以达到此目的。
l make clean:删除之前编译时生成的可执行文件及目标文件(形如*.o的中间文件)。
configure.in文件的内容是一系列GNU m4的宏,这些宏经autoconf理后会变成检查系统特性的Shell脚本。configure.in文件中宏的顺序并没有特别的规定,但是每一个configure.in文件必须以宏AC_INIT开头,以宏AC_OUTPUT结束。一般可先用autoscan这个工具扫描原始文件以产生一个configure.scan文件,再对configure.scan作些修改,从而生成configure.in文件

Makefile及GCC编译选项培训

Makefile及GCC编译选项培训
据文件名后缀选择一个缺省值)。此选项影响后面的所有输入文件 ,一直到下一个 –x 选项。
language可取的值为:
c c-header cpp-output c++ c++-cpp-output objective-c objc-cpp-output assembler assembler-with-cpp ada f77 f77-cpp-input ratfor java
Makefile及GCC编译选项培训
Makefile中变量的使用:
objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o
edit : $(objects) cc -o edit $(objects)
Makefile及GCC编译选项培训
-ansi
支持所有ANSI标准的C程序。 这个开关不支持那些GNU C中与ANSI C 不兼容的特性,如关键词asm,inline和typeof,以及标明所用系统类型的预 定义宏,如unix和vax。它同时支持不受欢迎而且很少使用的ANSI三字母词 特性,不允许“$”作为标识符的一部分,不识别C++风格的“//”注释。
一般情况下GCC会采用特殊代码更高效地实现特定的内置函数。比如 调用alloca会变成若干直接调整堆栈的单一指令,而调用memcpy 会变成直 接插入的复制循环。这样产生的代码更小更快,而由于代码中没有了函数 调用,无法在这些调用中设置断点,也不能通过连接不同的库来改变这些 函数的功能。
-ansi 开关禁止函数alloca和ffs成为内置函数,因为它们没有ANSI标准 下的意义。
上下文中时,虽然没有用引号括起来,其数值被字符串化)。预处理器 认为字符串常量以新行为结束。

makefile编写规则 ifeq

makefile编写规则 ifeq

makefile编写规则 ifeq【实用版】目录1.Makefile 简介2.Makefile 编写规则3.ifeq 函数的作用4.ifeq 函数的语法5.ifeq 函数的实例6.结论正文1.Makefile 简介Makefile 是一种用于自动化构建和编译软件的脚本文件。

它通常包含一系列的规则,用于指定如何构建和编译源代码。

Makefile 的主要目的是为了简化和自动化构建过程,以便开发者能够更专注于编写代码。

2.Makefile 编写规则在 Makefile 中,编写规则通常遵循以下格式:```目标:依赖文件t命令```其中,目标表示要构建的文件,依赖文件表示构建目标所需的输入文件,命令表示用于构建目标的命令。

例如,要编译一个名为“main.c”的源文件,可以编写如下规则:```main.o: main.ctgcc -c main.c```3.ifeq 函数的作用ifeq 函数是 Makefile 中的一种条件函数,用于根据某个条件决定是否执行相应的命令。

它可以帮助开发者根据不同的环境或配置选择性地执行代码。

4.ifeq 函数的语法ifeq 函数的语法如下:```ifeq (条件)ttrue-casetfalse-caseelsetelse-caseendif```其中,条件是一个逻辑表达式,true-case 和 false-case 分别表示条件为真和假时执行的命令。

else-case 是可选的,用于表示条件不满足时执行的命令。

5.ifeq 函数的实例假设我们希望根据不同的操作系统选择不同的编译器选项,可以编写如下 Makefile 规则:```%.o: %.ctifeq ($(OS), Linux)ttgcc -o $@ $< -std=gnu99telsettgcc -o $@ $< -std=ansitendif```在这个例子中,我们使用 ifeq 函数根据当前操作系统($(OS))选择不同的编译器选项。

Makefile中用宏定义进行条件编译-CSDN博客

Makefile中用宏定义进行条件编译-CSDN博客

Makefile中用宏定义进行条件编译-CSDN博客在源代码里面如果这样是定义的:#ifdef MACRONAME//可选代码#endif那在makefile里面gcc -D MACRONAME=MACRODEF或者gcc -D MACRONAME这样就定义了预处理宏,编译的时候可选代码就会被编译进去了。

对于GCC编译器,有如下选项:-D macro=string,等价于在头文件中定义:#define macro string。

例如:-D TRUE=true,等价于:#define TRUE true-D macro,等价于在头文件中定义:#define macro 1,实际上也达到了定义:#define macro的目的。

例如:-D LINUX,等价于:#define LINUX 1(与#define LINUX作用类似)。

--define-macro macro=string与-D macro=string作用相同。

如:TEST.C 文件#include <stdio.h>#include <stdlib.h>main(){#ifdef p1 printf('Hello p1');#else printf('Hello p2');#endif }1.编译: gcc -o test test.c运行: ./test输出: Hello p22.编译: gcc -o test test.c -D p1运行: ./test输出: Hello p1还有另外一种使用方式:Makefile写法:$(SERVER_NAME):$(SERVER_OBJ) $(COM_OBJS) $(CC) -Wall -pthread -D KRC_SERVER_NAME=$(SERVER_NAME)_FLAG C代码中用法:#if KRC_SERVER_NAME == krc_search_FLAG#elif KRC_SERVER_NAME == krc_feedback_FLAG#else#endif注意:其中的两个参数为宏定义,不能使用常量定义,因为需要在预编译阶段就要确定其值!#define krc_search_FLAG 1#define krc_feedback_FLAG 2这种用法也能实现条件编译的作用,而且更好!。

makefile编写规则 ifeq

makefile编写规则 ifeq

makefile编写规则 ifeqifeq是Makefile中的一个条件语句,用于判断给定的两个参数是否相等,如果相等则执行后续的指令。

ifeq语句的基本语法如下:ifeq (参数1, 参数2)指令1else指令2endif其中,参数1和参数2可以是任意字符串或者变量。

一般来说,参数1可以是一个Makefile变量的值,参数2可以是一个常量或者字符串。

ifeq语句在Makefile中非常有用,它可以根据不同的条件执行相应的动作,例如选择不同的编译器、设置不同的编译选项等。

下面是一个具体的例子,展示了如何使用ifeq语句:```Makefileifeq ($(CC), gcc)CFLAGS += -std=c99elseCFLAGS += -std=c11endififeq ($(OS), Windows_NT)RM = del /f /qelseRM = rm -fendifall:$(CC) $(CFLAGS) -o program program.cclean:$(RM) program```在上面的例子中,我们使用ifeq语句判断变量$(CC)的值是否为"gcc",如果是则给变量CFLAGS添加编译选项"-std=c99",否则添加"-std=c11"。

这样就能根据不同的编译器选择不同的编译选项。

另外,我们还使用ifeq语句判断变量$(OS)的值是否为"Windows_NT",如果是则将删除文件的命令设置为"del /f /q",否则设置为"rm -f"。

这样就能在不同的操作系统上使用相应的删除命令。

最后,我们定义了两个目标,分别是"all"和"clean"。

"all"目标使用$(CC)编译$(CFLAGS)选项将program.c文件编译为可执行程序"program";"clean"目标使用$(RM)命令删除"program"文件。

使用makefile编译多个文件(.c,.cpp,.h等)

使用makefile编译多个文件(.c,.cpp,.h等)

使⽤makefile编译多个⽂件(.c,.cpp,.h等)有时候我们要⼀次运⾏多个⽂件,这时候我们可以使⽤Makefile◊make是什么? make是⼀个命令⼯具,是⼀个解释makefile中指令的命令⼯具。

它可以简化编译过程⾥⾯所下达的指令,当执⾏make 时,make 会在当前的⽬录下搜寻 Makefile (or makefile) 这个⽂本⽂件,执⾏对应的操作。

make 会⾃动的判别原始码是否经过变动了,⽽⾃动更新执⾏档。

◊为什么要使⽤make? 假设,现在⼀个项⽬⾥⾯包含了100个程序⽂件,如果要对这个项⽬进⾏编译,那么光是编译指令就有100条。

如果要重新进⾏编译,那么就⼜得像之前⼀样重新来⼀遍。

这样重复且繁琐的⼯作实在是让我们很不爽啊。

所以,⽤make来进⾏操作,间接调⽤gcc岂不是很⽅便?如果我们更动过某些原始码档案,则 make 也可以主动的判断哪⼀个原始码与相关的⽬标⽂件档案有更新过,并仅更新该档案。

这样可以减少重新编译所需要的时间,也会更加⽅便。

◊makefile⼜是⼲什么的? makefile其实就是⼀个⽂档,⾥⾯定义了⼀系列的规则指定哪些⽂件需要先编译,哪些⽂件需要后编译,哪些⽂件需要重新编译,它记录了原始码如何编译的详细信息! makefile⼀旦写好,只需要⼀个make命令,整个⼯程完全⾃动编译,极⼤的提⾼了软件开发的效率。

先看⼀下makefile的规则: ⽬标(target):⽬标⽂件1 ⽬标⽂件2 <Tab>gcc -o 欲建⽴的执⾏⽂件⽬标⽂件1 ⽬标⽂件2先举⼀个运⾏多个c语⾔⽂件。

⾸先下⾯是⼀个完整的 c语⾔⽂件,实现了统计⽤户输⼊的字符串中⼤⼩写字母的个数#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>void test(){char str[50]={0};scanf("%s",str);int m=0;int n=0;pid_t p=fork();if(p<0){printf("fork failed");}if(p == 0){for(int i=0;i<sizeof(str);i++){if( str[i]<='Z'&& str[i]>='A'){m++;}}printf("⼤写字母⼀共有");printf("%d",m);printf("个");}if(p>0){for(int i=0;i<sizeof(str);i++){if(str[i]>='a' && str[i]<='z'){n++;}}printf("⼩写字母⼀共有");printf("%d",n);printf("个");}}int main(){test();return 0;}此时我们可以把该⽂件拆成三份,⼀份是.h⽂件,⽤来放头⽂件等信息,另外两个是.c⽂件,⼀个⽤来放main⽅法,⼀个放声明的函数,如下三图则在终端进⾏⼀下操作成功运⾏多个⽂件下⾯介绍运⾏cpp⽂件,⼤致步骤相同。

单片机makefile编写

单片机makefile编写

单片机makefile编写编写一个针对单片机的Makefile通常涉及指定编译器、链接器、源文件、目标文件、依赖关系以及构建和清理过程。

以下是一个简单的Makefile示例,它假设你正在使用GCC编译器为单片机(如AVR)编译代码:make# 定义编译器和工具链CC=avr-gccOBJCOPY=avr-objcopySIZE=avr-size# 定义项目名称和CPU类型PROJECT=my_projectCPU=atmega328p# 定义源文件目录和源文件列表SRC_DIR=./srcSRC=$(wildcard $(SRC_DIR)/*.c)# 定义目标文件目录和目标文件列表OBJ_DIR=./objOBJ=$(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)# 定义编译选项CFLAGS=-Os -DF_CPU=16000000UL -mmcu=$(CPU) -I. -std=gnu99 -Wall -Wextra -Werror# 定义最终目标文件HEX_FILE=$(PROJECT).hexELF_FILE=$(PROJECT).elf# 默认目标,输入'make'时将执行此目标all: $(HEX_FILE)# 链接对象文件并生成elf文件$(ELF_FILE): $(OBJ)$(CC) $(CFLAGS) -o $@ $^# 将elf文件转换为hex文件$(HEX_FILE): $(ELF_FILE)$(OBJCOPY) -O ihex -R .eeprom $< $@# 编译源文件并生成对象文件$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR)$(CC) $(CFLAGS) -c $< -o $@# 创建目标文件目录(如果不存在)$(OBJ_DIR):mkdir -p $@# 显示项目大小信息size: $(HEX_FILE)$(SIZE) -A $(ELF_FILE)# 清理生成的文件clean:rm -f $(OBJ_DIR)/*.o $(HEX_FILE) $(ELF_FILE)此Makefile将完成以下工作:使用AVR GCC编译器编译在src目录下的所有C源文件。

GCC 64位程序的makefile条件编译

GCC 64位程序的makefile条件编译

GCC 64位程序的makefile条件编译32位版与64位版、debug版与release版(兼容MinGW、TDM-GCC)为了适应现在越来越流行的64位系统,经常需要将代码分别编译为32位版和64位版。

其次,除了需要生成debug版用于开发测试外,还需要生成release版用于发布。

本文介绍了如何利用makefile条件编译来生成这些版本,而且不仅兼容Linux下的GCC,还支持MinGW、TDM-GCC等Windows下的GCC编译器。

一、C程序代码为了测试条件编译的效果,以下面这个C语言程序为例(gcc64_make.c)——#include <stdio.h>#include <assert.h>// 获取程序位数(被编译为多少位的代码)int GetProgramBits(){return sizeof(int*) * 8;}int main(int argc, char* argv[]){printf("bits:\t%d\n", GetProgramBits());assert( argc>1 );return0;}main函数中,前两条语句的含义为——●第一条语句用于显示当前程序的位数。

如果编译为32位版,将会显示“bits: 32”;如果编译为64位版,将会显示“bits: 64”。

●第二条语句是一条断言,需要argc变量大于1。

如果编译为debug版,若运行时未加命令参数,该断言失败,于是输出错误信息并终止程序;如果编译为release版,所有断言被屏蔽,不会有错误信息。

二、GCC命令行参数复习一下GCC命令行参数,看看各个版本的区别——●32位版:加上-m32 参数,生成32位的代码。

●64位版:加上-m64 参数,生成64位的代码。

●debug版:加上-g 参数,生成调试信息。

●release版:加上-static 参数,进行静态链接,使程序不再依赖动态库。

C语言预处理、结构体和make的使用--make的使用和Makefile的编写(二)

C语言预处理、结构体和make的使用--make的使用和Makefile的编写(二)
四、隐含规则
在编写过一些Makefile文件后就会发现,目标文件、依赖文件、编译命令之间存在一定的规律。比如,目标文件一般依赖同名的.c源文件,而生成这种目 标文件的命令则是使用gcc编译该.c源文件。为了简化Makefile的编写,make命令在实现时内嵌了隐含规则。隐含规则是make或用户自己预定 义的一些规则。如果Makefile文件中没有显式的给出某个目标的依赖文件和编译命令,make会根据目标文件的扩展名使用隐含规则,自动建立关于这个 目标文件的依赖文件和编译所使用的命令。
.o:目标文件
这里.o目标文件是指使用编译器gcc的-c选项生成的中间文件,不是Makefile里介绍的目标文件。
在make处理Makefile文件时,Байду номын сангаас及C语言的隐含规则主要有两条:一条是,对于一个没有后缀的目标文件(如上面的program),如果 Makefile文件中没有明确指明对应的依赖文件和编译命令,并且当前目录下可以找到同名.c源文件,那么make就自动为该目标文件建立一条像上面那 样的规则。另一条是,对于一个以.o结尾的目标文件,如果该目标没有依赖文件和编译器命令并且可以在当前目录下找到同名.c源文件,make会为它建立一 个规则以生成.o目标文件。比如,对于规则:
endif
示例二:
foo =
ifdef foo
frobozz = yes
else
frobozz = no
endif
示例一中的结果是“forbozz = yes”,而示例二的结果是“frobozz = no”。其原因在于:示例一中,变量“foo”的定义是“foo = $(bar)”。虽然变量“bar”的值为空,但是“ifdef”判断的结果是真。当需要判断一个变量的值是否为空时,最好使用“ifeq”(或者 “ifneq”)而不是“ifdef”。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

常用的vim命令 命令 常用的
光标命令:(可视模式下) 光标命令:(可视模式下) :(可视模式下 k、j、h、l—上下左右光标移动命令。 上下左右光标移动命令。 、 、 、 上下左右光标移动命令 nG—调转命令,n为行数,该命令使光标立即跳到指定的行数。 调转命令, 为行数 该命令使光标立即跳到指定的行数。 为行数, 调转命令 Ctrl+G—光标所在位置的行数和列数。 光标所在位置的行数和列数。 光标所在位置的行数和列数 编辑命令: 可视模式下) 编辑命令: (可视模式下) i—从可视命令模式进入文本编辑模式。 从可视命令模式进入文本编辑模式。 从可视命令模式进入文本编辑模式 esc键—放回到可视命令模式。 放回到可视命令模式。 键 放回到可视命令模式 查找命令: 可视模式下) 查找命令: (可视模式下) /string 、? 、?String—从光标所在的行向前向后查找相应的字符 从光标所在的行向前向后查找相应的字符 串。 拷贝复制命令: 可视模式下) 拷贝复制命令: (可视模式下) yy—拷贝一行到剪切板 拷贝一行到剪切板 p—粘贴剪切板的内容 粘贴剪切板的内容 在冒号命令方式下: ,表示从当前光标处开始复制n行内容到 在冒号命令方式下:yn,表示从当前光标处开始复制 行内容到 剪切板。将光标移到相应的位置, 即可粘贴剪切板的内容。 剪切板。将光标移到相应的位置,按p即可粘贴剪切板的(可视模式下) 编辑命令(可视模式下)
dd—删除整行命令 删除整行命令 u—恢复前一次的删除动作 恢复前一次的删除动作
冒号命令方式命令 :q—退出命令 退出命令 :w—存档 存档 :wq—存档退出 存档退出 放弃任何改动, :q!--放弃任何改动,强行退出 ! 放弃任何改动
GUNMakeFile、Makefile和makefile 、 和
实例分析
#The makefile is for test. objects = main.o subr.o exec = prog all:$(objects) gcc –o $(exec) $(objects) main.o:test1.c gcc –c main.c subr.o:test2.c gcc –c subr.c clean: rm –r $(exec) $(objects) 注意: 注意:
蓝色的每行,必须从每行的起始处开始,不能有空格。 蓝色的每行,必须从每行的起始处开始,不能有空格。 红色标注的每行,起始处不是空格,是“Tab”键。 红色标注的每行,起始处不是空格, 键 注释均以’ 开始 注释均以’#’开始
简化makefile 简化
利用makefile的隐含规则简化 的隐含规则简化 利用 ######## objects = main.o subr.o exec = prog all:$(objects) gcc –o $(exec) $(objects) clean: rm –r $(exec) $(objects)
Vi编辑器和 编辑器和GCC 编辑器和 开发工具
vi(m)编辑器 编辑器
vi是Linux/UNIX世界里极为普遍的全屏幕 是 / 世界里极为普遍的全屏幕 文本编辑器,几乎任何一台Linux/UNIX机 文本编辑器,几乎任何一台 / 机 器都会提供这个软件。 器都会提供这个软件。这种编辑器的一大好 处是所有的命令按键都在手指范围内,手不 处是所有的命令按键都在手指范围内, 必离开主键盘就可输入所有命令。 必离开主键盘就可输入所有命令。 $vi filename 新建文档或开启旧文档。 新建文档或开启旧文档。 vi有3种状态,即可视命令模式、冒号命令模 种状态, 有 种状态 即可视命令模式、 式及文本编辑模式。 式及文本编辑模式。
Makefile
Makefile带来的好处就是--“自动化编 带来的好处就是--“ 带来的好处就是-- 一旦写好,就只需一个make命令就可 译”,一旦写好,就只需一个 命令就可 以实现整个工程完全自动化编译, 以实现整个工程完全自动化编译,极大的提 高了软件开发的效率。 高了软件开发的效率。 有效文件名: 有效文件名:
gcc 编译过程
预处理 这一步需要分析各种命令, 这一步需要分析各种命令,如:#define、 、 #include、#ifdef等。gcc将调用 将调用cpp程序来进 、 等 将调用 程序来进 行预处理。 行预处理。 编译 这一步将根据输入文件产生汇编语言, 这一步将根据输入文件产生汇编语言,由于通常 是立即调用汇编程序, 是立即调用汇编程序,所以其输出一般不保存在 文件中。 文件中。 汇编 这一步将汇编语言用作输入,产生具有.o扩展名 这一步将汇编语言用作输入,产生具有 扩展名 的目标文件。 的目标文件。 连接 在这一步,各目标文件.o被放在可执行文件的适 在这一步,各目标文件 被放在可执行文件的适 当位置上。 调用连接程序ld来完成最终的任 当位置上。gcc调用连接程序 来完成最终的任 调用连接程序 务。
gcc规则 规则
gcc通过后缀来区别输入文件的类别,gcc所 通过后缀来区别输入文件的类别, 通过后缀来区别输入文件的类别 所 遵循的部分约定规则如下: 遵循的部分约定规则如下:
.c为后缀的文件,C语言源代码文件; 为后缀的文件, 语言源代码文件 语言源代码文件; 为后缀的文件 .a为后缀的文件,是由目标文件构成的档案库文 为后缀的文件, 为后缀的文件 件; .cc或.cxx 为后缀的文件,是C++源代码文件; 为后缀的文件, 源代码文件; 或 源代码文件 .h为后缀的文件,是程序所包含的头文件; 为后缀的文件, 为后缀的文件 是程序所包含的头文件; .o为后缀的文件,是编译后的目标文件; 为后缀的文件, 为后缀的文件 是编译后的目标文件; .s为后缀的文件,是汇编语言源代码文件; 为后缀的文件, 为后缀的文件 是汇编语言源代码文件;
gcc编译器 编译器
Linux系统下的 系统下的Gcc(GNU C Compiler)是GNU 系统下的 ( ) 推出的功能强大、性能优越的多平台编译器, 推出的功能强大、性能优越的多平台编译器,是 GNU的代表作品之一。gcc是可以在多种硬体平 的代表作品之一。 的代表作品之一 是可以在多种硬体平 台上编译出可执行程序的超级编译器, 台上编译出可执行程序的超级编译器,其执行效 率与一般的编译器相比平均效率要高20%~30%。 率与一般的编译器相比平均效率要高 。 Gcc编译器能将 、C++语言源程序、汇编程序和 编译器能将C、 语言源程序、 编译器能将 语言源程序 目标程序编译、连接成可执行文件, 目标程序编译、连接成可执行文件,如果没有给 出可执行文件的名字, 将生成一个名为a.out 出可执行文件的名字,gcc将生成一个名为 将生成一个名为 的文件。在Linux系统中,可执行文件没有统一的 的文件。 系统中, 系统中 后缀, 后缀,系统从文件的属性来区分可执行文件和不 可执行文件。 可执行文件。
vi的编辑状态 的编辑状态
可视命令模式:一般当进入 时 可视命令模式:一般当进入vi时,会首先进 入可视命令方式,这是Vi的启动默认模式 的启动默认模式。 入可视命令方式,这是 的启动默认模式。 冒号命令方式:所有命令都要以“ 开始, 冒号命令方式:所有命令都要以“:”开始, 所输入的字符系统均作命令来处理, 所输入的字符系统均作命令来处理, 如输入 “:q”代表退出,“:w”表示存盘。 代表退出, 表示存盘。 代表退出 表示存盘 文本编辑模式:在可视命令模式下,输入” 文本编辑模式:在可视命令模式下,输入”i” 即可进入编辑模式,进行编写、 即可进入编辑模式,进行编写、修改代码等 操作。 操作。
gcc 参数说明
-c 只编译并生成目标文件。 只编译并生成目标文件。 -o FILE 生成指定的输出文件 生成指定的输出文件FILE,没有指定 ,没有指定FILE, , 默认输出文件为a.out。 默认输出文件为 。 -O 优化生成代码。 优化生成代码。 -w 不生成任何警告信息。 不生成任何警告信息。 -Wall 生成所有警告信息。 生成所有警告信息。 -g 生成调试信息。GNU 调试器可利用该信息。 生成调试信息。 调试器可利用该信息。 -lLIBRARY 连接时搜索指定的函数库 连接时搜索指定的函数库LIBRARY。 。
gdb
Linux 包含了一个叫 包含了一个叫gdb 的GNU 调试程序 调试程序. gdb 是一个用来调试 和C++ 程序的强力调 是一个用来调试C 试器. 试器 它使你能在程序运行时观察程序的内部 结构和内存的使用情况. 功能非常强大: 结构和内存的使用情况 Gdb 功能非常强大
可监视程序中变量的值。 可监视程序中变量的值。 可设置断点以使程序在指定的代码行上停止执行。 可设置断点以使程序在指定的代码行上停止执行。 支持单步执行等
简化makefile(2) 简化
利用内部变量进行简化 objects = main.o subr.o exec = prog all:$(objects) gcc –o $@ $^ clean: rm –r $(exec) $(objects)
$@ 扩展成当前规则的目的文件名, 扩展成当前规则的目的文件名, $< 扩展成依靠列表中的第 一个依靠文件 $^ 扩展成整个依靠的列表
gcc用法
gcc最基本的用法是∶ 最基本的用法是∶ 最基本的用法是 gcc [options] [filenames] 其中options就是编译器所需要的参数,filenames 就是编译器所需要的参数, 其中 就是编译器所需要的参数 给出相关的文件名称。 给出相关的文件名称。 举例: 举例: gcc –c main.c gcc –c subr.c gcc –I/usr/include –o prog main.o subr.o
gdb 的常用命令
list 显示源代码段。 显示源代码段。 run 运行程序。 运行程序。 break NUM 在指定的行上设置断点。 在指定的行上设置断点。 Watch express 参看变量或表达式的值。 参看变量或表达式的值。 continue 继续执行正在调试的程序。该命令用在程 继续执行正在调试的程序。 序由于处理信号或断点而导致停止运行时。 序由于处理信号或断点而导致停止运行时。 next 单步执行,但不进入函数。 单步执行,但不进入函数。 Step 单步执行,进入函数。 单步执行,进入函数。 info break 显示当前断点清单,包括到达断点处的 显示当前断点清单, 次数等。 次数等。 kill 终止正被调试的程序。 终止正被调试的程序。
相关文档
最新文档