Linux 静态库与共享库完全指南：从制作到使用

引言

在C语言开发中，我们经常需要重复使用一些通用功能，比如数学计算、字符串处理、文件操作等。如果每次都重新编写这些代码，不仅效率低下，还容易出错。库（Library） 就是解决这个问题的方案------它是预先编译好的方法的集合，使用者只需链接二进制文件，无需关心实现细节。

库分为两种类型：静态库 和共享库（动态库）。今天，我将从底层原理出发，全面讲解两种库的创建、使用、区别以及常见问题解决。

---

第一部分：库的基本概念

一、什么是库？

库是预先编译好的方法（函数）的集合，本质上是二进制文件。它让使用者可以直接链接使用，无需重新编译源代码。

源代码(.c) → 预编译 → 编译 → 汇编 → 目标文件(.o) → 链接 → 可执行文件

↑

库文件(.a/.so)

库的核心价值：

1. 避免重复编译：使用者直接链接二进制文件

2. 保护知识产权：隐藏实现细节，只暴露接口（头文件）

3. 标准化功能：提供通用功能的统一实现

二、库的分类

类型	Linux文件名	Windows文件名	链接时机
静态库	libxxx.a	.lib	编译时
共享库	libxxx.so	.dll	运行时

存储位置：

• 系统库：/lib、/usr/lib、/usr/lib64

• 头文件：/usr/include

• 本地库：/usr/local/lib

---

第二部分：静态库的制作与使用

一、静态库的特点

特性	说明
链接方式	编译时将用到的函数代码拷贝到可执行程序中
运行依赖	程序运行时不再依赖原库文件
文件大小	可执行文件体积较大
内存占用	多个程序运行时重复加载相同代码
更新维护	更新库需要重新编译整个程序
执行速度	快（代码已全部包含）

二、静态库的制作步骤

// add.h
#ifndef ADD_H
#define ADD_H
int add(int x, int y);
#endif

// add.c
#include "add.h"
int add(int x, int y) {
    return x + y;
}

// max.h
#ifndef MAX_H
#define MAX_H
int max(int x, int y);
#endif

// max.c
#include "max.h"
int max(int x, int y) {
    return x > y ? x : y;
}

步骤1：编译源文件为目标文件（.o）

# 将.c文件编译为.o目标文件
gcc -c add.c -o add.o
gcc -c max.c -o max.o

# 或批量编译
gcc -c add.c max.c

步骤2：使用ar命令打包为静态库

**# ar命令参数说明：

c：创建库

r：将方法添加到库中（替换已有成员）

v：显示详细过程**

ar crv libfoo.a add.o max.o

**# 输出：

a - add.o

a - max.o**

静态库命名规范：

• 必须以 lib 开头

• 以 .a 结尾

• 中间为自定义名称（如 foo）

三、静态库的使用

// main.c
#include <stdio.h>
#include "add.h"
#include "max.h"

int main() {
    int a = 10, b = 20;
    printf("%d + %d = %d\n", a, b, add(a, b));
    printf("max(%d, %d) = %d\n", a, b, max(a, b));
    return 0;
}

编译链接：

# 方法1：直接链接.o文件
gcc main.c add.o max.o -o main

**# 方法2：链接静态库

-L. 指定库搜索路径（当前目录）

-lfoo 链接libfoo.a（去掉lib前缀和.a后缀）

gcc main.c -L. -lfoo -o main**

# 方法3：将库放到标准目录后
sudo cp libfoo.a /usr/lib
gcc main.c -lfoo -o main

四、静态库的特性验证

编译后，删除静态库

rm libfoo.a

程序仍然可以运行（代码已拷贝到可执行文件中）

./main

输出：

10 + 20 = 30

max(10, 20) = 20

第三部分：共享库的制作与使用

一、共享库的特点

特性	说明
链接方式	编译时仅标记需要使用的库和方法，运行时动态加载
运行依赖	程序运行时必须能找到对应的共享库文件
文件大小	可执行文件体积小
内存占用	多个程序共享同一份库代码
更新维护	只需替换库文件，无需重新编译程序
别称	Windows中称为DLL（动态链接库）

二、共享库的制作步骤

步骤1：编译位置无关代码（PIC）

**# -fPIC：生成位置无关代码（Position Independent Code）

这是共享库的必要条件

gcc -c -fPIC add.c -o add.o
gcc -c -fPIC max.c -o max.o**

# 或批量编译
gcc -c -fPIC add.c max.c

步骤2：创建共享库

**# -shared：生成共享库

-fPIC：位置无关代码（已在编译时指定）

-o：指定输出文件名

gcc -shared -fPIC -o libfoo.so add.o max.o**

# 或直接一步完成
gcc -shared -fPIC -o libfoo.so add.c max.c

共享库命名规范：

• 必须以 lib 开头

• 以 .so 结尾

• 中间为自定义名称（如 foo）

三、共享库的使用

// main.c（与静态库使用相同）
#include <stdio.h>
#include "add.h"
#include "max.h"

int main() {
    int a = 10, b = 20;
    printf("%d + %d = %d\n", a, b, add(a, b));
    printf("max(%d, %d) = %d\n", a, b, max(a, b));
    return 0;
}

编译链接：

# 编译时指定库路径和库名
gcc main.c -L. -lfoo -o main

**# 编译成功，但运行时可能报错！
./main

error while loading shared libraries: libfoo.so: cannot open shared object file: No such file or directory**

四、解决共享库运行时找不到的问题

原因： 系统默认只在标准目录（/lib、/usr/lib）查找共享库。

解决方法1：将库移动到标准目录

**sudo cp libfoo.so /usr/lib

或

sudo mv libfoo.so /lib**

./main # 现在可以正常运行

解决方法2：设置LD_LIBRARY_PATH环境变量

# 设置当前目录为库搜索路径
export LD_LIBRARY_PATH=.

# 运行程序
./main

**# 使用ldd查看库依赖
ldd ./main

libfoo.so => ./libfoo.so (0x...)**

解决方法3：在编译时指定rpath

# -Wl,-rpath,. 将当前目录写入可执行文件的库搜索路径
gcc main.c -L. -lfoo -Wl,-rpath,. -o main

./main # 无需设置环境变量即可运行

五、共享库的特性验证

# 编译后，删除共享库
rm libfoo.so

# 程序无法运行！
./main
# error while loading shared libraries: libfoo.so: cannot open shared object file: No such file or directory

第四部分：静态库与共享库的区别总结

一、核心区别对比表

对比项	静态库（.a）	共享库（.so）
链接时机	编译时	运行时
代码包含	拷贝到可执行文件	仅做使用标记
文件体积	大	小
运行依赖	不依赖原库	必须依赖原库
内存占用	每个程序一份	多个程序共享一份
更新维护	需重新编译程序	只需替换库文件
执行速度	快	稍慢（动态加载开销）
命名格式	libxxx.a	libxxx.so

二、链接过程对比

三、常用命令总结

命令	作用
ar crv libfoo.a add.o max.o	创建静态库
gcc -c -fPIC add.c	编译位置无关代码
gcc -shared -fPIC -o libfoo.so add.o max.o	创建共享库
gcc main.c -L. -lfoo -o main	链接库文件
ldd ./main	查看程序依赖的共享库
nm libfoo.a	查看静态库符号表
export LD_LIBRARY_PATH=.	设置共享库搜索路径

---

第五部分：缓冲区机制与printf

一、为什么需要缓冲区？

printf 的输出不会立即显示在屏幕上，而是先存入缓冲区。这是为了减少用户态到内核态的频繁切换，提高I/O效率

二、缓冲区的刷新时机

刷新方式	触发条件	示例
缓冲区满	缓冲区容量达到上限	默认缓冲区大小通常为4KB
强制刷新	\n 或 fflush(stdout)	printf("hello\n")
程序正常结束	exit(0) 会刷新缓冲区	exit(0)

三、exit 与 _exit 的区别

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    printf("Hello, World!");  // 没有\n，不刷新缓冲区
    
    // exit(0);   // 会刷新缓冲区，输出 "Hello, World!"
    _exit(0);     // 不会刷新缓冲区，不输出任何内容
    
    return 0;
}

函数	缓冲区刷新	清理操作
exit(0)	✅ 会刷新	执行标准清理（调用atexit等）
_exit(0)	❌ 不刷新	立即终止，不执行清理

四、fflush 函数

#include <stdio.h>

int main() {
    printf("Processing...");
    
    // 强制刷新缓冲区，立即显示输出
    fflush(stdout);
    
    sleep(2);  // 模拟耗时操作
    printf("Done!\n");
    
    return 0;
}

函数原型： int fflush(FILE *stream)

使用场景：

• 需要立即显示输出内容时

• 程序可能异常终止前

• 长时间运行中的关键信息输出

注意事项： 频繁调用 fflush 会影响性能

---

第六部分：库文件管理常用命令

一、查看依赖库（ldd）

查看可执行程序依赖的共享库

ldd ./main

输出示例：

linux-vdso.so.1 (0x00007ffd...)

libfoo.so => ./libfoo.so (0x00007f...)

libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f...)

二、查看库符号（nm）

查看静态库中的符号

nm libfoo.a

输出：

add.o:

0000000000000000 T add

max.o:

0000000000000000 T max

查看共享库中的符号

nm -D libfoo.so

三、查看文件类型（file）

file libfoo.a

libfoo.a: current ar archive

file libfoo.so

libfoo.so: ELF 64-bit LSB shared object, x86-64...

file main

main: ELF 64-bit LSB executable, x86-64...

第七部分：总结

一、静态库 vs 共享库速查表

对比项	静态库	共享库
创建命令	ar crv libxxx.a *.o	gcc -shared -fPIC -o libxxx.so *.o
编译选项	无特殊要求	需要 -fPIC
链接时机	编译时	运行时
运行依赖	不需要库文件	需要库文件
更新方式	重新编译程序	替换库文件即可
文件大小	大	小
内存占用	高	低

二、常见问题解决

问题	原因	解决方案
undefined reference to 'xxx'	未链接正确的库	添加 -l 参数
cannot find -lxxx	找不到库文件	使用 -L 指定路径
error while loading shared libraries	运行时找不到共享库	设置 LD_LIBRARY_PATH 或安装到标准目录

静态库和共享库是C/C++开发中不可或缺的工具。理解它们的区别和使用方法，能够帮助你更好地管理项目依赖、优化程序体积和部署效率。

学习建议：

1. 开发阶段使用共享库（方便更新调试）

2. 发布阶段可根据需求选择静态库（便于部署）或共享库（节省空间）

3. 使用 ldd 检查程序依赖，确保运行时库文件可被找到