Linux笔记---动静态库（使用篇）

[1. 库的概念](#1. 库的概念)

[2. 静态库（Static Libraries）](#2. 静态库（Static Libraries）)

[2.1 静态库的制作](#2.1 静态库的制作)

[2.2 静态库的使用](#2.2 静态库的使用)

[2.2.1 显式指定库文件及头文件路径](#2.2.1 显式指定库文件及头文件路径)

[2.2.2 将库文件安装到系统目录](#2.2.2 将库文件安装到系统目录)

[2.2.3 将头文件安装到系统目录](#2.2.3 将头文件安装到系统目录)

[3. 动态库](#3. 动态库)

[3.1 动态库的制作](#3.1 动态库的制作)

[3.2 动态库的使用](#3.2 动态库的使用)

[3.2.1 显式指定库文件路径](#3.2.1 显式指定库文件路径)

[2.2.2 将路径加载到环境变量中](#2.2.2 将路径加载到环境变量中)

[2.2.3 配置文件](#2.2.3 配置文件)

[4. 总结与补充](#4. 总结与补充)

1. 库的概念

库（Library）是一组预先编译好的代码（函数、类、数据等）的集合，可以被多个程序共享和重复使用。库的核心目的是代码复用，避免开发者重复编写相同的功能（如文件操作、数学计算等）。

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

按照代码复用的形式，库可以分为两种：

静态库：.a [Linux]、.lib [Windows]

动态库：.so [Linux]、.dll [Windows]

库是在链接这一步被使用的，实际上就是一堆 .o 文件的集合，我们可以特定的工具来将这些 .o 文件进行打包，进而形成库。

为举例方便，这里给出我们自己实现的简单的C语言库---myc：

cpp 复制代码

// mystdio.h

#pragma once
#include <stdio.h>
#define MAX 1024
#define NONE_FLUSH (1<<0)
#define LINE_FLUSH (1<<1)
#define FULL_FLUSH (1<<2)

typedef struct IO_FILE
{
    int fileno;
    int flag;
    char outbuffer[MAX];
    int bufferlen;
    int flush_method;
}MyFile;


MyFile *MyFopen(const char *path, const char *mode);
void MyFclose(MyFile *);
int MyFwrite(MyFile *, void *str, int len);
void MyFFlush(MyFile *);



// mystdio.c

#include "mystdio.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

static MyFile *BuyFile(int fd, int flag)
{
    MyFile *f = (MyFile*)malloc(sizeof(MyFile));
    if(f == NULL) return NULL;
    f->bufferlen = 0;
    f->fileno = fd;
    f->flag = flag;
    f->flush_method = LINE_FLUSH;
    memset(f->outbuffer, 0, sizeof(f->outbuffer));
    return f;
}

MyFile *MyFopen(const char *path, const char *mode)
{
    int fd = -1;
    int flag = 0;
    if(strcmp(mode, "w") == 0)
    {
        flag = O_CREAT | O_WRONLY | O_TRUNC;
        fd = open(path, flag, 0666);
    }
    else if(strcmp(mode, "a") == 0)
    {
        flag = O_CREAT | O_WRONLY | O_APPEND;
        fd = open(path, flag, 0666);
    }
    else if(strcmp(mode, "r") == 0)
    {
        flag = O_RDWR;
        fd = open(path, flag);
    }
    else
    {
        //TODO
    }
    if(fd < 0) return NULL;
    return BuyFile(fd, flag);
}
void MyFclose(MyFile *file)
{
    if(file->fileno < 0) return;
    MyFFlush(file);
    close(file->fileno);
    free(file);
}
int MyFwrite(MyFile *file, void *str, int len)
{
    // 1. 拷贝
    memcpy(file->outbuffer+file->bufferlen, str, len);
    file->bufferlen += len;
    // 2. 尝试判断是否满足刷新条件！
    if((file->flush_method & LINE_FLUSH) && file->outbuffer[file->bufferlen-1] == '\n')
    {
        MyFFlush(file);
    }
    return 0;
}
void MyFFlush(MyFile *file)
{
    if(file->bufferlen <= 0) return;
    // 把数据从用户拷贝到内核文件缓冲区中
    int n = write(file->fileno, file->outbuffer, file->bufferlen);
    (void)n;
    fsync(file->fileno);
    file->bufferlen = 0;
}



// mystring.h

#pragma once
int my_strlen(const char *s);



// mystring.c

#include "mystring.h"

int my_strlen(const char *s)
{
    const char *start = s;
    while(*s)
    {
        s++;
    }
    return s - start;
}

接下来，我们会介绍如何将上述的原文件打包成动静态库并使用。

2. 静态库（Static Libraries）

文件扩展名：.a（Archive）

特点：

在编译时，库的代码会被直接复制到最终的可执行文件中。

生成的可执行文件独立，不依赖运行时环境中的库文件。

缺点：文件体积较大，且更新库时需要重新编译程序。

**创建工具：**ar（归档工具）+ ranlib（生成索引）。

**使用场景：**适合对程序独立性要求高的场景。

2.1 静态库的制作

静态库使用 ar 指令进行打包：

bash 复制代码

ar -rc lib[库名].a [目标文件s]

lib[库名].a 是静态库文件的命名规范，实际上的库名需要去掉lib前缀以及.a扩展名。

通常来说，只有库文件是不够的，还需要将库的头文件交给用户，所以我们可以使用如下的Makefile来将库及其头文件一起打包交给用户：

bash 复制代码

SRC=$(wildcard *.c)
OBJ=$(SRC:.c=.o)

libmyc.a:$(OBJ)
	ar -rc $@ $^

$(OBJ):$(SRC)
	gcc -c $^

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

.PHONY:clean
clean:
	rm -rf *.o libmyc.a lib lib.tgz

2.2 静态库的使用

gcc/g++会默认链接c标准库，但是myc库是我们自己制作的第三方库，所以在编译时需要指定链接myc库。

假设用户已经接收到了我们的 lib.tgz 包，并且用户的代码(usercode.c)调用了我们库中的方法：

注：使用tar xzf lib.tgz进行解包得到lib目录。

cpp 复制代码

// usercode.c

#include "mystdio.h"
#include "mystring.h"
#include <string.h>
#include <unistd.h>

int main()
{
    MyFile *filep = MyFopen("./log.txt", "a");
    if(!filep)
    {
        printf("fopen error!\n");
        return 1;
    }

    int cnt = 10;
    while(cnt--)
    {
        char *msg = (char*)"hello myfile!!!";
        MyFwrite(filep, msg, strlen(msg));
        MyFFlush(filep);
        printf("buffer: %s\n", filep->outbuffer);
        sleep(1);
    }
    MyFclose(filep); // FILE *fp

    const char *str = "hello bit!\n";
    printf("strlen: %d\n",my_strlen(str));
    return 0;
}

2.2.1 显式指定库文件及头文件路径

在编译时，需要指定头文件所在路径、要链接的库文件路径以及指定库文件：

bash 复制代码

gcc -o [可执行程序] [目标文件s] -I [头文件路径] -L [库路径] -l [库名]

2.2.2 将库文件安装到系统目录

我们知道，所谓安装，实际上就是把文件拷贝到指定的系统目录下。这样，在我们未显式指定库文件所在目录时，系统就能够在默认目录中找到。

当然，除了拷贝，建立链接也是可以的。

/lib 、/usr/lib：系统级库

/usr/local/lib：用户安装的第三方库

我们将 libmyc.a 文件拷贝到三个库中的一个即可完成安装，此时不在需要指明库所在路径：

但是，不建议安装到系统级库，用户自己要安装的第三方库最好安装到 /usr/local/lib 中。

2.2.3 将头文件安装到系统目录

/usr/include：系统级头文件

/usr/local/include：本地安装的第三方库头文件

/usr/include/<库名> 或 /usr/local/include/<库名>：特定软件的子目录

我们将自己的头文件拷贝到上述目录下即可完成安装，此时不再需要指明头文件所在路径：

3. 动态库

文件扩展名：.so（Shared Object）

特点：

在程序运行时被动态加载到内存，多个程序可共享同一份库代码。

可执行文件体积小，库更新时无需重新编译程序。

缺点：依赖运行时环境中的库文件（若缺失会导致程序无法运行）。

**创建工具：**gcc/g++ 的 -shared 选项。

**使用场景：**大多数系统库（如 glibc）和通用功能库（如 OpenSSL）。

3.1 动态库的制作

bash 复制代码

// 编译目标文件时需要带上-fPIC选项，fPIC：产生位置无关码(position independent code) 
gcc/g++ -c -fPIC [原文件s]

// 生成库文件时需要带上-shared选项，shared: 表示生成共享库格式 
gcc/g++ -o lib[库名].so [目标文件s] -shared

同样的，lib[库名].so 是命名规范，实际上的库名需要去掉lib前缀和 .so扩展名。

我们可以使用如下的Makefile来对库及其头文件进行打包：

bash 复制代码

SRC=$(wildcard *.c)
OBJ=$(SRC:.c=.o)

libmyc.so:$(OBJ)
	gcc -shared -o $@ $^

$(OBJ):$(SRC)
	gcc -fPIC -c $^

.PHONY:output
output:
	mkdir -p lib/include
	mkdir -p lib/mylib
	cp -f *.h lib/include
	cp -f *.so lib/mylib
	tar czf lib.tgz lib

.PHONY:clean
clean:
	rm -rf *.o libmyc.so lib lib.tgz

3.2 动态库的使用

我们以同样的代码作为示例，将库及头文件安装到系统目录的方式与静态库一样，这里就不再重复，但是对于显式给出库文件路径的方式，我们要多说两句。

3.2.1 显式指定库文件路径

假如我们未将库文件安装到系统目录当中，并显式指定某路径下的库文件：

我们会发现编译通过了，但是：

当我们运行生成的可执行程序时，会发现系统显式找不到对应的库。

这是因为，我们仅仅告诉了编译器："这个库是存在的"，所以编译器完成了编译。

但是动态链接是在程序运行时才将库与可执行程序产生链接，负责链接的是系统，然而系统并不知道在哪里找到这个库。

要让操作系统在运行我们的程序时找到对应的动态库，我们可以选择安装的形式（与静态库的安装完全一致），也可采取以下几点中提到的措施。

注意：与静态链接不同，接下来的几点措施（包括安装），都不需要重新编译可执行文件。

2.2.2 将路径加载到环境变量中

bash 复制代码

# LD_LIBRARY_PATH：临时指定额外的库搜索路径。
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/path/to/libs

使用 ldd 命令可以查看可执行程序链接的库及其所在路径：

但是，这种方式只是临时的，重新登录或更新环境变量时就会失效。

2.2.3 配置文件

/etc/ld.so.conf：系统级库路径配置文件

/etc/ld.so.conf.d：用户库路径配置文件目录

我们可以直接在/etc/ld.so.conf中加入我们库文件的路径，但是我们依然更建议在用户库路径配置文件目录中添加自己的配置文件：

这里sudo echo创建文件的方式居然不行，只能用编辑器创建了。

然后加载配置文件：

bash 复制代码

sudo ldconfig

结果与2.2.2相同，这里就不展示了。

4. 总结与补充

gcc/g++编译命令补充：
- $-I\] ：指定头文件所在目录。$
- $-l\]：指定要链接的库。$
- $-fPIC\]：产生位置无关码。$
静态库使用ar命令进行打包：
bash 复制代码
```
ar -rc lib[库名].a [目标文件s]
```
将静态库与用户目标文件一起编译即可生成可执行程序。

动态库使用gcc/g++进行打包，且目标文件需要携带位置无关码：

bash 复制代码

// 编译目标文件时需要带上-fPIC选项，fPIC：产生位置无关码(position independent code) 
gcc/g++ -c -fPIC [原文件s]

// 生成库文件时需要带上-shared选项，shared: 表示生成共享库格式 
gcc/g++ -o lib[库名].so [目标文件s] -shared

动态库在编译时需要让gcc/g++知道这个库是存在的（给出路径或安装到系统，并指定库名）。在运行时，系统需要能够找到这个库（需要安装到系统）。
第三方库在编译时要指定链接这个库。
在编译时，我们的系统当中可能既安装了某个库的动态版本，又安装了某个库的静态版本。此时，编译器默认能采用动态链接则采用动态链接。如果要使用静态链接则需要带上 -static 选项，一旦带上这个选项，就意味着动态链接被禁用，如果某个库只有动态链接的版本，则会发生链接失败。