实验3：动态库和静态库的制作和使用

静态库和动态库编译静态库和动态库是编程中常用的两种库文件形式，本文将介绍它们的编译过程和使用方法。

1. 静态库编译静态库是一种在编译时被链接到程序中的库文件，它包含了程序所依赖的所有函数和数据结构，因此程序在运行时不需要再加载库文件。

静态库的编译过程包括以下步骤：（1）创建一个或多个源文件，使用编译器将它们编译成目标文件（.o 或 .obj）。

（2）将多个目标文件打包成一个静态库文件，通常使用 ar 工具完成此操作。

例如，在 Linux 系统下，可以使用以下命令创建名为 libfoo.a 的静态库文件：$ ar rcs libfoo.a foo1.o foo2.o ...其中，rcs 参数分别表示创建、向库文件中添加目标文件和生成索引表。

（3）在编译器中使用静态库，需要将其链接到目标程序中。

在Linux 系统下，可以使用以下命令编译名为 main.c 的源文件和名为libfoo.a 的静态库文件：$ gcc -o main main.c -L. -lfoo其中，-L 参数指定库文件搜索路径，. 表示当前目录；-l 参数指定链接库文件，实际上是将其前缀 lib 和后缀 .a 去掉，即 foo。

2. 动态库编译动态库是一种在程序运行时动态加载的库文件，它只包含程序所需要的部分函数和数据结构，因此可以减小程序的尺寸和加载时间。

动态库的编译过程包括以下步骤：（1）创建一个或多个源文件，使用编译器将它们编译成目标文件。

（2）将多个目标文件打包成一个共享库文件，通常使用 ld 或链接器完成此操作。

例如，在 Linux 系统下，可以使用以下命令创建名为 libfoo.so 的动态库文件：$ gcc -shared -o libfoo.so foo1.o foo2.o ...其中，-shared 参数表示生成共享库文件。

（3）在编译器中使用动态库，需要将其链接到目标程序中。

在Linux 系统下，可以使用以下命令编译名为 main.c 的源文件和名为libfoo.so 的动态库文件：$ gcc -o main main.c -L. -lfoo其中，-L 和 -l 参数的含义同静态库。

动态库和静态库的制作过程我们通常把一些公用函数制作成函数库，供其它程序使用。

函数库分为静态库和动态库两种。

静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。

本文主要通过举例来说明在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#(注1：本文不介绍各命令使用和其参数功能，若希望详细了解它们，请参考其他文档。

C语言程序静态库和动态库的创建及其应用在用c写程序时，很多时候需要存储一些简单的数据，如果为此而用mysql数据库就有些大才小用了，可以把这些数据以结构的形写入文件，然后再需要时读取文件，取出数据。

如下是定义函数的源文件和头文件：源文件struct.c:#include "struct.h"//第一个参数是要写入的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示写入成功，返回FALSE表示写入失败int writeStruct(const char *fileName,char *buffer,int bufferLen,char *mode){ int ret;FILE *fileID = NULL;fileID = fopen(fileName,mode);if (fileID == NULL){perror("fopen");goto writeEnd;}rewind(fileID);ret = fwrite(buffer,bufferLen,1,fileID);if (ret <= 0){perror("fwrite");goto writeEnd;}if (fileID != NULL){fclose(fileID);fileID = NULL;}return TRUE;writeEnd:if (fileID != NULL){fclose(fileID);fileID = NULL;}return FALSE;}//第一个参数是要读取的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示读取成功，返回FALSE表示读取失败int readStruct(const char *fileName,char *buffer,int bufferLen,char *mode){ int ret;FILE *fileID = NULL;fileID = fopen(fileName,mode);if (fileID == NULL){perror("fopen");goto readEnd;}rewind(fileID);memset(buffer,0,sizeof(buffer));ret = fread(buffer,bufferLen,1,fileID);if (ret >= 0){strcat(buffer,"\0");}else{perror("fread") ;goto readEnd;}if (fileID != NULL){fclose(fileID);fileID = NULL;}return TRUE;readEnd:if (fileID != NULL){fclose(fileID);fileID = NULL;}return FALSE;}头文件struct.h:#ifndef OWNSTRUCT_H_#define OWNSTRUCT_H_#include#include#include#define FALSE 0#define TRUE 1//第一个参数是要写入的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示写入成功，返回FALSE表示写入失败int writeStruct(const char *fileName,char *buffer,int bufferLen,char *mode);//第一个参数是要读取的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示读取成功，返回FALSE表示读取失败int readStruct(const char *fileName,char *buffer,int bufferLen,char *mode);#endif为了使用方便，可以把这两个函数接口定义为动态链接库或静态链接库。

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。

Linux下静态库和动态库（共享库）的制作与使用Linux 操作系统支持的函数库分为静态库和动态库，动态库又称共享库。

linux 系统有几个重要的目录存放相应的函数库，如/lib /usr/lib。

静态函数库：这类库的名字一般是libxxx.a；利用静态函数库编译成的文件比较大，因为整个函数库的所有数据都会被整合进目标代码中，他的优点就显而易见了，即编译后的执行程序不需要外部的函数库支持，因为所有使用的函数都已经被编译进可执行文件了。

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

动态函数库：这类库的名字一般是libxxx.so，动态库又称共享库;相对于静态函数库，动态函数库在编译的时候并没有被编译进目标代码中，你的程序执行到相关函数时才调用该函数库里的相应函数，因此动态函数库所产生的可执行文件比较小。

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

动态函数库的改变并不影响你的程序，所以动态函数库的升级比较方便。

而且如果多个应用程序都要使用同一函数库，动态库就非常适合，可以减小应用程序的体积。

下面来介绍linux 静态函数库的创建和使用：例程add.h add.c sub.hsub.cmain.c: add.h #ifndef ADD_H #define ADD_H int add(int x,int y); #endif add.c #include stdio.h #include add.h int add(int x,int y){ return (x+y);} ------------------------------------- -------------------------------sub.h #ifndef SUB_H #define SUB_H int sub(int x,int y); #endif sub.c #include stdio.h#include sub.h int sub(int x,int y){ return (x-y);} -----------------------------------------------------------------------main.c #include stdio.h#include sub.h #include add.h int main() { inta,b;a = add(1,2);b = sub(10,5);tips:感谢大家的阅读，本文由我司收集。

静态库的使用与创建静态库是一种预编译的库，它包含了一组已经编译好的目标文件（.o文件）。

使用静态库可以将一些常用的函数、类或其他代码打包成一个单独的文件，以便在多个应用程序中重复使用。

使用静态库：1. 创建静态库：首先需要将要打包的源代码编译成目标文件，然后使用静态库工具（如ar）将目标文件打包成静态库文件（.a文件）。

2. 链接静态库：在编译应用程序时，需要引用静态库文件，并将其链接到应用程序的可执行文件中。

可以使用编译器的命令行选项来指定链接静态库的路径和名称。

创建静态库的一般步骤如下：1. 编写源代码文件：创建需要打包进静态库的源代码文件（.c、.cpp、.h等）。

2. 编译源代码文件：使用编译器将源代码文件编译成目标文件（.o文件）。

例如，使用gcc编译C文件：`gcc -c file.c -o file.o`。

3. 打包目标文件：使用静态库工具（如ar）将目标文件打包成静态库文件。

例如，使用ar工具创建静态库：`ar rcs libfile.a file1.o file2.o ...`。

4. 链接静态库：在应用程序的编译过程中，使用编译器的命令行选项来链接静态库文件。

例如，使用gcc链接静态库：`gcc main.c -o main -L<path_to_lib> -lfile`。

注意事项：在创建静态库时，需要保持相应源代码文件的可移植性和独立性，以便在不同的项目中使用。

链接静态库时，需要确保目标文件和静态库文件的路径正确，并且编译器能够找到它们。

如果静态库依赖于其他库，需要确保这些依赖库也正确链接到应用程序中。

使用静态库可以提高代码的重用性和管理性，尤其是对于一些通用的函数或模块。

这种方法适用于部署到嵌入式设备、静态链接的可执行文件等场景。

xianga…11月23日正文字体大小：大中小静态库与动态库的建立与使用(2011-11-03 13:27:55)转载▼分类：C/C标签：杂谈转《深入浅出Visual C++动态链接库编程》作者宋宝华静态链接库就是你使用的.lib文件，库中得代码最后需要连接到你的可执行文件中去，所以静态连接的可执行文件一般比较大一些。

引用：一、通用：格式如：#pragma comment(lib,"XXX.lib") //指定与静态库一起连接二、针对开发环境：1、如果使用VC，可以在Project Setting--&gt;Link中加入你的静态库，也可以直接把该.lib 文件加入到你的工程中2、如果使用Visual Studio，位置在项目→配置属性→连接器→输入→附加依赖项中加入.lib文件静态链接库不同于动态链接库（*.dll），在静态库情况下，函数和数据被编译进一个二进制文件（通常扩展名为*.LIB），Visual C++的编译器在链接过程中将从静态库中恢复这些函数和数据并把他们和应用程序中的其他模块组合在一起生成可执行文件。

这个过程称为"静态链接"，此时因为应用程序所需的全部内容都是从库中复制了出来，所以静态库本身并不需要与可执行文件一起发行。

静态链接库对静态链接库的讲解不是本文的重点，但是在具体讲解DLL之前，通过一个静态链接库的例子可以快速地帮助我们建立“库”的概念。

图1 建立一个静态链接库如图1，在VC++6.0中new一个名称为libTest的static library工程（单击此处下载本工程附件），并新建lib.h和lib.cpp两个文件，lib.h和lib.cpp的源代码如下：//文件：lib.h#ifndef LIB_H#define LIB_Hextern "C" int add(int x,int y);//声明为C编译、连接方式的外部函数#endif//文件：lib.cpp#include "lib.h"int add(int x,int y){return x + y;}编译这个工程就得到了一个.lib文件，这个文件就是一个函数库，它提供了add的功能。

C静态库（lib）及动态库（dll）的创建及调用一、静态库的创建及调用最近在编程序的时候，用到静态库和动态库的创建和调用，将自己的一些心得总结如下，希望对各位有所帮助，有不恰当之处欢迎评论留言。

静态库和动态库的区别可以参考博客：windows中静态库lib和动态dll的区别及使用方法_dxzysk的专栏-CSDN博客_动态dll和静态库的区别1、静态库的创建为了方便大家学习，从空项目进行演示，实现输入两个数求出两数之和及两数之差，本文使用VS2017编译器。

（1）创建空项目（2）新建头文件.h和源文件.cpp其中test工程为后面测试用工程，现在不用考虑。

（3）修改项目属性，将目标文件扩展名和配置类型均修改为.lib （4）在项目头文件testLib.h中编写代码方法一和方法二均可以生成和调用（5）源文件testLib.cpp代码编写(6)工程生成可以看到工程目录下生成了testLib.ib和testLib.pdb文件，代表静态库生成成功。

2、静态库的调用（1）为了方便演示，在静态库生成的同解决方案下创建测试工程test，本地创建的是控制台应用程序。

（2）创建完测试工程后，在test.cpp文件中编写静态库调用程序（3）将test工程设置为启动工程，编译运行，会出现报错（4）针对（3）出现的报错，需要在项目中引入静态库文件路径静态库生成工程和测试工程目录如下：引入静态库的相对路径再次编译就可以成功。

运行结果如下至此，静态库的创建及调用讲解结束。

二、动态库的创建及调用1、动态库的创建动态库的创建介绍两种方式：__declspec(dllexport)和.def文件导出。

1.1、动态库的创建（__declspec(dllexport)）（1）同静态库一样创建空项目testDll，创建头文件和源文件（2）修改项目属性，将目标文件扩展名和配置类型均修改为.dll(3)修改项目头文件testDll.h，本文介绍三种dll库生成的方法动态生成库的关键字为__declspec(dllexport)方法一和方法二的区别就是标识符是否被定义，如果标识符TESTDLL被定义则重新定义标识符TESTDLLAPI，并使用重新定义的标识符进行函数导出；如果标识符TESTDLL未被定义，则使用当前定义的标识符进行函数导出。

UNIX系统开发－静态库和动态库的建立UNIX系统及各种软件包为开发人员提供了大量的库文件。

但一般情况下这些库文件还不能足以满足用户的所有需求。

开发人员大多会根据他们自己的开发、研究要求编写出许多函数。

对于这些函数，如果都用在命令行中指定源文件的方法同调用它们的的程序链接起来，虽然也是可以的，但也有一些缺点：对每一个调用了这些函数的程序，在编译时都需要将这些函数的代码分别重新编译，这实际是对计算时间的大量浪费。

一个文件中通常都不止包含有一个函数的定义。

使用上述编译方法将使得大量无关函数的代码被拷贝到最终的可执行文件中，无端加大对存储资源的占用量，使运行时装载变慢。

维护上的诸多不便。

由于一个源文件供多个程序使用，当由于某个程序的需要面对此源文件进行了某种修改时将引起诸多意想不到的麻烦。

等等。

所有这些原因，使得我们想到能否将自己编写的函数也作成库文件供多个程序调用，就如同那些标准的库函数那样。

事实上在UNIX系统中提供了这方面的工具。

借助于这些工具我们不光是能将函数放到静态库，而且能够将其作成动态库。

下面来看看如何生成静态库。

我们知道静态库也称档案库，在此档案文件中实际上是收集了一系列的目标文件。

这些目标文件就是由CC对函数的源代码编译生成的。

因此，静态库的生成方法实际上可分成两步：1.将各函数代码所在地源文件编译成目标文件。

例如，对于前面的myfunc.c，可以用如下命令将其编译成目标文件：$ cc -c myfunc.ccc命令行中将其分别列上就可以了。

myfunc.o。

2.将各目标文件收集起来放到一个静态库文件中。

这主要借助于ar命令完成，如：$ ar r $HOME/lib/libtest.a myfunc.oar:creating /home/yxz/libtest.a$这里-o $HOME/lib/libtest.a是生成的静态库的全路径名。

其中我们假定$HOME/lib目录已经存在。

注意对静态库的命名要遵循libx.a的原则，便于以后能够在cc命令行中用-l选项指定之。

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。

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为目标文件。

C语言是一种广泛应用的编程语言，优秀的C程序员总是会将常用的代码封装成函数或者模块，这样可以提高代码的可读性和重用性。

而静态库就是一种常用的封装方式。

本文将介绍C静态库的创建与使用。

一、静态库的概念静态库是指在编译时被链接到目标文件中的库文件，其包含了一组函数和数据，这些函数和数据可以被不同的程序调用。

静态库可以分为标准库和用户库两种，标准库是C语言自带的库，包含了大量的函数和常量，在编译时会自动链接。

用户库则是程序员自己编写的库，需要手动链接。

二、静态库的创建1. 编写头文件和源文件首先，我们需要编写头文件和源文件，这些文件中包含了我们需要封装的函数和数据。

以一个简单的示例来说明：假设我们要封装一个计算两个整数之和的函数add()，代码如下：add.h```int add(int a, int b);```add.c```include "add.h"int add(int a, int b){return a + b;}```2. 编译生成目标文件接下来，我们需要将源文件编译成目标文件，使用gcc命令进行编译：```gcc -c add.c -o add.o```其中，-c表示只编译不链接，-o表示指定输出文件名。

3. 创建静态库使用ar命令将目标文件打包成静态库：```ar rcs libadd.a add.o```其中，r表示插入目标文件到库中，c表示创建库，s表示建立索引表。

libadd.a是静态库的名称，可以自定义。

4. 静态库的使用将静态库链接到程序中：```gcc main.c -L. -ladd -o main```其中，-L表示指定库文件的路径，这里使用当前路径，-l表示指定库文件名称，不需要添加前缀“lib”和后缀“.a”。

三、静态库的使用使用静态库的方法与调用普通函数没有区别，只需要在程序中包含头文件即可。

以之前的示例为例：main.c```include "add.h"include <stdio.h>int main(){int a = 1, b = 2;printf("%d + %d = %d\n", a, b, add(a, b));return 0;}```编译并运行程序：```gcc main.c -L. -ladd -o main./main```输出结果为：1 + 2 = 3。

动态链接库和静态库的创建及使用教程第一部分静态库(以vs2005为例)一、创建新的静态库项目1.从“文件”菜单中，选择“新建”，然后选择“项目…”。

2.从“项目类型”窗格中，选择“Visual C++”下的“Win32”。

3.从“模板”窗格中，选择“Win32 控制台应用程序”。

4.为项目选择一个名称，如“MathFuncsLib”，并将其输入“名称”字段。

为解决方案选择一个名称，如“StaticLibrary”，并将其输入“解决方案名称”字段。

5.按“确定”启动Win32 应用程序向导。

在“Win32 应用程序向导”对话框的“概述”页中，按“下一步”。

6.从“Win32 应用程序向导”的“应用程序设置”页中，选择“应用程序类型”下的“静态库”。

7.从“Win32 应用程序向导”的“应用程序设置”页中，取消选择“附加选项”下的“预编译头”。

8.按“完成”创建项目。

向静态库添加类1.若要为新类创建头文件，请从“项目”菜单中选择“添加新项…”。

将显示“添加新项”对话框。

从“类别”窗格中，选择“Visual C++”下的“代码”。

从“模板”窗格中选择“头文件(.h)”。

为头文件选择一个名称，如“MathFuncsLib.h”，并按“添加”。

将显示一个空白文件。

2.添加一个名为“MyMathFuncs”的简单类，以执行常见的算术运算，如加、减、乘和除。

代码应与以下内容类似：// MathFuncsLib.hnamespace MathFuncs{class MyMathFuncs{public:// Returns a + bstatic double Add(double a, double b);// Returns a - bstatic double Subtract(double a, double b);// Returns a * bstatic double Multiply(double a, double b);// Returns a / b// Throws DivideByZeroException if b is 0static double Divide(double a, double b);};}3.若要为新类创建源文件，请从“项目”菜单中选择“添加新项…”。