使用Automake生成Makefile及动态库和静态库的创建

合集下载

[IT计算机]Automake、Autoconf生成Makefile

[IT计算机]Automake、Autoconf生成Makefile

使用Automake,Autoconf 生成Makefile使用Automake,Autoconf 生成Makefile在Unix 上写过程序的人尤其是用 C 来开发程序的人一般都遇到过Makefile,用make 来开发和编译程序的确很方便,可是要写出一个Makefile 就不那么简单了。

GNU Make 那份几百页的文件,让许多人害怕。

当然,现在关于make 的文档比较多,不过写一个Makefile 总是一件很烦人的事情,GNU Autoconf 及Automake 这两个软件就是帮助程序开发者轻松产生Makefile 文件的。

现在的GNU 软件如Apache, MySQL Minigui 等都是利用Autoconf,Automake 实现自动编译的。

用户只要使用“./configure”, “make”, “make install” 就可以把程序安裝到系统中。

简介Makefile 基本上就是『目标』(target), 『关联』(dependencies) 和『动作』三者所组成的一系列规则。

而make 就是根据Makefile 的规则决定如何编译(compile) 和连接(link) 程序或者其它动作。

当然,make 可做的不只是编译和连接程序,例如FreeBSD 的port collection 中,Makefile 还可以做到自动下载远程程序,解压缩(extract) ,打补丁(patch),设定,然后编译,安装到系统中。

Makefile 基本结构虽然很简单,但是妥善运用这些规则就可以变换出许多不同的花样。

却也因为这样,许多人刚开始学写Makefile 时会觉得没有规范可以遵循,每个人写出来的Makefile 都不大一样,不知道从哪里下手,而且常常会受到开发环境的限制,只要环境参数不同或者路径更改,可能Makefile 就得跟着修改。

虽然有GNU Makefile Conventions (GNU Makefile 惯例)制订出一些在进行GNU 程序设计时写Makefile 的一些标准和规范,但是其内容很长而且很复杂,并且经常作一些调整,为了减轻程序开发人员维护Makefile 的负担,就出现了Automake。

教你如何使用automake生成Makefile文件

教你如何使用automake生成Makefile文件

教你如何使用automake生成Makefile文件引言总所周知,Makefile主要用来组织源码的编译,其语法在此不再迭述。

经分析可发现,源码的组织结构通常有以下3种形式:①、flat:所有文件都处在同一目录所有源文件、头文件以及相关的库文件都处在当前的目录中,不存在任何子目录。

②、shallow:主要源代码处在顶层目录,其他各部分处在子目录主要源文件在当前目录中,而其它一些实现各部分功能的源文件位于各自不同的目录。

③、deep:所有源代码处在子目录,顶层目录存放配置信息所有源文件及自己写的头文件位于当前目录的一个子目录中,而当前目录里没有任何源文件。

使用automake对以上3种源码组织结构的编译过程在某些细节上存在一些差异,但是大概流程是一致的,如下图所示:图1生成Makefile的过程编译过程2.1flat根据引言中对flat源码结构的描述“所有源文件、头文件以及相关的库文件都处在当前的目录中,不存在任何子目录”可知其目录结构如下图所示:图2flat源码结构目录说明:add.c:实现加法运算int my_add(int a,int b){return(a+b);}sub.c:实现减法运算int my_sub(int a,int b){return(a-b);}mul.c:实现乘法运算int my_mul(int a,int b){return(a*b);}div.c:实现除法运算int my_div(int a,int b){return(a/b);}algo.h:头文件声明源码中实现的函数test.c:在主函数中调用以上源文件实现的函数,并展示运算结果编译步骤:①、执行autoscan在目录中执行autoscan命令,会生成文件configure.scan,再将其重命名为configure.in,最后还需要做如下修改。

#autoscan#mv configure.scan configure.in#vim configure.in修改前:图3configure.scan①、将AC_CONFIG_SRCDIR([sub.c])改为AC_CONFIG_SRCDIR([test.c])注:使用有主函数main()的源文件test.c取代sub.c②、将AC_CONFIG_HEADER([config.h])改为AM_CONFIG_HEADER([config.h])③、新增AM_INIT_AUTOMAKE(math, 1.0):其中math是希望生成的可执行程序的名字,1.0表示版本号④、将AC_OUTPUT改为AC_OUTPUT(Makefile):表示要创建的Makefile名修改后:图4configure.in②、配置Makefile.am在当前目录中新建Makefile.am文件,生成可执行文件math,因此其配置内容为:图5Makefile.am③、新建文件在当前目录下新建文件NEWS、README、ChangeLog、AUTHORS文件,内容为空;#touch NEWS#touch README#touch ChangeLog#touch AUTHORS④、生成configure#aclocal——该命令将以configure.in为输入文件,生成aclocal.m4#autoconf——该命令将以configure.in和aclocal.m4为输入文件,生成文件configure#autoheader⑤、生成Makefile.in#automake-a(该命令将以configure.in和Makefile.am为输入文件,生成文件Makefile.in)⑥、执行./configure配置安装程序,并生成Makefile⑦、编译源码经过以上步骤,已经生成了Makefile,此时只需执行make,便可以编译源码,并生成可执行程序了;⑧、运行结果完成以上所有操作之后,在当前目录下就生成了可执行程序math,其最终的运行结果如下图所示:图6flat结果2.2shallow根据引言中对shallow源码结构的描述“主要源文件在当前目录中,而其它一些实现各部分功能的源文件位于各自不同的目录”可知其目录结构如下图所示:图7shallow源码结构目录说明:add/add.c:实现加法运算int my_add(int a,int b){return(a+b);} sub/sub.c:实现减法运算int my_sub(int a,int b){return(a-b);} mul/mul.c:实现乘法运算int my_mul(int a,int b){return(a*b);} div/div.c:实现除法运算int my_div(int a,int b){return(a/b);} incl/algo.h:头文件声明源码中实现的函数test.c:在主函数中调用以上源文件实现的函数,并展示运算结果编译步骤:①、执行autoscan在目录中执行autoscan命令,会生成文件configure.scan,再将其重命名为configure.in,最后还需要做如下修改。

AutoMake制作makefile文件

AutoMake制作makefile文件

AutoMake制作makefile文件1、首先创建一个Mytest目录(命令:mkdir mytest )2、写一个01.cpp的文件。

(vi 01.cpp)3、用autoscan命令来帮助我们在目录下为源代码生成一个configure.in的模板文件。

4、此时我们发现并没有生成configure.in文件,所以我们将configure.scan改成.in文件(命令是mv configure.in configure.scan)5、这个时候我需要对configure.in文件进行修改需要的第一点:改后的结果是需要修改的第二点是:改后的结果是6、然后执行命令aclocal和autoconf,分别会产生aclocal.m4及configure两个文件7、创建一个Makefile.am文件(命令:vi Makefile.am)8、并对该文件进行编辑,内容如下:AUTOMAKE_OPTIONS=foreign9、运行autoheader10、运行automake --add-missing.automake会根据Makefile.am文件产生一些文件,包含最重要的Makefile.in。

11、执行configure生成Makefile12、使用Makefile编译代码(命令:make)13、运行可执行文件./01总结:大致的代码流程为:命令说明:1、autoscanautoscan是用来扫描源代码目录生成configure.scan文件的。

autoscan可以用目录名做为参数,但如果你不使用参数的话,那么autoscan将认为使用的是当前目录。

autoscan将扫描你所指定目录中的源文件,并创建configure.scan文件。

2、configure.scanconfigure.scan包含了系统配置的基本选项,里面都是一些宏定义。

我们需要将它改名为configure.in3、aclocalaclocal是一个perl 脚本程序。

Linux下Makefile中动态链接库和静态链接库的生成与调用

Linux下Makefile中动态链接库和静态链接库的生成与调用

Linux下Makefile中动态链接库和静态链接库的⽣成与调⽤Linux下Makefile中动态链接库和静态链接库的⽣成与调⽤ 背景:写这篇博客的原因是:最近在搞嵌⼊式,需要交叉编译opencv库⽂件,⾃⼰写Makefile,通过arm-linux-g++编译、链接、⽣成可执⾏⽂件,从⽽实现了移植的过程。

平台是Toradex的Apalis TK1,三千多元,买回来我就后悔了,全是英⽂资料,还各种Bug,迟迟⽆法上⼿。

早知如此,还不如直接买Nvidia的Jetson TK1呢。

书归正传,今天写⼀下Makefile⽂件中,动态链接库和静态链接库的⽣成与调⽤。

⼀、概念 动态链接库:是⼀种不可执⾏的⼆进制程序⽂件,它允许程序共享执⾏特殊任务所必需的代码和其他资源。

Windows平台上动态链接库的后缀名是”.dll”,Linux平台上的后缀名是“.so”。

Linux上动态库⼀般是libxxx.so;相对于静态函数库,动态函数库在编译的时候并没有被编译进⽬标代码中,你的程序执⾏到相关函数时才调⽤该函数库⾥的相应函数,因此动态函数库所产⽣的可执⾏⽂件⽐较⼩。

由于函数库没有被整合进你的程序,⽽是程序运⾏时动态的申请并调⽤,所以程序的运⾏环境中必须提供相应的库。

动态函数库的改变并不影响你的程序,所以动态函数库的升级⽐较⽅便。

静态链接库:这类库的名字⼀般是libxxx.a;利⽤静态函数库编译成的⽂件⽐较⼤,因为整个函数库的所有数据都会被整合进⽬标代码中,他的优点就显⽽易见了,即编译后的执⾏程序不需要外部的函数库⽀持,因为所有使⽤的函数都已经被编译进去了。

当然这也会成为他的缺点,因为如果静态函数库改变了,那么你的程序必须重新编译。

Makefile:利⽤IDE开发调试的⼈员可能对Makefile不⼤理解,其实Makefile就是完成了IDE中的编译、链接、⽣成等⼯作,并遵循shell脚本中变量定义与调⽤的规则。

⼆、编写Makefile实现编译与链接1、准备⽂件 我们写⼀个简单的⼯程吧,此⼯程包含3个⽂件,分别是main.cpp,func.cpp和func.h。

autoconf与automake的完整例程

autoconf与automake的完整例程

autoconf与automake的完整例程一、 automake 的用途automake 和 autoconf 可以自动生成 GNU 的 Makefile ,虽然我们也可以手工写 Makefile ,但是考虑到在多硬件平台上运行,编译环境差异,依赖关系,静态和动态库的生成,等一系列的问题,对于复杂的代码树,用 automake 工具就成了更好的选择。

在下面的例程中,将介绍树型源码包的 Makefile 生成,其中包括生成库文件和可执行文件。

二、完整例程1.建立目录树a) 生成目录树$ mkdir lib$ mkdir src$ mkdir include$ touch include/xy.h$ touch lib/xy1.cpp$ touch lib/xy2.cpp$ touch src/main.cppb) 编辑源代码文件i. include/xy.h 内容如下:void xytest1();void xytest2();ii. lib/xy1.cpp 内容如下:#include <stdio.h>void xytest1(){ printf(“xytest1/n”); }iii. lib/xy2.cpp 内容如下:#include <stdio.h>void xytest2(){ printf(“xytest2/n”); }iv. src/main.cpp 内容如下:#include <xy.h>main(){xytest1();xytest2();}2. autoconfa) 生成默认的 configure.in$ autoscan此时目录下生成 configure.scan$ mv configure.scan configure.inb) 编辑 configure.in (为了书写简单,去掉了所有注释)AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)AM_INIT_AUTOMAKE(xytest, 1.0) # 此处是软件名和版本号AC_PROG_CXX # 自动检测编译器AC_PROG_CCAC_PROG_LIBTOOL # 生成动态/ 静态库需要LIBTOOL AC_OUTPUT(Makefile lib/Makefile src/Makefile) # 此处是输出的文件c) 自动生成 configure$ aclocal 它是一个perl 脚本,根据configure.in 产生aclocal.m4$ libtoolize –force它会生成 libtool 所需要的工具,主要为生成库做准备$ autoconf 通过 aclocal.m4 产生 configure3. automakea) Makefile.am 项层写法,编辑 ./Makefile.am 如下AUTOMAKE_OPTIONS=foreignSUBDIRS = lib srcb) Makefile.am 编译库文件的写法,编辑 lib/Makefile.am 如下DEFAULT_INCLUDES=-I../includelib_LTLIBRARIES = libxy_la_SOURCES =xy1.cpp xy2.cppc) Makefile.am 编译开执行程序的写法,编辑src/Makefile.am 如下DEFAULT_INCLUDES=-I../includebin_PROGRAMS = mainmain_SOURCES = main.cppmain_LDADD= -L../lib/.libs/ -lxyd) 生成 Makefile.in$ automake –add-missing4.编译运行(以 arm 为示例)$ ./configure –host=arm-linux 此时机器上需要有arm-linux-gcc 系统的编译工具$ make$ make install5.总结a) 需要手动编译的只有 configure.in, Makefile.am, 和源代码三处i. Makefile.am 中的常用设置项AM_CXXFLAGS= 编译 C++ 程序时所带的 FLAGSAM_CFLAGS= 编译C 程序时所带的FLAGSDEFAULT_INCLUDES= 编译时加入的include 目录DEFS= 编译时定义的DEFIND 值b) 注意看执行过程中有无错误提示。

cmake configure生成makefile用法

cmake configure生成makefile用法

CMake是一个开源的、跨平台的自动化构建工具,它可以生成标准的makefile文件,使得用户可以通过make命令来编译源代码。

下面是一个简单的示例,演示如何使用CMake生成makefile文件。

1.创建一个CMakeLists.txt文件
在源代码的根目录下创建一个CMakeLists.txt文件,这个文件用于描述如何构建你的项目。

在CMakeLists.txt文件中,你需要指定要构建的目标、依赖项和构建规则。

下面是一个简单的CMakeLists.txt文件示例:
在这个示例中,我们指定了要构建一个名为my_program的可执行目标,并指定了该目标的源代码文件为main.cpp。

1.生成makefile文件
在源代码的根目录下打开终端,并进入CMakeLists.txt所在的目录。

然后运行以下命令:
这个命令会在build目录下生成makefile文件,并使用make命令编译源代码。

如果编译成功,你将在build目录下看到可执行文件。

1.自定义构建规则
在CMakeLists.txt文件中,你可以使用各种CMake命令来定义构建规则。

例如,你可以使用add_library 命令来添加静态库或动态库目标,使用add_custom_command命令来添加自定义构建规则等等。

下面是一个更复杂的CMakeLists.txt文件示例:
在这个示例中,我们添加了一个名为my_library的静态库目标,并添加了一个名为my_program的可执行目标。

我们还添加了一个自定义构建规则,该规则指定了my_program目标依赖于my_library 目标。

使用Automake生成Makefile及动态库和静态库的创建

使用Automake生成Makefile及动态库和静态库的创建

使用Automake生成Makefile及动态库和静态库的创建使用Automake 创建和使用静态库1. 目录结构如下:[c-sharp]view plaincopy1.example2.|——src 目录(存放源代码文件)3. |——hello.c4.|——lib 目录(存放用来生成库的文件)5. |——test.c 用来生成静态库libhello.a6.|——include 目录(存放程序中使用的头文件)7. |——hello.h2. 编写的各个目录下的源文件[c-sharp]view plaincopy1.hello.h 文件2.extern void print(char *);3.test.c 文件4.#include<stdio.h>5.void print(char *msg)6.{7.print(“%s/n”, msg);8.}9.hello.c 文件10.#include “hello.h”11.int main()12.{13.print(“Hello static library!”);//这里用到的是静态库中的函数14.return 0;15.}3. 编写lib/Make 文件[c-sharp]view plaincopy1.noinst_LIBRARIES=libhello.a2.libhello_a_SOURCES=test.c3.AUTOMAKE_OPTIONS=foreign第一行noinst 表示生成的是静态库,不需要make install ,直接制定它的位置和名字就可以使用。

第二行表示用来生成静态库的源文件。

如果要把静态库生成到其他地方,可以在=后面加上路径(建议用绝对路径,并将所要用到的静态库生成在同一个文件夹下,如lib)。

第三行AUTOMAKE_OPTIONS 是Automake 的选项。

Automake 主要是帮助开发 GNU 软件的人员来维护软件,所以在执行Automake 时,会检查目录下是否存在标准GNU 软件中应具备的文件,例如 'NEWS'、'AUTHOR'、 'ChangeLog' 等文件。

qmake 自动生成Makefile

qmake 自动生成Makefile

在linux下,很多时候需要用Makefile来管理自己编写的程序,下面介绍如何使用qmake ,就是用来生成Makefile文件,不需要手写Makefile。

1、首先创建.pro文件1.1 将.cpp文件加入.pro中,使用SOURCES += XX.cpp,如果是多个.cpp文件可以另起一行写两个例子如下:SOURCES +=xx.cppSOURCES +=xx.cpporSOURCES +=xx.cpp xx.cpp ……orSOURCES +=xx.cpp /xx.cpp1.2 将.h文件加入.pro中,使用HEADERS += xx.h具体列子就不写了如上1.3 使用TARGET关键字指示生成的目标文件名称,默认如果不写使用跟项目文件相同的名称TARGET = xxxxx这里需要说明,qmake会根据不同的平台生成不同的类型,windows会生成xxxxx.exe,linux会生成xxxxx1.4 the final step设置CONFIG变量指定报刊QT相关库,并且在最后生成的Makefile 文件中加入moc uic的行,如下:CONFIG += qt如果要携带debug信息,如下CONFIG += qt debug最后,xx.pro应该如下面这个样子CONFIG += qt debugSOURCES += xx.cpp /xx.cppHEADERS += xx.hTARGET = xxxxx2、在command line中输入qmake -o Makefile xx.pro便会生成用于编译的Makefile文件,如下:qmake -o Makefile xx.proVisual Stutio用户可以用如下命令生成.dsw或者.vcproj文件qmake -tp vc xx .pro3、根据平台选择要编译的文件使用如下命令win32{SOURCES += xx.cpp}orunix{SOURCES += xx.cpp}4、如果文件不存在停止qmake,如下!exists(xx.cpp){error("No xx.cpp file found") }。

使用AutoMake轻松生成Makefile

使用AutoMake轻松生成Makefile

使用AutoMake轻松生成Makefile
冯庆端;裴海龙
【期刊名称】《电脑开发与应用》
【年(卷),期】2009(22)1
【摘要】一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目
录中,在linux里面makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作。

makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工程完全自动编译,极大地提高了软件开发的效率。

【总页数】2页(P72,76)
【作者】冯庆端;裴海龙
【作者单位】华南理工大学自动化学院;华南理工大学自动化学院
【正文语种】中文
【中图分类】TP3
【相关文献】
1.ARM应用程序中Makefile文件的自动生成 [J], 于维;张振东
2.与错题相约,让生成更轻松r——建立"错题集"的优点、方法和有效使用 [J], 麦
莲清
3.转换思路,使用Excel轻松实现成绩分析--论Excel中IF函数的巧妙使用 [J],
马宏伟
4.使用TestMX测试远程电子邮件服务器的连接性——使用一个简单命令轻松检
查连接性 [J],
5.Microsoft FoxPro2.5使用技术讲座——第四讲使用FoxPro 2.5的报表生成器生成报表 [J], 傅淑堂
因版权原因,仅展示原文概要,查看原文内容请购买。

自动生成Makefile详解

自动生成Makefile详解

autoconf 和automake生成Makefile文件本文介绍了在linux 系统中,通过Gnu autoconf 和automake 生成Makefile 的方法。

主要探讨了生成Makefile 的来龙去脉及其机理,接着详细介绍了配置Configure.in 的方法及其规则。

引子无论是在Linux还是在Unix环境中,make都是一个非常重要的编译命令。

不管是自己进行项目开发还是安装应用软件,我们都经常要用到make或make install。

利用make工具,我们可以将大型的开发项目分解成为多个更易于管理的模块,对于一个包括几百个源文件的应用程序,使用make和makefile工具就可以轻而易举的理顺各个源文件之间纷繁复杂的相互关系。

但是如果通过查阅make的帮助文档来手工编写Makefile,对任何程序员都是一场挑战。

幸而有GNU 提供的Autoconf及Automake这两套工具使得编写makefile不再是一个难题。

本文将介绍如何利用GNU Autoconf 及Automake 这两套工具来协助我们自动产生Makefile文件,并且让开发出来的软件可以像大多数源码包那样,只需"./configure", "make","make install" 就可以把程序安装到系统中。

模拟需求假设源文件按如下目录存放,如图1所示,运用autoconf和automake生成makefile文件。

图1文件目录结构假设src是我们源文件目录,include目录存放其他库的头文件,lib目录存放用到的库文件,然后开始按模块存放,每个模块都有一个对应的目录,模块下再分子模块,如apple、orange。

每个子目录下又分core,include,shell三个目录,其中core和shell目录存放.c文件,include的存放.h文件,其他类似。

自动生成 Makefile 的全过程详解!

自动生成 Makefile 的全过程详解!

自动生成Makefile的全过程详解!automake/autoconf入门automake/autoconf 入门作为Linux 下的程序开发人员,大家一定都遇到过Makefile ,用make 命令来编译自己写的程序确实是很方便。

一般情况下,大家都是手工写一个简单Makefile ,如果要想写出一个符合自由软件惯例的Makefile 就不那么容易了。

在本文中,将给大家介绍如何使用autoconf 和automake 两个工具来帮助我们自动地生成符合自由软件惯例的Makefile ,这样就可以象常 见的GNU 程序一样,只要使用“./configure” ,“make” ,“make instal” 就可以把程序安装到Linux 系统中去了。

这将特别适合想做开放源代码软件的程序开发人员,又或如果你只是自己写些小的Toy 程序,那么这 个文章对你也会有很大的帮助。

一、Makefile 介绍Makefile 是用于自动编译和链接的,一个工程有很多文件组成,每一个文件的改变都会导致工程的重新链接,但是不是所有的文件都需要重新编译,Makefile 中纪录有文件的信息,在make 时会决定在链接的时候需要重新编译哪些文件。

Makefile 的宗旨就是:让编译器知道要编译一个文件需要依赖其他的哪些文件。

当那些依赖文件有了改变,编译器会自动的发现最终的生成文件已经过时,而重新编译相应的模块。

Makefile 的基本结构不是很复杂,但当一个程序开发人员开始写Makefile 时,经常会怀疑自己写的是否符合惯例,而且自己写的 Makefile 经常和自己的开发环境相关联,当系统环境变量或路径发生了变化后,Makefile 可能还要跟着修改。

这样就造成了手工书写 Makefile 的诸多问题,automake 恰好能很好地帮助我们解决这些问题。

使用automake ,程序开发人员只需要写一些 简单的含有预定义宏的文件,由autoconf 根据一个宏文件生成configure ,由automake 根据另一个宏文件生成Makefile.in , 再使用configure 依据Makefile.in 来生成一个符合惯例的Makefile 。

cmake文件编写规则中,用于生成静态链接库和动态库

cmake文件编写规则中,用于生成静态链接库和动态库

cmake文件编写规则中,用于生成静态链接库和动态库CMake是一个开源的跨平台构建工具,它使用简洁的语法来描述软件构建过程。

在CMake文件编写规则中,我们可以使用一些指令来生成静态链接库和动态库。

本文将以生动、全面、有指导意义的方式介绍如何编写CMake文件以生成静态链接库和动态库。

一、生成静态链接库静态链接库是在编译时将库的代码直接嵌入到可执行文件中的库文件。

下面是生成静态链接库的CMake代码示例:```设置库名称set(LIB_NAME my_static_library)设置源文件列表set(SRC_FILESfile1.cppfile2.cpp)生成静态链接库add_library(${LIB_NAME} STATIC ${SRC_FILES})```上述代码中,首先需要设置库的名称(LIB_NAME),然后指定源文件的列表(SRC_FILES)。

最后,使用add_library命令来生成静态链接库。

二、生成动态库动态库是在运行时加载的库文件,它与可执行文件分开存储。

下面是生成动态库的CMake代码示例:```设置库名称set(LIB_NAME my_dynamic_library)设置源文件列表set(SRC_FILESfile1.cppfile2.cpp)生成动态库add_library(${LIB_NAME} SHARED ${SRC_FILES})```同样,我们需要设置库的名称(LIB_NAME)和源文件的列表(SRC_FILES)。

使用add_library命令,指定库类型为SHARED,就可以生成动态库了。

三、区分不同平台的库生成CMake可以根据不同平台来生成对应的库文件。

下面是一个区分不同平台的CMake代码示例:```设置库名称set(LIB_NAME my_library)设置源文件列表set(SRC_FILESfile1.cppfile2.cpp)判断平台类型if(WIN32)# 生成Windows平台的库add_library(${LIB_NAME} STATIC ${SRC_FILES})elseif(UNIX)# 生成UNIX平台(Linux、Mac等)的库add_library(${LIB_NAME} SHARED ${SRC_FILES})endif()```在上述代码中,我们使用if语句来判断当前的平台类型。

QT开发——动态库静态库的生成与调用(Qmake和Cmake方式)

QT开发——动态库静态库的生成与调用(Qmake和Cmake方式)

QT开发——动态库静态库的⽣成与调⽤(Qmake和Cmake⽅式)1.理解动态库与静态库区别链接:https:///wonengguwozai/article/details/93195827静态库和动态库最本质的区别就是:该库是否被编译进⽬标(程序)内部。

1.1 静态(函数)库⼀般扩展名为(.a或.lib),这类的函数库通常扩展名为libxxx.a或xxx.lib 。

这类库在编译的时候会直接整合到⽬标程序中,所以利⽤静态函数库编译成的⽂件会⽐较⼤,这类函数库最⼤的优点就是编译成功的可执⾏⽂件可以独⽴运⾏,⽽不再需要向外部要求读取函数库的内容;但是从升级难易度来看明显没有优势,如果函数库更新,需要重新编译。

1.2 动态函数库动态函数库的扩展名⼀般为(.so或.dll),这类函数库通常名为libxxx.so或xxx.dll 。

与静态函数库被整个捕捉到程序中不同,动态函数库在编译的时候,在程序⾥只有⼀个“指向”的位置⽽已,也就是说当可执⾏⽂件需要使⽤到函数库的机制时,程序才会去读取函数库来使⽤;也就是说可执⾏⽂件⽆法单独运⾏。

这样从产品功能升级⾓度⽅便升级,只要替换对应动态库即可,不必重新编译整个可执⾏⽂件。

1.3总结从产品化的⾓度,发布的算法库或功能库尽量使动态库,这样⽅便更新和升级,不必重新编译整个可执⾏⽂件,只需新版本动态库替换掉旧动态库即可。

从函数库集成的⾓度,若要将发布的所有⼦库(不⽌⼀个)集成为⼀个动态库向外提供接⼝,那么就需要将所有⼦库编译为静态库,这样所有⼦库就可以全部编译进⽬标动态库中,由最终的⼀个集成库向外提供功能。

2.qmake⽅式⽣成和调⽤动态/静态库链接:https:///lywzgzl/article/details/428059912.1 ⽣成库QT -= guiTARGET = laser_libTEMPLATE = libCONFIG += staticlib #加这句是⽣成静态库,不加则是动态库DEFINES += LASER_LIB_LIBRARYDEFINES += QT_DEPRECATED_WARNINGSLIBS += /usr/lib/x86_64-linux-gnu/libboost_thread.so\/usr/lib/x86_64-linux-gnu/libboost_system.soSOURCES += \laser_lib.cppHEADERS += \laser_lib.h \laser_lib_global.hinclude(LMS1xx/LMS1xx.pri)DESTDIR = $$PWD/../Libunix {target.path = /usr/libINSTALLS += target}2.2 调⽤库QT -= guiCONFIG += c++11 consoleCONFIG -= app_bundleDEFINES += QT_DEPRECATED_WARNINGS#增加系统库的依赖LIBS +=/usr/lib/x86_64-linux-gnu/libboost_thread.so\/usr/lib/x86_64-linux-gnu/libboost_system.so#增加⾃定义库的依赖LIBS += -L$$PWD/../Lib -llaser_lib #$$PWD获取当前pro⽂件的⽬录INCLUDEPATH += ../laser_libSOURCES += main.cppDESTDIR = $$PWD/../Lib3.cmake⽅式⽣成和调⽤动态库3.1创建共享库项⽬Cmake新建⼀个Qt Creator项⽬,在CMakeLists.txt中添加如下代码#-------------------------------------- 搜索软件包 --------------------------------------find_package(Qt5Widgets REQUIRED)find_package(Qt5Network REQUIRED)set(CMAKE_AUTOMOC ON)#-------------------------------------- 包含头⽂件 --------------------------------------include_directories(${Qt5Widgets_INCLUDE_DIRS})include_directories(${Qt5Network_INCLUDE_DIRS})include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)#-------------------------------------- -添加项⽬- --------------------------------------FILE(GLOB_RECURSE HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.h*)FILE(GLOB_RECURSE SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.c*)add_library(${PROJECT_NAME} SHARED${HEADER_FILES}${SOURCE_FILES}) #STATIC or SHARED 对应静态库或者动态库target_link_libraries(${PROJECT_NAME}${Qt5Widgets_LIBRARIES}${Qt5Network_LIBRARIES})#-------------------------------------- -设置输出- --------------------------------------set(OUTPUT_LIB_DIR ${PROJECT_BINARY_DIR}/libCACHE PATH "Output directory for libraries")file(MAKE_DIRECTORY ${OUTPUT_LIB_DIR})file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/${PROJECT_NAME})set(LIBRARY_OUTPUT_PATH ${OUTPUT_LIB_DIR})#-------------------------------------- -安装项⽬- --------------------------------------install(TARGETS ${PROJECT_NAME}EXPORT ${PROJECT_NAME}LIBRARY DESTINATION ${LIBRARY_OUTPUT_PATH})按需编辑plugintest.h和plugintest.cpp,这个就是该共享库项⽬的plugintest类了,我加⼊了⼀个int sum(int input1, int input2);公共函数,内容为:int Plugintest::sum(int input1, int input2){std::cout<<"Hello World!"<<std::endl;int sum = input1+input2;return sum;}保存并编译项⽬吧,没问题的话会在plugintest-build/lib⽬录⾥⽣成libplugintest.so。

一步一步学CMake之生成动态库和静态库

一步一步学CMake之生成动态库和静态库

⼀步⼀步学CMake之⽣成动态库和静态库⽬录1. 准备源⽂件包含:1.CMakeLists.txt2.Message.cpp3.Message.hpp4.hello-world.cpp详见:2. 创建⽬标库⽂件这次我们要将 Message.cpp 和 Message.hpp 这两个⽂件编译成⼀个静态库⽂件,⽽不是可执⾏⽂件,更改CMakeLists.txt⽂件,创建⼀个新的⽬标⽂件:1.add_library(message2. STATIC3. Message.hpp4. Message.cpp5.)该命令会⽣成构建⼯具指令,⽤于将指定的源⽂件编译为库⽂件,第⼀个参数 message 是将要⽣成的库⽂件的名字,该库名可以在整个CMakeLists.txt中使⽤,⽽实际⽣成的库⽂件名字则会包含前缀(lib)和后缀,后缀取决于第⼆个参数是STATIC还是SHARED,还取决于操作系统。

命令详解见:3. 链接库⽂件告诉CMake必须把库⽂件链接到可执⾏⽂件⾥target_link_libraries(hello-world message)该命令是将库⽂件链接到可执⾏⽂件⾥,这条命令能保证hello-world可执⾏⽂件能够正确地⼀来于 message库⽂件(库⽂件总是在可执⾏⽂件之前构建的)。

4. 静态库和共享库下⾯命令中第⼆个参数STATIC是指⽣成静态库,如果要⽣成共享库,可以直接将其替换为SHARED关键词。

1.add_library(message STATIC Message.hpp Message.cpp)2.add_library(message SHARED Message.hpp Message.cpp)这⾥顺便简单提⼀下静态(函数)库和共享(函数)库的区别:静态(函数)库是在程序编译时链接的,其实就是⼀个或多个⽬标⽂件的集合,⽤“.a”作为⽂件的后缀。

共享(函数)库中的函数是在当⼀个可执⾏程序在启动的时候被加载,共享(函数)库⼜叫动态(函数)库,⽂件后缀是.so ,windows上叫动态加载函数库,⽂件后缀是.dll1.# set minimum cmake versioncmake_minimum_required(VERSION 3.5 FATAL_ERROR)3.4.# project name and language5.project(recipe-03 LANGUAGES CXX)6.7.# generate an object library from sources8.add_library(message-objs9.OBJECT10.Message.hpp11.Message.cpp12.)13.14.# this is only needed for older compilers15.# but doesn't hurt either to have it16.set_target_properties(message-objs17.PROPERTIES18.POSITION_INDEPENDENT_CODE 119.)20.21.add_library(message-shared22.SHARED23.$<TARGET_OBJECTS:message-objs>24.)25.set_target_properties(message-shared26.PROPERTIES27.OUTPUT_NAME "message"28.)29.30.add_library(message-static31.STATIC32.$<TARGET_OBJECTS:message-objs>33.)34.set_target_properties(message-static35.PROPERTIESOUTPUT_NAME "message"37.)38.39.add_executable(hello-world hello-world.cpp)40.41.target_link_libraries(hello-world message-static)。

autotool工具的使用方式(简单的例子)

autotool工具的使用方式(简单的例子)

autotool⼯具的使⽤⽅式(简单的例⼦)autotool⼯具的使⽤⽅式(简单的例⼦)autotool是⼀种帮助⽤户⾃动管理项⽬⽣成Makefile的⼯具。

有时候⼿动写Makefile可以满⾜⾃⼰的要求,但是随着项⽬增加,代码结构也变得⾮常复杂,这样⼀来⼿动维护每个Makefile就变得⾮常困难。

autotool的存在帮助降低了项⽬维护的难度。

autotool不是某⼀个⼯具,⽽是⼀系列⼯具的混合体。

autoscanaclocalautoconfautoheaderautomake这⼀系列最终⽬的就是⽣成makefile,进⽽帮助项⽬编译。

Makefile.am的作⽤Makefile.am⽂件是整个autotool⾃动⽣成makefile的灵魂,这其中不需要规定多么复杂的逻辑⽣成关系。

这⾥对这个内容进⾏着重介绍。

终极⽬标automake通过Makefile.am来⽣成Makefile.in。

bin_PROGRAMS(*program-list*) a program or programs build in the local directory that should be compiled, linked and installed.noinst_PROGRAMS(*program-list*) a program or programs build in the local directory that should be compiled, linked but not installed.bin_SCRIPTS(*script-list*) a script or scripts build in the local directory that should be installed.man_MANS(*page-list*)man pages that should be installed.lib_LTLIBRARIES(*lib-list*) a library or libraries that should be built using libtool.命名⽅案automake使⽤统⼀的命名规则,此举可以使⼯具明确需要构建的内容。

cmakeqmakemakefile动态和静态库教程

cmakeqmakemakefile动态和静态库教程

cmakeqmakemakefile动态和静态库教程makefileMakefile经典教程(掌握这些⾜够)规则:makefile的基本规则就是:1. target 设定编译的target和各种的依赖⽂件已经如何从⽂件⽣成target的命令target : prerequisites ...commandtarget: 可以是object file,也可以是可执⾏⽂件,也可以是标签labelprerequisites: ⽣成target需要的⽂件或者其它的target; make 命令会检查这些依赖和上⼀次make相⽐是否有了改动,来决定这个target是否要重新更新。

command : 任何的shell命令,command⼀定要⽤Tab键开头。

对于command,GNU的make定义了⼀些隐含的规则,因此有的时候也可以不需要提供command,只提供target和依赖,GNU Make会⾃动调⽤隐含的规则(command):GNU的make很强⼤,它可以⾃动推导⽂件以及⽂件依赖关系后⾯的命令,于是我们就没必要去在每⼀个[.o]⽂件后都写上类似的命令,因为,我们的make会⾃动识别,并⾃⼰推导命令。

⽐如:a.o : a.c不需要提供command,make会⾃动使⽤gcc来⽣成以上就是最核⼼的makefile的规则。

2. 常⽤的语法(1) \ 反斜杠:换⾏符合a.c \b.c(2) 变量定义objects = a.o b.o c.o在使⽤的时候: $(objects)来调⽤这个变量(3) .PHONY : label.PHONYb表⽰后⾯的是⼀个伪⽬标,、(4) 注释 : #(5) make 命令会在当前⽬录下⾃动找: GNUmakefile, makefile, Makefile⽂件进⾏编译,如果要指定可以使⽤ “ make -f xxx”或者 make --file xxx(6) include : include可以把其他的makefile包括到当前的makefile中。

makefile文件的生成

makefile文件的生成

用Autoconf及Automake来帮我们产生Makefile档了1.用autoscan产生一个configure.in的雏型,执行autoscan後会产生一个configure.scan的档案,我们可以用它做configure.in档的蓝本。

% autoscan% ls% configure.scan hello.c2.编辑configure.scan档,如下所示,并且把它的档名改成configure.in# Process this file with autoconf to produce a configure script.AC_INIT(hello.c )AM_INIT_AUTOMAKE(hello, 1.0)# Checks for programs.AC_PROG_CC# Checks for libraries.# Checks for header files.# Checks for typedefs, structures, and compiler characteristics.# Checks for library functions.AC_OUTPUT(Makefile)3.执行aclocal和autoconf,分别会产生aclocal.m4及configure两个档案% aclocal% autoconf% lsaclocal.m4 configure configure.in hello.c4.编辑Makefile.am档,内容如下AUTOMAKE_OPTIONS=foreignbin_PROGRAMS=hellohello_SOURCES=hello.c5.执行automake --add-missing,Automake会根据Makefile.am档产生一些档案,包含最重要的Makefile.in%automake –add-missingautomake:configure.in:installing`./install-sh'automake:configure.in:installing`./mkinstalldirs'automake:configure.in:installing`./missing'6.最後执行./configure,% ./configurecreating cache ./config.cachechecking for a BSD compatible install... /usr/bin/install -cchecking whether build environment is sane... yeschecking whether make sets ${MAKE}... yeschecking for working aclocal... foundchecking for working autoconf... foundchecking for working automake... foundchecking for working autoheader... foundchecking for working makeinfo... foundchecking for gcc... gccchecking whether the C compiler (gcc) works... yeschecking whether the C compiler (gcc) is a cross-compiler...no checking whether we are using GNU C... yeschecking whether gcc accepts -g... yesupdating cache ./config.cachecreating ./config.statuscreating Makefile现在你的目录下已经产生了一个Makefile档,下个``make''指令就可以开始编译hello.c成执行档,执行./hello和GNU打声招呼吧!% makegcc -DPACKAGE=\"hello\" -DVERSION=\"1.0\" -I. -I. -g -O2 -c hello.cgcc -g -O2 -o hello hello.o% ./helloHello!GNU!你还可以试试``make clean'',''make install'',''make dist''看看会有什麽结果。

cmake生成makefile流程

cmake生成makefile流程

文章标题:深入剖析CMake生成Makefile的流程与原理1. CMake介绍CMake是一个跨评台的自动化构建工具,可用于管理软件构建过程中的编译、信息、测试和安装等任务。

它采用了一种称为“CMakeLists.txt”的文本配置文件来描述项目的构建过程,然后根据这些描述生成不同评台下的构建脚本,如Makefile。

2. CMake生成Makefile的流程(1)项目目录结构:需要在项目目录下创建一个CMakeLists.txt文件,描述项目的组织结构和构建过程。

(2)配置CMake:运行cmake命令,指定项目的路径和生成的构建系统,如Unix的Makefile、Windows的Visual Studio项目等。

(3)生成Makefile:CMake解析CMakeLists.txt文件,生成相应的Makefile文件。

(4)编译项目:运行生成的Makefile文件,执行编译、信息等操作。

3. CMake生成Makefile的原理(1) CMakeLists.txt文件:该文件描述了项目的结构、依赖关系、编译选项等信息,CMake根据这些信息生成Makefile。

(2) CMake内部算法:CMake利用内部的算法来解析CMakeLists.txt文件,生成对应评台的构建脚本。

4. 个人观点和理解CMake的优势在于其跨评台性和灵活性,能够简化项目的构建过程,提高开发效率。

而CMake生成Makefile的过程则是其核心功能之一,可以帮助开发人员快速、高效地进行项目构建和管理。

总结与回顾本文深入剖析了CMake生成Makefile的流程与原理,介绍了CMake的基本概念和使用方法。

通过本文的阐述,读者可以更全面地了解CMake在软件构建中的作用和重要性,以及其生成Makefile的内部工作机制,希望能对读者有所帮助。

通过本文的了解,你是否对CMake生成Makefile的流程有了更深入的认识呢?让我们一起来探索和学习吧!CMake作为一个跨评台的自动化构建工具,其生成Makefile的流程和原理是非常重要的,了解这些内容有助于开发人员更好地使用和理解CMake,提高项目构建的效率和质量。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

使用Automake生成Makefile及动态库和静态库的创建使用Automake 创建和使用静态库1. 目录结构如下:[c-sharp]view plaincopy1.example2.|——src 目录(存放源代码文件)3. |——hello.c4.|——lib 目录(存放用来生成库的文件)5. |——test.c 用来生成静态库libhello.a6.|——include 目录(存放程序中使用的头文件)7. |——hello.h2. 编写的各个目录下的源文件[c-sharp]view plaincopy1.hello.h 文件2.extern void print(char *);3.test.c 文件4.#include<stdio.h>5.void print(char *msg)6.{7.print(“%s/n”, msg);8.}9.hello.c 文件10.#include “hello.h”11.int main()12.{13.print(“Hello static library!”);//这里用到的是静态库中的函数14.return 0;15.}3. 编写lib/Makefile.am 文件[c-sharp]view plaincopy1.noinst_LIBRARIES=libhello.a2.libhello_a_SOURCES=test.c3.AUTOMAKE_OPTIONS=foreign第一行noinst 表示生成的是静态库,不需要make install ,直接制定它的位置和名字就可以使用。

第二行表示用来生成静态库的源文件。

如果要把静态库生成到其他地方,可以在=后面加上路径(建议用绝对路径,并将所要用到的静态库生成在同一个文件夹下,如lib)。

第三行AUTOMAKE_OPTIONS 是Automake 的选项。

Automake 主要是帮助开发 GNU 软件的人员来维护软件,所以在执行Automake 时,会检查目录下是否存在标准GNU 软件中应具备的文件,例如 'NEWS'、'AUTHOR'、 'ChangeLog' 等文件。

设置为foreign 时,Automake会改用一般软件的标准来检查。

如果不加这句的话,需要在autoconf之前,先执行touch NEWSREADME AUTHORS ChangeLog 来生成'NEWS'、'AUTHOR'、 'ChangeLog' 等文件4. 编写src/Makefile.am 文件[c-sharp]view plaincopy1.AUTOMAKE_OPTIONS=foreign2.INCLUDES= -I../include3.bin_PROGRAMS=hello4.hello_SOURCES=hello.c5.hello_LDADD=../lib/libhello.a第二行指定头文件的位置,-I 是idirafter 的缩写。

../include 指定头文件的位置,..是上一级目录,也就是这里的example 目录。

第三行指定生成可执行文件名hello,在这里可执行文件生成在src 下,建议将可执行文件生成到一个特定的文件夹下,让它和源代码分开,如/root/test 目录下。

写法为:[c-sharp]view plaincopy1.bin_PROGRAMS=/root/test/hello,后面的第四、五行也相对应地变为:2._root_test_hello_SOURCES=hello.c3._root_test_hello_LDADD=../lib/libhello.a第四行指定生成可执行文件hello 的源代码文件,如果hello.c 在其他目录下,需要加上完整的路径。

第五行指定需要使用静态库的位置。

5. 生成静态库文件lib/libhello.a。

执行autoscan 生成configure.scan 文件,将它重命名为configure.in 并修改其内容。

[c-sharp]view plaincopy1.#configure.in2.# Process this file with autoconf to produce a configure script.3.AC_PREREQ(2.59)4.AC_INIT(libhello.a,1.1,[])5.AM_INIT_AUTOMAKE6.# Checks for programs.7.AC_PROG_CC8.# Checks for libraries.9.AC_PROG_RANLIB//需要加入的内容,因为使用了静态库10.# Checks for header files.11.# Checks for typedefs, structures, and compiler characteristics.12.# Checks for library functions.13.AC_OUTPUT([Makefile])14.AC_INIT(FILE)该宏用来检查源代码所在路径,autoscan 会自动产生,一般无须修改它。

AM_INIT_AUTOMAKE(PACKAGE,VERSION)这个是使用 Automake 所必备的宏,PACKAGE 是所要产生软件的名称,VERSION 是版本编号。

也可以把包和版本号等信息放在AC_INIT(FILE) 宏里。

AC_PROG_CC检查系统可用的C 编译器,若源代码是用C 写的就需要这个宏。

AC_OUTPUT(FILE)设置 configure 所要产生的文件,若是Makefile ,configure 便会把它检查出来的结果填充到Makefile.in 文件后产生合适的 Makefile。

后面的FILE 是一个Makefile 的输出列表,你可以选着将要输出的Makefile 的位置和个数。

建议只在src 中输出Makefile。

在lib 目录下依次执行 aclocal 、autoconf、automake--add-missing、./configure、make,此时在该目录下就可以看到生成的静态库文件libhello.a6. 在src 目录下,执行autoscan 生成configure.scan 文件,将它重命名为configure.in 并修改其内容。

[c-sharp]view plaincopy1.#configure.in2.# Process this file with autoconf to produce a configure script.3.AC_PREREQ(2.59)4.AC_INIT(hello,1.1,[])5.AM_INIT_AUTOMAKE6.AC_CONFIG_SRCDIR([hello.c])7.# Checks for programs.8.AC_PROG_CC9.# Checks for libraries.10.# Checks for header files.11.# Checks for typedefs, structures, and compiler characteristics.12.# Checks for library functions.13.AC_OUTPUT([Makefile])7. 在src 目录下依次执行 aclocal 、autoconf、automake--add-missing、./configure、make,生成可执行文件hello8. 执行make install 进行安装,最后输入hello 来运行程序,查看效果:Hello static library!执行成功!使用gcc 创建和使用静态库1. 编写mylib.h 文件[c-sharp]view plaincopy1.#ifndef _mylib_h_2.#define _mylib_h_3.void welcome();4.void outstring(const char * str);5.#endif2. 编写mylib.c 文件,用来生成静态库。

[c-sharp]view plaincopy1.#include <stdio.h>2.void welcome()3.{4.p rintf(“welcome to libmylib/n”);5.}6.void outstring(const char * str)7.{8.if(str!=NULL)9.printf(“%s”,str);10.}3. 编译源文件,产生目标代码gcc –o mylib.o –c mylib.c4. 将上面产生的目标文件加入到静态库中,并把静态库拷贝到系统默认的路径[c-sharp]view plaincopy1.ar rcs libmylib.a mylib.o2.cp libmylib.a /usr/lib/5. 编写测试程序来使用刚才创建的静态库 libmylib.a[c-sharp]view plaincopy1.#include “mylib.h”2.#include <stdio.h>3.Int main()4.{5.printf(“create and use library:/n”);6.welcome();7.outstring(“It’s a successful/n”);8.}6. 编译使用库函数的程序[c-sharp]view plaincopy1.gcc –o test test.c -lmylib运行./test 查看结果。

使用Automake 创建和使用动态库动态库与静态库的差别在于:动态库是在程序执行的时候加载到内存,供调用函数使用。

1. 目录结构如下:[c-sharp]view plaincopy1.example2.|——src 目录(存放源代码文件)3.|——hello.c4.|——lib 目录(存放用来生成库的文件)5.|——test.c 用来生成动态库6.|——include 目录(存放程序中使用的头文件)7.|——hello.h2. 编写各个目录下的源文件如下:[c-sharp]view plaincopy1.hello.h 文件2.extern void print(char *);3.test.c 文件4.#include<stdio.h>5.void print(char *msg)6.{7.print(“%s/n”, msg);8.}9.hello.c 文件10.#include “hello.h”11.int main()12.{13.print(“Hello static library!”);//这里用到的是动态库中的函数14.return 0;15.}3. 在lib 目录下编译需要生成动态库的文件,生成动态库,并安装到系统的标准库中,供程序调用。

相关文档
最新文档