C语言程序静态库和动态库的创建及其应用

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

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 参数的含义同静态库。

C语⾔编写静态链接库及其使⽤本篇讲述使⽤C语⾔编写静态链接库，⽽且使⽤C和C++的⽅式来调⽤等.⼀、静态库程序：执⾏时不独⽴存在，链接到可执⾏⽂件或者动态库中，⽬标程序的归档。

1、⽤C编写静态库步骤a.建⽴项⽬（Win32 Static Library）b.加⼊库程序，源⽂件使⽤C⽂件（Win32 Static Library）clib.c库源⽂件<pre name="code" class="cpp">int CLib_add(int add1,int add2){return add1+add2;}int CLib_sub(int add1,int add2){return add1-add2;}编译，链接后产⽣clib.lib，后⾯使⽤这个⽂件2、静态库的使⽤a.建⽴⼀个C⽂件，能够在⽂件⾥直接使⽤C库函数，不须要头⽂件，C编译器仅仅是依据库函数名称，在库中找到相应的函数代码，进⾏链接。

b.库的路径设置。

项⽬的“Setting”中设置库路径，也能够使⽤#pragmakeyword设置 #pragma comment(lib,"..\\clib\\clib.lib")3、C的⽅式调⽤C语⾔编写的静态库C Type//C编译器什么头⽂件及函数声明都不要.....#pragma comment(lib,"..\\clib\\clib.lib") //通知链接器。

到那找源码.int main(void){int num1 = 100;int num2 = 1000;int nSum = CLib_add(num1,num2);int nSub = CLib_sub(num1,num2);printf("nSum = %d,nSub = %d\r\n",nSum,nSub);return 0;}</pre><pre name="code" class="cpp">4、<strong>C++的⽅式调⽤C语⾔编写的静态库</strong>在CPP环境使⽤C静态库。

静态库的使用与创建静态库是一种预编译的库，它包含了一组已经编译好的目标文件（.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`。

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

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

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

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

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

库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。

面对比一下两者：静态链接库：当要使用时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。

动态库而言：某个程序在运行中要调用某个动态链接库函数的时候，操作系统首先会查看所有正在运行的程序，看在内存里是否已有此库函数的拷贝了。

如果有，则让其共享那一个拷贝；只有没有才链接载入。

在程序运行的时候，被调用的动态链接库函数被安置在内存的某个地方，所有调用它的程序将指向这个代码段。

因此，这些代码必须使用相对地址，而不是绝对地址。

在编译的时候，我们需要告诉编译器，这些对象文件是用来做动态链接库的，所以要用地址不无关代码（Position Independent Code (PIC))。

注意：linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。

一．静态库下面就通过实际的例子来向大家演示一下,该怎样编译和使用静态和动态链接库：1. 编辑测试文件二个文件：add.c、sub.c、add.h 、sub.h 和main.c/*add.h */#ifndef _ADD_H_#define _ADD_H_int add(int a, int b);#endif-------------------------------------------------------------------------------------------------/*add.c*/#include "add.h"int add(int a, int b){return a+b;}------------------------------------------------------------------------------------------------- /*sub.h*/#ifndef _SUB_H_#define _SUB_H_int sub(int a, int b);#endif------------------------------------------------------------------------------------------------- /*sub.c*/#include "add.h"int sub(int a, int b){return a-b;}------------------------------------------------------------------------------------------------- /*main.c*/#include <stdio.h>#include "add.h"#include "sub.h"int main(void){printf("1 + 2 = %d\n", add(1, 2));printf("1 - 2 = %d\n", sub(1, 2));return 0;}------------------------------------------------------------------------------------------------- 2.将add.c 和sub.c 编译生成.o文件gcc -c add.cgcc -c sub.c生成的文件：sub.o ，add.o无论是静态库文件还是动态库文件，都是由.o 文件创建的。

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未被定义，则使用当前定义的标识符进行函数导出。

GCC编译步骤及静态库动态库制作GCC是一种广泛使用的编译器，可以将C、C++等高级语言源代码转换为可执行的机器码。

本文将介绍GCC编译步骤及制作静态库和动态库的过程。

1. 预处理（Preprocessing）：预处理器会处理源代码，根据预编译指令进行操作，例如宏展开、条件编译等。

预处理后的代码仍然是源代码，只是进行了一些文本替换和宏展开操作。

3. 汇编（Assembling）：汇编器将汇编语言转换为机器码，生成目标文件（Object Files）。

目标文件包含可执行代码的二进制表示，以及与其他目标文件和库文件链接的信息。

4. 链接（Linking）：链接器将多个目标文件和库文件结合在一起，生成最终的可执行文件。

链接器会解析目标文件之间的引用和符号，将它们关联起来，并生成可执行文件。

静态库制作：静态库是一种包含可执行代码和函数的库文件，在链接时会将库文件中的代码复制到最终的可执行文件中。

静态库的制作分为以下几个步骤：1.编写库代码：创建一个或多个源文件，其中包含一些可重用的函数和类。

确保将库代码编写成独立的、可移植的模块。

2. 编译库代码：使用GCC进行编译，将源代码文件编译成目标文件。

例如，对于C文件使用以下命令编译为目标文件：`gcc -c file1.cfile2.c`。

3. 归档库文件：将目标文件归档成库文件。

使用GCC进行归档时，可以使用`ar`命令。

例如，使用以下命令将目标文件归档：`ar rcs libmylib.a file1.o file2.o`。

这将创建名为libmylib.a的静态库文件。

4. 使用库文件：在需要使用库函数的程序中，包含库的头文件，并在链接时将库文件链接到程序中。

例如，使用以下命令编译和链接程序：`gcc -o myprog myprog.c -L. -lmylib`。

其中，-L参数指定库文件的路径，-l参数指定要链接的库文件。

在程序中使用库函数时，只需包含相应的头文件，并调用库函数。

GCC⽣成静态库.o以及动态库.so⽂件及其使⽤学习⽬录编译⽣成静态库⽂件1.编辑⽣成例⼦程序hello.h,hello.c,main.chello.c是函数库的源程序，其中包括公⽤函数hello,该函数将在屏幕上输出(hello XXX)hello.h为该函数库的头⽂件,main.c为测试库的主程序。

在主程序中调⽤函数hello程序1:hello.h#ifndef HELLO_H#define HELLO_Hvoid hello(const char*name)#endif//HELLO_H程序2 :hello.c#include<stdio.h>void hello(const char *name){printf("Hello %s!\n",name);}程序3 :main.c#include "hello.h"int main(){hello("everyone");return 0;}2,将hello.c编译成.o⽂件⽆论是静态库还是动态库都是由.o⽂件创建的。

因此，我们必须将源程序hello.c通过gcc先编译成.o⽂件输⼊命令 gcc -c hello.c在⽂件夹中发现⽣成了hello.o⽂件3.由.o⽂件创建静态库静态库⽂件名命名规范是以lib为前缀紧接着跟着静态库名，扩展名为.a。

例如:我们将创建的⽽静态库命名为myhello，则静态库⽂件名就是libmyhello.a。

在创建和使⽤静态库时我们需要注意这点，创建静态库⽤ar命令。

在系统提⽰符下输⼊以下命令创建静态库⽂件libmyhello.a#ar -crv libmyhello.a hello.o4.在程序中使⽤静态库静态库制作完了如何使⽤它内部的函数呢？只需要在使⽤到这些公⽤函数的源程序中包含这些公⽤函数的原型声明，然后再gcc命令⽣成⽬标⽂件时指明静态库名字，gcc将会从静态库中将公⽤函数连接到⽬标⽂件中注意gcc会在静态库名前加上前缀lib，然后追加.a得到的静态库⽂件名来查找静态库⽂件。

C语言静态函数库的制作和使用方法
一、C语言静态函数库的制作
1.1创建.h文件
首先我们需要创建一个.h文件，用来将静态函数库的接口定义出来，并且可以被其他文件所调用。

当创建完.h文件之后，我们可以在里面定
义首先被客户端使用的函数原型，如：
```c
int myAdd(int a, int b); //定义myAdd函数，用来求两个数字的
和
```
1.2创建.c文件
之后，我们需要创建一个.c文件，用来实现上面在.h文件中定义的
函数。

.c文件中要包含对应的.h头文件，比如mylib.c对应mylib.h，
当创建完.c文件之后，在里面实现我们定义在.h文件中的函数，比如：```c
#include"mylib.h"
intmyAdd(inta,intb)
returna+b;
```
1.3编译成静态函数库
在上面的步骤中，我们实现了一个静态函数库，并且它可以被其他文件调用，但是好像有什么地方还不够？当然，没有编译成静态函数库，还是无法被其他文件调用的。

所以，可以使用gcc编译器将.c文件编译成静态函数库，编译方法如下：
```c
gcc-c mylib.c –o mylib.a
```
其中mylib.c是之前创建的.c文件，mylib.a是编译成的静态函数库文件。

二、C语言静态函数库的使用
2.1在项目中添加依赖
首先，我们要给我们的项目添加依赖文件，也就是把刚刚创建的mylib.h文件和mylib.a文件添加到项目中，以便我们在代码中调用。

2.2使用函数库。

动态库的创建与使用动态库是一种在程序运行时加载的库，它可以使用动态链接来提供共享代码。

在本文中，我们将介绍如何创建和使用动态库。

一、创建动态库动态库可以使用多种编程语言创建，如C、C++、Java等。

下面以C语言为例，介绍如何创建动态库。

1. 创建源文件首先需要编写源文件，可以是一个或多个C文件。

例如，我们创建一个名为“test.c”的文件，其中包含一个名为“test_func”的函数。

```#include <stdio.h>void test_func() {printf('Hello, world!');}```2. 编译生成动态库使用编译器将源文件编译生成动态库。

在Linux下，可以使用gcc命令，如下所示：```gcc -shared -o libtest.so test.c````-shared` 表示生成动态库，`-o` 后面指定生成的库文件名，这里我们命名为“libtest.so”。

3. 添加库文件路径在使用动态库时，需要告诉编译器库文件的路径。

可以使用环境变量LD_LIBRARY_PATH来设置库文件路径，如下所示：```exportLD_LIBRARY_PATH=/path/to/dynamic/library:$LD_LIBRARY_PATH ```其中，“/path/to/dynamic/library”为动态库所在的路径。

二、使用动态库使用动态库需要在程序中包含头文件并链接库文件。

1. 包含头文件在程序中包含动态库的头文件，如下所示：```#include <stdio.h>#include <test.h>```其中，“test.h”是头文件名，包含了动态库中的函数声明。

2. 链接库文件在编译程序时需要链接动态库文件，可以使用编译器的-L和-l 选项，如下所示：```gcc -o program program.c -L /path/to/lib -ltest```其中，“program.c”是程序源文件名，“-L”指定库文件所在路径，“-ltest”指定链接“libtest.so”库文件。

动态链接库和静态库的创建及使用教程第一部分静态库(以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.若要为新类创建源文件，请从“项目”菜单中选择“添加新项…”。

C语言静态函数库的制作和使用方法一．库函数简介：C语言中有一些函数会执行一些标准任务，可以事先对这些函数进行编译，然后将他们放置在一些特殊的目标代码文件中，这些目标代码文件称为库。

库文件中的函数可以通过连接程序与应用程序进行链接，这样就不用在每次执行程序时都对这些通用的函数进行编译了。

标准的C函数库名称为libc，包含了诸如内存管理或者输入输出操作的基本函数。

这些库放置在系统的公用目录下，如/usr/lib，系统中的任何用户都可以利用这些库函数，用户也可以自己建立库。

库的两种形式：静态库；共享库二.静态库：1）基本概念：静态库又称为文档文件（Archive File）。

它是多个.o文件的集合。

Linux中静态库文件的后缀为"a"。

静态库的代码在编译时就已经链接到应用程序中静态库中的各个成员（.o文件）没有特殊的存在格式，仅仅是一个.o文件的集合。

使用"ar"工具维护和管理静态库2）如何建立和使用静态库下面是一个建立静态链接库的例子：1、编写源文件：源码一：my_strcpy.c:（实现一个strcpy的功能）#include <stdio.h>#include <string.h>#include <stdlib.h>void my_strcpy(char *des, const char *src){while (*des++ = *src++);}源码二：my_strcmp.c(实现一个strcmp的功能)#include <stdio.h>#include <string.h>#include <stdlib.h>int my_strcmp(const char *obj1, const char *obj2) {while (*obj1 && *obj2){if (*obj1 - *obj2){return (*obj1 - *obj2); }else{obj1++;obj2++;}}return 0;}2、生成.o文件gcc -c my_strcpy.c my_strcmp.c3、建立静态链接库ar rcs libmylib.a *.o这样，就在当前路径下面建立好了libmylib.a的静态库；ar的三个参数中：r代表将文件插入归档文件中，c代表建立归档文件，s代表若归档文件中包含了对象模式，可利用此参数建立备存文件的符号表。

Linux下Gcc生成和使用静态库和动态库详解一、基本概念1.1什么是库在windows平台和linux平台下都大量存在着库。

本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。

由于windows和linux的平台不同（主要是编译器、汇编器和连接器的不同），因此二者库的二进制是不兼容的。

本文仅限于介绍linux下的库。

1.2库的种类linux下的库有两种：静态库和共享库（动态库）。

二者的不同点在于代码被载入的时刻不同。

静态库的代码在编译过程中已经被载入可执行程序，因此体积较大。

共享库的代码是在可执行程序运行时才载入内存的，在编译过程中仅简单的引用，因此代码体积较小。

1.3库存在的意义库是别人写好的现有的，成熟的，可以复用的代码，你可以使用但要记得遵守许可协议。

现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。

共享库的好处是，不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例。

1.4库文件是如何产生的在linux下静态库的后缀是.a，它的产生分两步Step 1.由源文件编译生成一堆.o，每个.o里都包含这个编译单元的符号表Step 2.ar命令将很多.o转换成.a，成为静态库动态库的后缀是.so，它由gcc加特定参数编译产生。

具体方法参见后文实例。

1.5库文件是如何命名的，有没有什么规范在linux下，库文件一般放在/usr/lib和/lib下，静态库的名字一般为libxxxx.a，其中xxxx是该lib的名称动态库的名字一般为libxxxx.so.major.minor，xxxx是该lib的名称，major是主版本号， minor是副版本号1.6如何知道一个可执行程序依赖哪些库ldd命令可以查看一个可执行程序依赖的共享库，例如# ldd /bin/lnlibc.so.6=> /lib/libc.so.6 (0×40021000)/lib/ld-linux.so.2=> /lib/ld- linux.so.2 (0×40000000)可以看到ln命令依赖于libc库和ld-linux库1.7可执行程序在执行的时候如何定位共享库文件当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径。

C语言静态函数库的制作和使用方法一、静态函数库的制作1.创建源代码文件首先，我们需要编写一组相关的函数，并将它们保存为源代码文件。

建议将每个函数保存为一个单独的源代码文件，以便于维护和管理。

2.编写头文件接下来，我们需要编写一个头文件来声明函数的接口。

头文件应该包含函数的原型和必要的宏定义。

头文件的命名规则通常是将库的名字和.h 扩展名组合起来。

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

使用以下命令来编译一个源代码文件：gcc -c filename.c -o filename.o重复这一过程，直到将所有源代码文件都编译成目标文件。

4.创建静态函数库使用ar命令创建静态函数库。

ar命令可以将一组目标文件打包成一个库文件。

以下是创建静态函数库的命令：ar rcs libname.a filename1.o filename2.o ...其中，libname.a是静态函数库的名称，filename1.o、filename2.o 等是目标文件的名称。

5.安装静态函数库将静态函数库复制到系统的指定目录下，以便在其他程序中使用。

二、静态函数库的使用1.包含头文件在需要使用静态函数库的程序中，使用#include指令引用之前创建的头文件。

例如：#include <header.h>2.编译程序使用C编译器编译程序时，需要在编译命令中指定要使用的静态函数库。

以下是编译命令的格式：gcc program.c -L/path/to/library -lname其中，program.c是主程序的源代码文件，/path/to/library是静态函数库所在的路径名，libname是静态函数库的名称。

3.运行程序使用生成的可执行文件运行程序。

静态函数库在程序运行时会被自动加载并链接到程序中。

三、注意事项1. 静态函数库不能与动态函数库同时使用。

如果需要在程序运行时动态加载函数库，应该使用动态函数库（.so文件）。

如何使⽤GCC⽣成动态库和静态库根据链接时期的不同，库⼜有静态库和动态库之分。

静态库是在链接阶段被链接的，所以⽣成的可执⾏⽂件就不受库的影响，即使库被删除，程序依然可以成功运⾏。

⽽动态库是在程序执⾏的时候被链接的。

程序执⾏完，库仍需保留在系统上，以供程序运⾏时调⽤。

链接静态库从某种意义上来说是⼀种复制粘贴，被链接后库就直接嵌⼊可执⾏程序中了，这样系统空间有很⼤的浪费，⽽且⼀旦发现系统中有bug，就必须⼀⼀把链接该库的程序找出来，然后重新编译，⼗分⿇烦。

⽽动态库刚好弥补了这个缺陷，因为动态库是在程序运⾏时被链接的，所以磁盘上只需保留⼀份副本，⼀次节约了空间，如果发现bug或者是要升级，只要⽤新的库把原来的替换掉就可以了。

静态库是不是⼀⽆是处了呢？⾮也。

如果代码在其他系统上运⾏，且没有相应的库时，解决办法就是使⽤静态库。

⽽且由于动态库是在程序运⾏的时候被链接，因此动态库的运⾏速度⽐较慢。

好了，我们了解了关于动态库和静态库的相关知识，那么如何使⽤GCC⽣成静态库和动态库呢？ 我们参考了《LinuxC程序设计⼤全》上⾯的例⼦，来总结GCC下编译静态及其动态链接库的⽅法及步骤。

程序清单如下： test.c1int add(int a,int b)2 {3 retrun a+b;4 }56int sub(int a,int b)7 {8 retrun a-b;9 }1011int mul(int a,int b)12 {13 retrun a*b;14 }1516int div(int a,int b)17 {18 retrun a/b;19 } test.h的内容1 #ifndef _TEST_H_2#define _TEST_H_3extern int add(int a,int b);4extern int sub(int a,int b);5extern int mul(int a,int b);6extern int div(int a,int b);main.c⽂件内容1 #include<stduo.h>2 #include<test.h>3int main()4 {5 int a,b;6 printf("please input a and b\n");7 scanf("%d %d",&a,&b);8 printf("The add:%d\n",add(a,b));9 printf("The sub:%d\n",sub(a,b));10 printf("The mul:%d\n",mul(a,b));11 printf("The div:%d\n",div(a,b));12 } 1.使⽤gcc⽣成静态库及静态库使⽤⽅法： 在此例中，test.c⽤于编译⽣成静态库libtest.a，test.h为libtest.a对应的头⽂件。

C/C++ 编译器和调试器以及静态库、动态库使用汇总阅读提示：本文是C/C++ 编译器和调试器以及静态库、动态库使用汇总大多数unix系统下面的调试器的使用方法如下：gdb介绍GNU 的调试器称为gdb，该程序是一个交互式工具，工作在字符模式。

在X Window 系统中，有一个gdb 的前端图形工具，称为xxgdb。

gdb 是功能强大的调试程序，可完成如下的调试任务：* 设置断点；* 监视程序变量的值；* 程序的单步执行；* 修改变量的值。

在可以使用gdb 调试程序之前，必须使用-g 选项编译源文件。

可在makefile 中如下定义CFLAGS 变量：CFLAGS = -g运行gdb 调试程序时通常使用如下的命令：gdb progname在gdb 提示符处键入help，将列出命令的分类，主要的分类有：* aliases：命令别名* breakpoints：断点定义；* data：数据查看；* files：指定并查看文件；* internals：维护命令；* running：程序执行；* stack：调用栈查看；* statu：状态查看；* tracepoints：跟踪程序执行。

键入help 后跟命令的分类名，可获得该类命令的详细清单。

gdb 的常用命令命令解释break NUM 在指定的行上设置断点。

bt 显示所有的调用栈帧。

该命令可用来显示函数的调用顺序。

clear 删除设置在特定源文件、特定行上的断点。

其用法为：clear FILENAME:NUM。

continue 继续执行正在调试的程序。

该命令用在程序由于处理信号或断点而导致停止运行时。

display EXPR 每次程序停止后显示表达式的值。

表达式由程序定义的变量组成。

file FILE 装载指定的可执行文件进行调试。

help NAME 显示指定命令的帮助信息。

info break 显示当前断点清单，包括到达断点处的次数等。

info files 显示被调试文件的详细信息。

C语⾔编程gcc如何⽣成静态库.a和动态库.so⽰例详解⽬录⼀、什么是静态库和动态库⼆、gcc⽣成.a静态库和.so动态库1.⽣成静态库(.a)1.1编辑⽣成例⼦程序hello.h、hello.c和main.c1.2将hello.c编译成.o⽂件1.3由.o⽂件创建静态库1.4在程序中使⽤静态库1.5验证静态库的特点2.⽣成动态库(.so)2.1由.o⽂件创建动态库⽂件2.2在程序中使⽤动态库三、实例1.实例11.1代码1.2 静态库.a⽂件的⽣成与使⽤1.3 动态库.so⽂件的⽣成与使⽤2.实例22.1代码2.2 静态库.a⽂件的⽣成与使⽤2.3 动态库.so⽂件的⽣成与使⽤总结系统环境：Ubuntu Desktop 18.04⼀、什么是静态库和动态库我们通常需要把⼀些公⽤函数制作成函数库，供其它程序使⽤，函数库分为静态库和动态库两种。

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

动态库在程序编译时并不会被连接到⽬标代码中，⽽是在程序运⾏时才被载⼊。

这样我们可以通过更改动态库，动态的改变程序的某些功能。

Linux下使⽤ar⼯具，将⽬标⽂件压缩到⼀起，并且对其进⾏编号和索引，以便于查找和检索。

⼆、gcc⽣成.a静态库和.so动态库1.⽣成静态库(.a)1.1编辑⽣成例⼦程序hello.h、hello.c和main.chello.h#ifndef HELLO_H//如果源⽂件没有定义，则编译下⾯代码#define HELLO_H//定义宏void hello(const char *name);#endif/HELLO_H//ifndef的结束hello.c#include<stdio.h>void hello(const char *name){printf("Hello %s!\n",name);}main.c#include "hello.h"int main(){hello("everyone");return 0;}1.2将hello.c编译成.o⽂件⽆论静态库还是动态库都是由.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。