C代码生成调用静态库方法
CodeBlocks静态库的创建和使用
过程第一步：启动code::blocks后，选择“Creat a new project”，如下图图标，后，弹出“New from template”对话框，如下图,拖动右侧的滚动条，选择其中的”Static library”, 在点击右上角的”Go”按钮，后弹出“Static library”对话框，如下图点击“Next”按钮，后进入下一步，输入工程名称和保存路径，如名称为“mylib”，保存路径为“F:\Ctest\”，其中四个文本框，只需填前两个，下面两个会自动生成。
如下图，点击”Next”按钮，进入下一步，配置相关的编译器，调试和发布版本的信息，选择默认即可，如下图点击“Finish”按钮，进入主界面，将作出的管理窗口“Workspace”下的目录展开，如下图，右击仅有的main.c文件，弹出一个浮动的菜单，如下图选择其中的“Rename file...”弹出“Rename file”对话框，如下图，将文本框中的名字改为“mylib.c”,点击”OK”按钮，左侧的管理窗口中的“main.c”文件名字变为“mylib.c”,如下图双击“mylib.c”文件名，进入文件编辑状态，从中添加你所有想要包含的函数，若还有其他很多源文件和头文件，可选择“File”下拉菜单的“new”菜单的“Empty file”，如下图我们这里创建一个“mylib.h”的头文件，当点击了“Empty file”后，弹出一个消息框，问是否将文件添加入工程，如下图点击“是”，之后生成一个“Save file”对话框，如下图将文件名改为“mylib.h”，后点击保存，在生成的对话框点击”OK”, 可以进行编辑文件了，几乎和普通工程没区别，全局变量、头文件等都存在，只是去掉main函数，确定要创建静态链接库的函数为最外层函数入口。
我们做一个两个正整数中加大者的函数1、头文件的声明如下图2、在源文件“mylib.c”中编辑代码第二步、编译、调试、直至成功3.切换到工程目录“F:\Ctest\mylib\bin\Debug”下，可以看到生成的“libmylib.a”,这个就是生成的静态库，名字中前五个字母“libmy”和我们的工程名一致，其后的“lib.a”是系统指定的静态库的固定格式，此时生成的所有文件中对我们有用的有两个：一个是“libmylib.a”的静态库文件，另个一是在目录“F:\Ctest\mylib”下的“mylib.h”头文件，在F盘下建立文件夹“mylib”,在“mylib”中创建两个文件夹“lib”和”include”,把文件“lib.a”拷贝到“F:\mylib\lib”目录下，把文件“mylib.h”拷贝到“F:\mylib\include”目录下。
使用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/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' 等文件。
静态库的调用方法
静态库的调用方法静态库是一种在编译时将代码和函数打包成一个文件的库文件，它包含了可被程序调用的函数、数据和其他资源。
与之对应的是动态库，动态库在程序运行时才被加载，而静态库在编译时就被链接到可执行文件中。
静态库的调用方法主要分为以下几个步骤：1. 创建静态库：首先需要创建一个静态库，静态库通常是通过编译源代码并将其打包成一个.a文件的方式创建的。
在一些开发环境中，可以使用特定的命令来创建静态库，比如使用gcc或g++编译源码并使用ar命令将多个对象文件打包成静态库。
2. 导入静态库：在使用这个静态库的项目中，需要将这个静态库导入到项目中。
通常有两种方式来导入静态库。
一种是将静态库复制到项目的目录中，然后在项目文件中设置相关的路径以便编译器可以找到这个静态库。
另一种方式是在项目文件中设置相关的路径，使得编译器能够找到这个静态库的存放位置。
3. 引入头文件：在使用静态库的项目中，需要引入静态库的头文件，以便在项目中使用静态库中定义的函数和数据结构。
头文件通常可以通过#include语句来引入，具体的语句形式为#include "header.h"，其中header.h是静态库中包含的头文件。
4. 编写代码：在项目中可以直接调用静态库中定义的函数和使用静态库中定义的数据结构。
具体的调用方式和使用方法可以参考静态库的文档或者示例代码。
在编写代码的过程中，可能需要包括静态库的头文件，调用静态库中的函数，以及使用静态库中的数据结构。
5. 编译链接：在编译项目时，需要设置编译选项和链接选项，以便编译器可以找到和链接静态库。
其中编译选项可以通过编译器的命令行参数或IDE的设置来指定。
链接选项通常包括静态库的路径和静态库的文件名。
6. 编译运行：在完成编译和链接后，可以运行生成的可执行文件来测试静态库的调用效果。
执行文件会调用静态库中的函数和使用静态库中的数据结构，从而实现特定的功能。
总结来说，静态库的调用方法主要包括创建静态库、导入静态库、引入头文件、编写代码、编译链接和编译运行这几个步骤。
c语言生成库文件过程
c语言生成库文件过程C语言是一种高级编程语言，被广泛用于系统级编程和嵌入式系统开发。
为了提高代码的复用性和模块化程度，C语言提供了生成库文件的机制。
本文将详细介绍C语言生成库文件的过程，以及相关的概念和步骤。
一、库文件的概念库文件是一种二进制文件，包含一组函数、变量或者数据结构的实现。
它将一些常用的代码封装成一个独立的单元，供其他程序调用和使用。
库文件可以被静态链接到程序中，也可以被动态链接到程序中。
1. 静态库（Static Library）：静态库是将库文件的内容完全复制到程序中，程序在编译时需要将所有被引用的库文件的代码复制到最终生成的可执行文件中。
具体来说，静态库以归档（Archive）的形式存在，包含了一组目标文件（Object File）的集合。
静态库的文件名通常以“.a”（在GNU 编译器中）或“.lib”（在Windows中）结尾。
2. 动态库（Dynamic Library）：动态库是在程序运行时被动态加载到内存中的库文件，程序在编译时只需要引用库函数的签名，无需复制库文件中的代码。
不同的程序可以共享同一个动态库的实例，有效减小可执行文件的体积。
动态库的文件名通常以“.so”（在Unix/Linux中）或“.dll”（在Windows中）结尾。
在使用库文件时，程序需要链接器（Linker）的支持，将库文件的代码和程序的代码进行整合，生成最终的可执行文件。
二、生成静态库的过程下面将介绍生成静态库的过程，以GNU编译器为例。
1. 编写源代码首先，需要编写一组实现某些功能的源代码文件。
这些源代码文件可以包含函数的定义、变量的声明和实现，以及相关的头文件。
2. 编译为目标文件使用编译器将源代码文件编译为目标文件（Object File）。
目标文件是二进制文件，包含了源代码文件的机器代码表示和一些符号表信息。
使用gcc 命令可以进行编译，例如：gcc -c file1.c file2.c这将生成`file1.o`和`file2.o`两个目标文件。
gcc常用参数(静动态链接 优化 调试)
一、编译过程概览gcc编译器对程序的编译过程有四个阶段：预处理(preprocessing)、编译(com- pilation proper)、汇编(assembly)和链接(linking)。
预处理：对源文件(source file)进行预处理，进行宏定义的替换等。
编译：将进行完预处理的源文件编译成汇编文件(assembly file)。
将C源代码编译成汇编语言。
汇编：将汇编文件汇编成目标文件(object file)。
链接：将一个或多个目标文件链接成一个可执行的二进制文件(execute file)。
链接的目标文件中有且只有一个main函数，作为可执行文件的开始。
-E在预处理阶段之后停止，不进行编译。
输出是预处理之后的源码，默认发送到标准输出(standard output)。
输入文件格式为.c等，默认输出为标准输出。
-S在编译阶段之后停止，不进行汇编。
输出为每一个指定的未编译的输入文件的汇编代码文件。
输入文件格式为.c、.i等，输出文件格式为.s。
-c编译或者汇编源文件，不进行链接。
输出为每一个源文件的目标文件。
输入文件格式为.c、.i、.s，输出文件格式为.o。
-o filename-o指定输出文件的文件名，如果没有指定-o，则默认输出的可执行文件名是a.out，默认输出的source.suffix的汇编文件名为source.s、目标文件名位source.o。
默认的预处理后的源文件输出到标准输出。
main.cgcc –E main.c –o main.itali main.igcc –S main.i –o main.stail main.sps：gcc –S main.c –o main.s也是可以的。
gcc –c main.s –o main.ogcc main.o –o test./testps：gcc –c main.i(main.c) –o main.ogcc main.c(main.i main.s) –o test都是可以的二、预处理预处理阶段可以用到的一些选项。
cmake ranlib的使用
`ranlib`是一个传统的Unix工具，用于为静态库生成索引。
这个索引可以加快库的查找速度，特别是在大型的静态库中。
然而，`cmake`并不直接支持`ranlib`。
在CMake中，如果你想要为静态库生成索引，可以使用`install(TARGETS)`和`EXPORTS`命令的组合，或者使用`ctest`的`--build-and-test`选项。
如果你仍然想要使用`ranlib`，你可以在CMake的`buildsystem`之外直接使用它。
以下是在Unix-like系统中使用`ranlib`的基本步骤：1. 首先，你需要编译你的项目，生成静态库。
这可以通过在CMake 中设置`CMAKE_SKIP_RPATH`选项并使用`install(TARGETS)`命令来完成。
例如：```cmakeset(CMAKE_SKIP_RPATH ON)install(TARGETS my_targetRUNTIME DESTINATION binLIBRARY DESTINATION libARCHIVE DESTINATION lib/static)```这将生成一个静态库文件，比如`libmy_target.a`。
2. 然后，你可以在CMake的构建目录之外，直接使用`ranlib`来为这个静态库生成索引。
例如：```bashranlib libmy_target.a```这将生成一个名为`libmy_target.a.o`的文件，这就是包含了索引的静态库。
3. 最后，你可以将这个索引文件一起安装，以便其他人在使用你的库时可以更快地找到它。
例如：```cmakeinstall(FILES libmy_target.a.o DESTINATION lib/static)```这将把`libmy_target.a.o`文件安装到指定的位置。
请注意，这些步骤可能因你的具体需求和环境而有所不同。
如果你在尝试这些步骤时遇到任何问题，你可能需要查阅CMake或`ranlib`的文档以获取更详细的信息。
linux下用gcc生成静态库和动态库
linux下用gcc生成静态库和动态库我们通常把一些公用函数制作成函数库，供其它程序使用。
函数库分为静态库和动态库两种。
静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。
动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。
本文主要通过举例来说明在Linux中如何创建静态库和动态库，以及使用它们。
在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o 文件。
第1步：编辑得到举例的程序--hello.h、hello.c和main.c；hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出"Hello XXX!"。
hello.h(见程序1)为该函数库的头文件。
main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。
#ifndef HELLO_H#define HELLO_Hvoid hello(const char *name);#endif //HELLO_H程序1: hello.h#include <stdio.h>void hello(const char *name){printf("Hello %s!\n", name);}程序2: hello.c#include "hello.h"int main(){hello("everyone");return 0;}程序3: main.c第2步：将hello.c编译成.o文件；无论静态库，还是动态库，都是由.o文件创建的。
因此，我们必须将源程序hello.c通过gcc先编译成.o文件。
在系统提示符下键入以下命令得到hello.o文件。
# gcc -c hello.c#我们运行ls命令看看是否生存了hello.o文件。
头文件和库文件-静态库和动态库
头⽂件和库⽂件-静态库和动态库⼀、头⽂件和库⽂件头⽂件提供声明，库⽂件提供定义/实现。
C代码的编译过程: 预处理(需要头⽂件) -> 编译 -> 汇编 -> 链接(需要库⽂件); 执⾏时可能还有动态链接过程。
编译的时候，只要有头⽂件中的声明就⾜够了。
在链接的时候，把已经编译好的.obj和现有的.lib⽂件进⾏链接，这时就可以最终⽣成可执⾏⽂件了。
其实头⽂件与其实现⽂件或相应lib⽂件都没有直接的联系。
头⽂件是告诉编译器函数是如何去调⽤如何返回的，所有实现都是分别编译，最后在链接阶段链在⼀起。
头⽂件包含声明, 库⽂件包含实现或者与DLL库的连接所以,如果在代码⾥要⽤到这些函数那么就要包含头⽂件,编译的时候才能知道这些函数的原形;在进⾏代码连接的时候就需要库⽂件了,这时连接器就把函数的实现代码(静态库)连接到你的程序或者将你的函数调⽤连接到相应的DLL的对应函数(动态库)lib是静态库, 编译的时候代码直接插⼊到你的程序 ,DLL是动态库,编译的时候,只是产⽣⼀些调⽤DLL内代码的导⼊表,真正运⾏的时候是调⽤的DLL内的代码。
总结起来就是，库⽂件通过头⽂件向外导出接⼝。
⽤户通过头⽂件找到库⽂件中函数实现的代码从⽽把这段代码链接到⽤户程序中去。
.a代表传统的静态函数库(也称作归档⽂件：archive).so代表共享函数库⼆、创建静态库⽂件：1.创建源⽂件willku1.c和willku2.c2.编译源⽂件⽣成.o⽂件（将要包含在库⽂件中的⽬标⽂件）gcc -c willku1.c willku2.c =>willku1.o willku2.o3.创建头⽂件ishead.h内容：void willku1(char *);void willku2(int);4.创建应⽤程序app.c（将调⽤willku2.c⽂件）#include "ishead.h"5.编译、测试应⽤程序app.cgcc -c app.cgcc -o app app.o willku2.o./app6.创建并使⽤库⽂件（.a）,使⽤ar创建归档⽂件并将⽬标⽂件加进去。
利用CMake生成动态或静态链接库工程
利⽤CMake⽣成动态或静态链接库⼯程install解释：TARGETS版本的install命令install(TARGETS targets... [EXPORT <export-name>][[ARCHIVE|LIBRARY|RUNTIME|FRAMEWORK|BUNDLE|PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE][DESTINATION <dir>][PERMISSIONS permissions...][CONFIGURATIONS [Debug|Release|...]][COMPONENT <component>][OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]] [...]) TARGETS格式的install命令规定了安装⼯程中的⽬标（targets）的规则。
有5中可以被安装的⽬标⽂件：ARCHIVE，LIBRARY，RUNTIME，FRAMEWORK，和BUNDLE。
除了被标记为MACOSX_BUNDLE属性的可执⾏⽂件被当做OS X上的BUNDLE⽬标外，其他的可执⾏⽂件都被当做RUNTIME⽬标。
静态链接的库⽂件总是被当做ARCHIVE⽬标。
模块库总是被当做LIBRARY ⽬标。
对于动态库不是DLL格式的平台来说，动态库会被当做LIBRARY⽬标来对待，被标记为FRAMEWORK的动态库是例外，它们被当做OS X上的FRAMEWORK⽬标。
对于DLL平台⽽⾔，动态库的DLL部分被当做⼀个RUNTIME⽬标⽽对应的导出库被当做是⼀个ARCHIVE⽬标。
所有基于Windows的系统，包括Cygwin，都是DLL平台。
ARCHIVE，LIBRARY，RUNTIME和FRAMEWORK参数改变了后续属性会加诸之上的⽬标的类型。
如果只给出了⼀种类型，那么只有那种类型的⽬标会被安装（这样通常只会安装⼀个DLL或者⼀个导出库。
gcc生成静态库和动态库
gcc生成静态库和动态库一、库文件简介简单地说，库（Library）就是一组已经写好了的函数和变量、经过编译代码，是为了能够提高开发效率和运行效率而设计的。
库分为静态库（Static Library）和共享库（Shared library）两类。
静态库文件的扩展名是.a，共享库文件的扩展名是.so（在CYGWIN环境下，分别叫做.o和.dll）。
共享库现在常常被叫做动态库，是由于很多人借用了MS Windows的DLL（Dynamic Linked Library）这个词。
（1）静态库静态是指每个用到该库的应用程序都拥有一份自己的库拷贝；应用程序运行的时候，即使将库删除也没有问题，因为应用程序自己已经有了自己的拷贝。
（2）共享库一个共享库有可能被多个所有应用程序共享。
因此，对每个应用程序来说，即使不再使用某个共享库，也不应将其删除。
此外，应用程序需要正确的环境变量设置（LD_LIBRARY_PATH），从而找到共享库所在的位置，否则，应用程序运行时会报告找不到这个库。
二、关于使用库的问题如果库是已经编译好的，那么如何在开发、运行应用程序时使用呢？头文件和库文件所在的路径，必须通过适当的方式通知给编译器、链接器和相关的应用程序。
对于静态库来说，主要涉及开发工具，如gcc。
例如，用gcc编译、链接时，需要通过适当的路径找到头文件和静态库文件；实现的方法有两种：gcc的命令行参数（-I, -L）shell的环境变量（C_INCLUDE_PATH, LIBRARY_PATH对于共享库来说，程序在运行时，如果用到了动态库，也需要找到对应的动态库文件；实现的方法：shell的环境变量（LD_LIBRARY_PATH）1） gcc命令行参数（-I, -L）默认情况下，gcc会自动搜索下面的路径：对头文件：/usr/local/include//usr/include/对库文件：/usr/local/lib//usr/lib/但是由于系统管理员对系统安装路径有不同的配置，或者对于如64位系统等情况，上述路径对于一台具体的计算机来说可能不同。
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是一个跨平台的自动化构建工具，它可以让我们更方便地管理C/C++代码的编译和构建过程。
在使用CMake进行静态库的编译时，我们需要按照以下步骤进行操作：1. 准备工作在使用CMake进行编译前，我们需要先准备好需要编译的代码文件，包括源文件和相关的头文件等。
同时，我们还需要确定编译的平台和目标系统，以便进行后续的配置。
2. 创建CMakeLists.txt文件CMakeLists.txt是CMake的配置文件，它包含了编译和构建过程的详细信息。
在这个文件中，我们需要定义项目名称、所需的源文件、编译选项等。
同时，我们还需要指定编译目标的类型，包括静态库、动态库或可执行文件等。
3. 配置CMake在CMakeLists.txt文件配置好后，我们需要在命令行窗口中切换到项目目录，并执行以下命令来配置CMake：```mkdir buildcd buildcmake ..```这个命令会创建一个新的build目录，并将CMakeLists.txt文件的配置信息写入到这个目录中的CMake缓存文件中。
在执行这个命令时，我们可以加上一些参数来指定编译器类型、编译选项等。
4. 编译生成静态库在配置好CMake后，我们可以执行以下命令来进行编译：```make```这个命令会根据CMakeLists.txt文件中的配置信息生成静态库文件，并将其保存在build目录中。
生成的静态库文件通常以lib为前缀，以.a为后缀。
5. 运行测试程序在生成了静态库文件后，我们可以通过编写测试程序来验证静态库是否正常工作。
测试程序通常包括一个或多个源文件、一个Makefile文件和一个可执行文件。
在此过程中，我们需要将静态库文件链接到测试程序中，并确保测试程序可以正常执行。
综上所述，使用CMake进行静态库编译需要我们熟练掌握CMake 的配置语法和编译参数。
只有在正确配置和使用CMake的情况下，才能顺利地生成高质量的静态库文件。
linux的编译方法动态库、静态库的制作和使用。
linux的编译方法动态库、静态库的制作和使用。
一、Linux编译方法在Linux下进行程序的编译使用gcc编译器，gcc是GNUCompiler Collection的缩写，是Linux系统中常用的编译器之一。
通过gcc编译器，可以将C、C++、Fortran等语言编写的程序源代码编译成可执行文件或动态库、静态库等。
1.编译可执行文件对于C语言程序，可以使用gcc编译器进行编译，命令格式如下：```shellgcc -o output_file input_file.c```其中，-o参数用来指定生成的可执行文件的名称，input_file.c为源文件的名称。
例如，编译一个名为hello.c的C语言程序，命令如下：```shellgcc -o hello hello.c```这样就会生成一个名为hello的可执行文件。
2.编译动态库对于动态库的编译，可以使用gcc编译器和共享库的特性。
动态库是一种在程序运行时加载的库，它可以被多个程序共享，并且在程序升级时不需要重新编译程序本身。
动态库的编译命令格式为：```shellgcc -shared -o libname.so source_file.c```其中，-shared参数表示生成动态库，libname.so为动态库的名称，source_file.c为动态库的源文件。
例如，编译一个名为libhello.so的动态库，命令如下：```shellgcc -shared -o libhello.so hello.c```这样就会生成一个名为libhello.so的动态库。
3.编译静态库静态库是一种在程序编译时静态链接的库，它会在程序生成的可执行文件中包含需要的库的代码，因此可执行文件的体积会变大，但运行时不需要依赖外部库。
静态库的编译命令格式为：```shellgcc -c source_file.car cr libname.a source_file.o```其中，-c参数表示只编译不链接，生成源文件的目标文件；ar命令用于创建和修改归档文件，-cr参数表示创建和修改归档文件，libname.a为静态库的名称，source_file.o为目标文件。
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中。
cmake添加头文件目录，链接动态、静态库
cmake添加头⽂件⽬录，链接动态、静态库罗列⼀下cmake常⽤的命令。
CMake⽀持⼤写、⼩写、混合⼤⼩写的命令。
1. 添加头⽂件⽬录INCLUDE_DIRECTORIES语法：include_directories([AFTER|BEFORE] [SYSTEM] dir1 [dir2 ...])它相当于g++选项中的-I参数的作⽤，也相当于环境变量中增加路径到CPLUS_INCLUDE_PATH变量的作⽤。
include_directories(../../../thirdparty/comm/include)2. 添加需要链接的库⽂件⽬录LINK_DIRECTORIES语法：link_directories(directory1 directory2 ...)它相当于g++命令的-L选项的作⽤，也相当于环境变量中增加LD_LIBRARY_PATH的路径的作⽤。
link_directories("/home/server/third/lib")3. 查找库所在⽬录FIND_LIBRARY语法：A short-hand signature is:find_library (<VAR> name1 [path1 path2 ...])The general signature is:find_library (<VAR>name | NAMES name1 [name2 ...] [NAMES_PER_DIR][HINTS path1 [path2 ... ENV var]][PATHS path1 [path2 ... ENV var]][PATH_SUFFIXES suffix1 [suffix2 ...]][DOC "cache documentation string"][NO_DEFAULT_PATH][NO_CMAKE_ENVIRONMENT_PATH][NO_CMAKE_PATH][NO_SYSTEM_ENVIRONMENT_PATH][NO_CMAKE_SYSTEM_PATH][CMAKE_FIND_ROOT_PATH_BOTH |ONLY_CMAKE_FIND_ROOT_PATH |NO_CMAKE_FIND_ROOT_PATH])例⼦如下：FIND_LIBRARY(RUNTIME_LIB rt /usr/lib /usr/local/lib NO_DEFAULT_PATH)cmake会在⽬录中查找，如果所有⽬录中都没有，值RUNTIME_LIB就会被赋为NO_DEFAULT_PATH4. 添加需要链接的库⽂件路径LINK_LIBRARIES语法：link_libraries(library1 <debug | optimized> library2 ...)# 直接是全路径link_libraries(“/home/server/third/lib/libcommon.a”)# 下⾯的例⼦，只有库名，cmake会⾃动去所包含的⽬录搜索link_libraries(iconv)# 传⼊变量link_libraries(${RUNTIME_LIB})# 也可以链接多个link_libraries("/opt/MATLAB/R2012a/bin/glnxa64/libeng.so" "/opt/MATLAB/R2012a/bin/glnxa64/libmx.so")可以链接⼀个，也可以多个，中间使⽤空格分隔.5. 设置要链接的库⽂件的名称TARGET_LINK_LIBRARIES语法：target_link_libraries(<target> [item1 [item2 [...]]][[debug|optimized|general] <item>] ...)# 以下写法都可以：target_link_libraries(myProject comm) # 连接libhello.so库，默认优先链接动态库target_link_libraries(myProject libcomm.a) # 显⽰指定链接静态库target_link_libraries(myProject libcomm.so) # 显⽰指定链接动态库# 再如：target_link_libraries(myProject libcomm.so) #这些库名写法都可以。
cmake常用指令
cmake常用指令CMake常用指令CMake是一个跨平台的开源构建工具，用于管理软件构建过程。
它通过使用CMake语言来描述构建过程，然后生成相应的构建系统。
在使用CMake时，我们可以通过一些常用的指令来完成各种构建任务。
本文将介绍一些常用的CMake指令，帮助读者更好地理解和使用CMake。
一、添加源文件和头文件在使用CMake构建项目时，首先需要将源文件和头文件添加到项目中。
CMake提供了几个常用的指令来完成这个任务。
1.1 add_executableadd_executable指令用于将源文件添加到项目中，并生成可执行文件。
它的语法如下所示：```add_executable(<executable_name> <source_files>)```其中，`<executable_name>`是生成的可执行文件的名称，`<source_files>`是源文件的列表。
1.2 add_libraryadd_library指令用于将源文件添加到项目中，并生成静态库或动态库。
它的语法如下所示：```add_library(<library_name> <library_type> <source_files>) ```其中，`<library_name>`是生成的库的名称，`<library_type>`可以是STATIC（静态库）或SHARED（动态库），`<source_files>`是源文件的列表。
1.3 include_directoriesinclude_directories指令用于添加头文件的搜索路径。
它的语法如下所示：```include_directories(<directory>)```其中，`<directory>`是头文件的搜索路径。
python cmake 指令
python cmake 指令CMake是一个用于自动化构建过程的跨平台工具。
它通过简单的语法来描述构建过程、依赖关系和目标文件等，然后生成适用于不同操作系统和编译器的构建脚本。
Python CMake指令是CMake中专门用于管理与Python相关的构建过程的一组指令。
以下是一些常用的Python CMake指令的介绍：1. find_package(Python3 COMPONENTS Interpreter Development)：这个指令用于寻找安装在系统上的Python3解释器和开发库。
它会设置一些相关的变量，比如PYTHON3_EXECUTABLE、PYTHON3_INCLUDE_DIR和PYTHON3_LIBRARY等，可以在后续的指令中使用。
2. add_library(<name> [STATIC SHARED MODULE] [EXCLUDE_FROM_ALL] source1 source2 ... sourceN)：这个指令用于将源代码文件编译成库文件。
可以使用STATIC选项创建静态库，使用SHARED选项创建共享库，使用MODULE选项创建Python模块。
可以通过设置EXCLUDE_FROM_ALL选项来将目标文件排除在构建过程之外。
3. add_executable(<name> source1 source2 ... sourceN)：这个指令用于将源代码文件编译成可执行文件。
它会生成一个与指定名称相关联的目标文件。
4. set_target_properties(<target> PROPERTIES prop1 value1 prop2value2 ...)：这个指令用于设置目标文件的属性。
可以通过这个指令设置一些与Python 相关的属性，比如PYTHON_MODULE、PYTHON_LIBRARY和PYTHON_EXTENSION等。
将C语言文件生成静态库lib
1 #include "Test.h" 2 3 int get_result(int firstNum,int secondNum) 4{ 5 return firstNum+secondNum; 6}
main.c
1 #include <stdio.h> 2 #include "Test.h" 3 4 int main() ቤተ መጻሕፍቲ ባይዱ{ 6 int rlt; 7 rlt = get_result(23,7); 8 printf("The result is: rlt = %d\n",rlt); 9 10 return 0; 11 }
其中Test.h,Test.c用于生成静态库，main.c用于测试
2,编译.o文件
无论静态库，还是动态库，都是由.o文件创建的。因此，我们必须将源程序Test.c通过gcc先编译成.o文件。
gcc -c Test.c
确认是否生成了Test.o文件
3，生成静态库
在linux环境下输入ar cr libmyTest.a Test.o
通过ls命令可以看到在当前目录中生成了静态库文件libmyTest.a文件
4，测试
输入gcc -o main main.c -L. -lmyTest
输出结果如下图：
楼主请问如果是在ubuntu环境下的qt调用vs编译的静态库也是按照你说的方法来吗
将 C语言文件生成静态库 lib
1，创建三个文件Test.c , Test.h,main.c
内容分别如下：
Test.h
1 #ifndef _TEST_H_ 2 #define _TEST_H_ 3 4 int get_result(int firstNum,int secondNum); 5 6 #endif //test.h
一步一步学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)该命令是将库⽂件链接到可执⾏⽂件⾥，这条命令能保证ｈｅｌｌｏ－ｗｏｒｌｄ可执⾏⽂件能够正确地⼀来于 ｍｅｓｓａｇｅ库⽂件（库⽂件总是在可执⾏⽂件之前构建的）。
4. 静态库和共享库下⾯命令中第⼆个参数ＳＴＡＴＩＣ是指⽣成静态库，如果要⽣成共享库，可以直接将其替换为ＳＨＡＲＥＤ关键词。
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)。
CMake优先链接静态库
CMake优先链接静态库当使⽤CMake来⽣成编译脚本时，如果需要链接其他库⽂件，⼀般使⽤，如：target_link_libraries(masterflatbuffersmariadbclientsslcryptodlrtpthreadresolvz)默认情况下，这个是链接动态库的。
不过很多时候为了⽅便部署，需要静态链接部分静态链库，有⼏种⽅式可以试下：直接写死静态库的完整路径target_link_libraries(master/usr/local/lib/libflatbuffers.a)⾃动查找静态库上⾯直接写死库⽂件的完整路径，可移植性⼤打折扣。
CMake的好处本⾝就是跨平台的，各个平台的库⽂件路径不⼀样，可以使⽤find_library来获取完整路径。
不过find_library默认情况下是优先查找动态库的，需要改⼀下if (WIN32 OR MSVC)set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")elseif (UNIX)# 仅查找静态库，强制后缀为 .aset(CMAKE_FIND_LIBRARY_SUFFIXES ".a")# 如果只是优先查找静态库，保证 .a 后缀在前⾯即可，把默认的后缀加上# set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})endif()find_library(FLATBUFFERS_LIB flatbuffers)target_link_libraries(master${FLATBUFFERS_LIB})# 当然，这个可能更简单，只是也不跨平台罢了find_library(FLATBUFFERS_LIB libflatbuffers.a)直接指定库⽂件后缀或者名字target_link_libraries(masterlibflatbuffers.a)# 或者target_link_libraries(masterflatbuffers.a)上⾯的写法都会查找静态库，只不过不跨平台（win下后缀是.lib）。