1.动静态库

• 静态库（.a）：程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库
• 动态库（.so）：程序在运行的时候才去链接动态库的代码，多个程序共享使用库的代码。
• 一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机器码
• 在可执行文件开始运行以前，外部函数的机器码由操作系统从磁盘上的该动态库中复制到内存中，这个过程称为动态链接（dynamic linking）
• 动态库可以在多个程序间共享，所以动态链接使得可执行文件更小，节省了磁盘空间。操作系统采用虚拟内存机制允许物理内存中的一份动态库被要用到该库的所有进程共用，节省了内存和磁盘空间。

2.创建自己的动静态库 

• 库中不能出现main函数

//源文件my_add.c
int Add(int a,int b)
{
	printf("enter Add function %d + %d = ?\n",a,b);
	return a + b;
}

//头文件my_add.h
#pragma once
 
#include <stdio.h>
 
extern int Add(int a,int b);

//main函数文件 main.c
#include "my_add.h"
#include "my_sub.h"

int main()
{    
    int a= Add(20,10);
    printf("%d\n",r);
    return 0;
}

//以前我们直接 gcc -o math main.c my_add.c 生成可执行文件math

1. 利用gcc -o my_add.c，生成二进制文件my_add.o(可重定位目标二进制文件)。
2. 利用gcc -o main.c，生成二进制文件main.o(可重定位目标二进制文件)。
3. 这时候就可以使用，gcc -o mymath main.o my_add.o,直接生成可执行文件mymyth
4. 不需要main函数，mv main.c main.o,保留my_add.o文件
5. 这时候，如果有人想用你代码，不想给他看，直接给他.o和.h文件就行
6. 直接利用main.c 和my_add.h my_add.o就可以生成.o文件
7. 直接利用生成的.o文件生成可执行文件

结论：如果我们不想给对方我们的源代码，我给你提供我们的.o可重定位目标二进制文件，让你来用你的代码进行链接就行!未来我可以给对方提供.o(方法的实现)，.h(都有什么方法)--------》库的本质就是：.o文件的集合

这时候，我们就尝试将所有的“.o文件”，打一个包，提供给对方一个库文件即可！

库文件，多个.o----》成一个文件 ------》整个文件就称为库------》所采用的打包工具和打包方式不同称为动静态库

2.1静态库与静态链接

2.1.1生成静态库（.a）

1.创建Makefile文件,然后make

libmymath.a:my_add.o my_sub.o   //libmymath.a它的库名叫mymath,lib是前缀，.a是后缀
    ar -rc $@ $^            //ar代表归档archivear是gnu归档工具
                                //rc表示(replace and create)
my_add.o:my_add.c
    gcc -c my_add.c -o my_add.o
my_sub.o:my_sub.c
    gcc -c my_sub.c -o my_sub.o
.PHONY:clean
clean:
    rm -f *.o libmymath.a

ar 参数：

c 禁止在创建库时产生的正常消息

r 如果指定的文件已经存在于库中，则替换它

s 无论 ar 命令是否修改了库内容都强制重新生成库符号表

v 将建立新库的详细的逐个文件的描述写至标准输出

q 将指定的文件添加到库的末尾

t 将库的目录写至标准输出

ar -rsv linbxxxxx.a xxxxx.o //创建静态库

ar -t libmymath.a //查看库文件是那个文件产生的

 2.使用库文件，还要加上对应的头文件

在Makefile 中增加发布,然后make output

.PHONY:output
output:
    mkdir -p mylib/include
    mkdir -p mylib/lib
    cp -f *.a mylib/lib
    cp -f *.h mylib/include

3.查看生成好的库文件tree mylib

 

---

4.将库文件进行压缩 tar -czf mylib.tgz mylib

可以将压缩包放到网上让人下载使用

下载安装的本质就是将头文件移动到/usr/include/下面 将库移动到/lib64下

5.进行编译

gcc在找头文件的时候默认在当前目录下找和系统默认头目录下找

可以在gcc -o mymath main.c -I ./mylib/include

gcc -o mymath main.c -I（空格可有可无）./mylib/include   
//-I 可以指定头文件的路径

gcc在找库文件的时候默认在当前目录下找和系统默认库目录下找

可以在gcc -o mymath main.c -I ./mylib/include -L ./mylib/lib

gcc -o mymath main.c -I ./mylib/include  -L（空格可有可无） ./mylib/lib  
//-L 可以指定库文件的路径

如果要连接库，必须指明库的名称（路径下的哪一个库）

为什么以前没有用过指明库名称呢？因为使用的g++/gcc是标准库，会自动帮你链接到，但是如果使用别的库，必须指明

可以在gcc -o mymath main.c -I ./mylib/include -L ./mylib/lib -l mymath

gcc -o mymath main.c -I ./mylib/include  -L ./mylib/lib -l（空格可有可无）mymath
//-l 可以指定使用的库（必须去掉前缀和后缀，只要库名）

6.形成可执行程序

ldd 可执行程序名 //查看可执行程序的链接属性

一个可执行程序，可能不依赖一个库 （gcc默认是动态链接，建议行为），

究竟是动态链接还是静态链接，取决与你使用的库是静态还是动态，

动静态库都有时，取决于gcc的选择

当有一个库是动态链接的时候，就是动态链接

就算已经将头文件移动到 usr/include/下面 将库移动到 /lib64下，也要指定要用的库

gcc mymyth main.c -l mymath

2.1.2生成动态库（.so）

1. 生成.o文件（多一个选项-fPIC）

gcc -c -fPIC my_add.c -o my_add.o
gcc -c -fPIC my_sub.c -o my_sub.o
//比静态库多一个选项-fPIC(产生位置无关码)

2.打包(可以直接用gcc -shared)

gcc -shared -o libmymath.so my_add.o my_subb.o

3.使用动态库

先mv libmymath.so mylib/lib

cp *.h mylib/include

编译

gcc -o mymath main.c -I mylinb/include -L mylib/lib -l math（跟静态库一样）

gcc -o mymath main.c -I ./mylib/include -L ./mylib/lib -l mymath

但是可执行程序无法执行

动态库找不到了？已经给gcc说了库文件和头文件的路径了，还有用那个库，

但是当已经不编译结束了的时候，已经和gcc没有关系了

程序运行的时候，OS和shell也要知道库在哪里？

使用的库没有在系统路径下。

解决办法

1. 直接将库安装到系统目录下（拷贝）
2. OS会到环境变量中找。

   LD_LIBRARY_PATH:动态库加载路径

   将使用的库的路径添加到该路径下面

   export LD_LIBRARY_PATH:$LD_LIBRARY_PATH:/home/xxx/xxx/mylib/lib

   这样的方法只能在当前登陆时间有效，退出去 ，就会失效

   或者加到~/.bashrc中

3. 修改配置文件，在系统目录下存在/etc/ld.so.conf.d这个目录下放 的就是配置文件，系需要创建一个.conf的文件，将动态库的路径写进去就可以了，然后更新一下 sudo ldconfig
4. 在当前路径下进行一个软连接

   ln -s /xxx/xx/x/mylib/lib/libmymath.so libmymath.so
   

5. 在/lib64路径下进行一个软连接

   ln -s /xxx/xx/x/mylib/lib/libmymath.so lib64/libmymath.so
   

2.2动静态库的加载理解

2.2.1静态库的加载

静态库不考虑加载。

就像我们写的代码一样，，将库中的函数代码拷贝到我们写的代码中，被拷贝的代码方式必须按照预定好的地址从全0到ffff，进行代码区的编译，这种就是绝对编译

加载到内存里面，进行执行

2.2.2动态库的加载

这有一个100米跑道，我在50 米的位置，在跑道30 米的位置有一颗树，我的位置可以表示为在跑道50 米的位置，也可以表示为树前20米的位置，但是当这个跑道延长到200米的时候，我还能说在树前20米的位置。这就是与位置无关，利用相对位置定位。

以printf函数为例。

编译过程，动态库中指定函数的地址（距离该动态库起始地址的偏移量），写到我们的可执行程序中。在执行的时候，程序被加载到内存，PCB开始执行该可执行程序，执行代码区中的代码，当执行到动态库中的函数的时候，会停止执行，开始找这个函数在那个库中，将这个库加载到内存，通过页表映射到共享区，就知道这个库的起始地址，然后通过偏移量进行读取printf的偏移量，找到printf在共享区的位置，进行调用执行，结束后返回，继续执行下面的代码

3.软硬链接

ln -s myfile.txt soft_file.link

ln----link，链接
-s----soft，软链接
myfile.txt----原文件
soft_file.link----创建的软连接文件

ln myfile.txt hard_file.link
hard_file.link----创建的硬连接文件

3.1.软硬链接的区别

软链接具有独立的inode,可以被当作独立文件看待

硬链接没有独立的inode

3.2.创建硬链接，硬链接做了什么

硬链接的文件属性，所属组，权限，内容与原文件一模一样。

• 建立硬链接，根本没有创建新文件，因为没有给硬链接分配独立的inode
• 既然没有创建文件，那么你一定没有自己的属性集合和内容集合
• 你用的一定是别人的inode和内容

在lesson21目录下面给myfile.txt创建一个硬链接hard_file.link，本质就是在目录文件的数据块中写下硬链接的文件名与原文件myfile.txt的inode的映射关系。

再对inode属性中对引用计数，进行加一。

所以在对具有硬链接的文件进行删除的时候，要看引用计数是否为0，若为0，则这个文件才被彻底删除。

相对的软连接(相当于windows下的快捷方式)，是将文件名进行了保存，通过文件的路径来找到原文件。

3.3.软连接的作用

快速找到文件和所用的库和可执行程序

ln -s /mumu/xxx/xxx/xxx/xxx/hello hello
直接在当前目录下创建可执行程序hello,方便执行

3.4硬链接的作用

创建普通文件的硬链接的引用计数为1，创建目录的引用计数为2.

一个普通文件本来就有一个文件名和inode的映射关系

目录文件有两个，会有.(一个点代表当前目录)

当在empty文件下再创建一个文件夹dir。他就会变成3，这是因为在dir目录下的..（两个点代表，上及目录empty）

Linux为什么不让给目录做硬链接？（软连接可以）

• 硬链接指向的是文件的 inode，而 inode 本身包含文件元数据。如果允许为目录创建硬链接，可能导致目录形成循环结构。例如，目录 A 可以通过硬链接指向目录 B，而目录 B 又通过硬链接指向目录 A，这会导致文件系统陷入无限循环，破坏文件系统的完整性。
• 软链接不直接引用 inode，而是存储路径信息，因此不会影响文件系统的结构。软链接只是一个普通文件，用户可以通过它访问其他文件或目录，系统在访问软链接时会自动解析路径，所以不会导致硬链接的问题。