动静态库原理与实战详解

目录

一、什么是库？

1、库主要分为两种类型：

2、Ubuntu系统中的动静态库示例

C语言库：

C++库：

3、CentOS系统中的动静态库示例

C语言库：

C++库：

二、动静态库的基本原理

三、认识动静态库

四、静态库

1、静态库的特点

2、静态库的创建

1. 准备示例文件

2. 创建静态库

步骤1：编译源文件为目标文件(.o)

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

（可选）查看静态库内容

3、使用静态库

编译并链接静态库

运行程序

4、添加更多功能到静态库

5、使用更新后的静态库

6、静态库的三种使用场景

准备工作：创建一个干净的工作目录

场景1：链接系统标准库（模拟）

1. 创建示例文件

2. 编译链接

3. 运行程序

场景2：链接当前目录的自定义库

1. 创建文件

2. 创建静态库

3. 编译链接

4. 运行程序

场景3：指定头文件和库文件路径

1. 创建目录结构

2. 移动文件到指定位置

3. 更新main.c位置

4. 编译链接

5. 运行程序

验证静态库独立性

关键命令总结

编译选项说明

静态库的打包与使用

打包

第一步：让所有源文件生成对应的目标文件

第二步：使用ar命令将所有目标文件打包为静态库

第三步：将头文件和生成的静态库组织起来

使用Makefile

使用

方法一：使用选项

方法二：把头文件和库文件拷贝到系统路径下

为什么之前使用gcc编译的时候没有指明过库名字？

扩展：

（1）删除头文件

（2）删除静态库

五、动态库

1、动态库基本概念

动态库的特点

动态库文件扩展名

2、动态库的打包与使用

打包

第一步：让所有源文件生成对应的目标文件

总结要点：

核心结论：

关于上面知识的补充：

1、什么是 "使用相对地址而非绝对地址"？

2、为什么共享库（.so）需要相对地址？

3、什么是 "代码重定位"？

第二步：使用-shared选项将所有目标文件打包为动态库

第三步：将头文件和生成的动态库组织起来

使用Makefile

使用

可能的原因（我认为最有可能是Linux 发行版的问题）

方法一：拷贝.so文件到系统共享库路径下

方法二：更改LD_LIBRARY_PATH

方法三：配置/etc/ld.so.conf.d/

3、动态库管理工具

1. ldd - 查看程序依赖的动态库

2. ldconfig - 管理共享库缓存

3. nm - 查看库中的符号

4. objdump - 查看库信息

动态库搜索路径

六、动静态库知识总结归纳

1、​​默认链接方式​​

2、​​Linux库安装特性​​

3、​​库与应用程序关系​​

4、​​VS编译器的能力​​

七、Linux中动静态库的区别和联系

1、核心区别

2、工作原理

1. 静态库

2. 动态库

3、关键联系

4、实际应用场景

5、验证工具

6、注意事项

八、使用外部库 - 课后实践

安装方法

示例代码

一、什么是库？

        库是由预先编写好、经过验证且可复用的代码组成的集合。在实际开发中，大多数程序都需要依赖基础库的支持，因此库的存在极大地提高了开发效率。本质上，库是以二进制形式存在的可执行代码，能够被操作系统直接加载到内存中运行。

1、库主要分为两种类型：

• 静态库：在Linux系统中以.a为后缀，Windows系统中则是.lib
• 动态库：在Linux系统中以.so为后缀，Windows系统中则是.dll

2、Ubuntu系统中的动静态库示例

C语言库：

$ ls -l /lib/x86_64-linux-gnu/libc-2.31.so
-rwxr-xr-x 1 root root 2029592 May  1 02:20 /lib/x86_64-linux-gnu/libc-2.31.so$ ls -l /lib/x86_64-linux-gnu/libc.a
-rw-r--r-- 1 root root 5747594 May  1 02:20 /lib/x86_64-linux-gnu/libc.a

C++库：

$ ls /usr/lib/gcc/x86_64-linux-gnu/9/libstdc++.so -l
lrwxrwxrwx 1 root root 40 Oct 24  2022 /usr/lib/gcc/x86_64-linux-gnu/9/libstdc++.so -> ../../../x86_64-linux-gnu/libstdc++.so.6$ ls /usr/lib/gcc/x86_64-linux-gnu/9/libstdc++.a
/usr/lib/gcc/x86_64-linux-gnu/9/libstdc++.a

3、CentOS系统中的动静态库示例

C语言库：

$ ls /lib64/libc-2.17.so -l
-rwxr-xr-x 1 root root 2156592 Jun  4 23:05 /lib64/libc-2.17.so$ ls /lib64/libc.a -l
-rw-r--r-- 1 root root 5105516 Jun  4 23:05 /lib64/libc.a

C++库：

$ ls /lib64/libstdc++.so.6 -l
lrwxrwxrwx 1 root root 19 Sep 18 20:59 /lib64/libstdc++.so.6 -> libstdc++.so.6.0.19$ ls /usr/lib/gcc/x86_64-redhat-linux/4.8.2/libstdc++.a -l
-rw-r--r-- 1 root root 2932366 Sep 30  2020 /usr/lib/gcc/x86_64-redhat-linux/4.8.2/libstdc++.a

二、动静态库的基本原理

动静态库的本质是可执行程序的“半成品”。

我们都知道，一堆源文件和头文件最终变成一个可执行程序需要经历以下四个步骤：

• 预处理： 完成头文件展开、去注释、宏替换、条件编译等，最终形成xxx.i文件。
• 编译： 完成词法分析、语法分析、语义分析、符号汇总等，检查无误后将代码翻译成汇编指令，最终形成xxx.s文件。
• 汇编： 将汇编指令转换成二进制指令，最终形成xxx.o文件。
• 链接： 将生成的各个xxx.o文件进行链接，最终形成可执行程序。

        例如，用test1.c、test2.c、test3.c、test4.c以及main1.c形成可执行文件，我们需要先得到各个文件的目标文件test1.o、test2.o、test3.o、test4.o以及main1.o，然后再将这写目标文件链接起来，最终形成一个可执行程序。

        如果我们在另一个项目当中也需要用到test1.c、test2.c、test3.c、test4.c和项目的main2.c或者main3.c分别形成可执行程序，那么可执行程序生成的步骤也是一样的。 

        而实际上，对于可能频繁用到的源文件，比如这里的test1.c、test2.c、test3.c、test4.c，我们可以将它们的目标文件test1.o、test2.o、test3.o、test4.o进行打包，之后需要用到这四个目标文件时就可以之间链接这个包当中的目标文件了，而这个包实际上就可以称之为一个库。

        实际上，所有库本质都是一堆目标文件(xxx.o)的集合，库的文件当中并不包含主函数而只是包含了大量的方法以供调用，所以说动静态库本质是可执行程序的“半成品”。 

三、认识动静态库

在Linux下创建文件编写以下代码，并生成可执行程序。

#include <stdio.h>int main()
{printf("hello world\n"); //库函数return 0;
}

这是最简单的代码，运行结果大家也都知道，就是hello world。

下面我们就通过这份简单的代码来认识一下动静态库

        在这份代码当中我们可以通过调用printf输出hello world，主要原因是gcc编译器在生成可执行程序时，将C标准库也链接进来了。

在Linux下，我们可以通过ldd 文件名来查看一个可执行程序所依赖的库文件。

        这其中的libc.so.6就是该可执行程序所依赖的库文件，我们通过ls命令可以发现libc.so.6实际上只是一个软链接。 

        实际上该软链接的源文件libc-2.17.so和libc.so.6在同一个目录下，为了进一步了解，我们可以通过file 文件名命令来查看libc-2.17.so的文件类型。

        此时我们可以看到，libc-2.17.so实际上就是一个共享的目标文件库，准确来说，这还是一个动态库。

• 在Linux当中，以.so为后缀的是动态库，以.a为后缀的是静态库。
• 在Windows当中，以.dll为后缀的是动态库，以.lib为后缀的是静态库。

        这里可执行程序所依赖的libc.so.6实际上就是C动态库，当我们去掉一个动静态库的前缀lib，再去掉后缀.so或者.a及其后面的版本号，剩下的就是这个库的名字。

而gcc/g++编译器默认都是动态链接的，若想进行静态链接，可以携带一个-static选项。

gcc -o mytest-s mytest.c -static

        此时生成的可执行程序就是静态链接的了，可以明显发现静态链接生成的可执行程序的文件大小，比动态链接生成的可执行程序的文件大小要大得多。

        静态链接生成的可执行程序并不依赖其他库文件，此时当我们使用ldd 文件名命令查看该可执行程序所依赖的库文件时就会看到以下信息。

        此外，当我们分别查看动静态链接生成的可执行程序的文件类型时，也可以看到它们分别是动态链接和静态链接的。 

四、静态库

        在 Linux 系统中，静态库（Static Library）是一种在编译时将库代码直接嵌入到可执行文件中的库类型。它与动态库（动态链接）不同，静态库会成为程序的一部分，因此生成的可执行文件无需依赖外部库文件即可运行。

1、静态库的特点

• 文件扩展名：.a（Archive，归档文件），例如 libmath.a。

• 编译行为：在链接阶段，静态库的代码会被完整地复制到最终的可执行文件中。

• 运行时行为：程序运行时不需要外部的 .so 文件，因为所有依赖的库代码已经包含在可执行文件里。

• 优点：

  • 独立性：程序不依赖系统环境，适合嵌入式开发或需要独立分发的场景。

  • 性能略高：由于库代码已经嵌入，无需动态加载，启动速度稍快。

• 缺点：

  • 可执行文件体积较大（因为库代码被完整复制）。

  • 更新库需要重新编译程序（如果库有更新，必须重新链接）。

  • 内存占用较高（如果多个程序使用同一个静态库，每个程序都会在内存中保存一份副本）。

• 可执行程序可能使用多个库，这些库可能是静态库或动态库。默认情况下，编译器优先链接动态库(.so)，仅当找不到同名动态库时才会使用静态库。可通过gcc的-static选项强制使用静态链接。

2、静态库的创建

静态库本质上是多个目标文件（.o 文件）的归档集合，使用 ar（archive）命令打包生成。

1. 准备示例文件

首先，我们创建两个简单的源文件：

math_functions.c (我们的库源文件):

int add(int a, int b) {return a + b;
}int subtract(int a, int b) {return a - b;
}

math_functions.h (库的头文件):

#ifndef MATH_FUNCTIONS_H
#define MATH_FUNCTIONS_Hint add(int a, int b);
int subtract(int a, int b);#endif

main.c (使用库的程序):

#include <stdio.h>
#include "math_functions.h"int main() {printf("2 + 3 = %d\n", add(2, 3));printf("5 - 3 = %d\n", subtract(5, 3));return 0;
}

2. 创建静态库

步骤1：编译源文件为目标文件(.o)

gcc -c math_functions.c -o math_functions.o

解释：

• -c 表示只编译不链接

• -o math_functions.o 指定输出文件名

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

ar rcs libmath.a math_functions.o

解释：

• ar 是GNU归档工具

• rcs 参数：

  • r：替换已存在的文件

  • c：创建库（如果不存在）

  • s：写入索引（加快链接速度）

• libmath.a 是静态库名称（约定以lib开头，.a结尾）

• math_functions.o 是要打包的目标文件

  

（可选）查看静态库内容

ar -vt libmath.a      # 列出库中的目标文件
nm libmath.a         # 查看库中的符号（函数/变量）

• t：列出静态库中的文件
• v：显示详细信息(verbose)

3、使用静态库

编译并链接静态库

gcc main.c -L. -lmath -o myprogram

解释：

• -L.：告诉编译器在当前目录（.）查找库文件

• -lmath：链接libmath.a（-l后接库名，省略lib和.a）

• -o myprogram：生成可执行文件myprogram

运行程序

./myprogram

输出应该为：

4、添加更多功能到静态库

如果你想向库中添加更多功能：

math_functions.c (更新后):

int add(int a, int b) {return a + b;
}int subtract(int a, int b) {return a - b;
}int multiply(int a, int b) {return a * b;
}

更新头文件 math_functions.h:

#ifndef MATH_FUNCTIONS_H
#define MATH_FUNCTIONS_Hint add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);#endif

然后重新编译和更新静态库：

gcc -c math_functions.c -o math_functions.o
ar rcs libmath.a math_functions.o

5、使用更新后的静态库

更新 main.c:

#include <stdio.h>
#include "math_functions.h"int main() {printf("2 + 3 = %d\n", add(2, 3));printf("5 - 3 = %d\n", subtract(5, 3));printf("4 * 3 = %d\n", multiply(4, 3));return 0;
}

重新编译并运行：

gcc main.c -L. -lmath -o myprogram
./myprogram

输出：

6、静态库的三种使用场景

准备工作：创建一个干净的工作目录

mkdir static_lib_demo && cd static_lib_demo

场景1：链接系统标准库（模拟）

1. 创建示例文件

main.c:

#include <stdio.h>
#include <math.h>  // 标准数学库头文件int main() {double x = 4.0;printf("√%.1f = %.2f\n", x, sqrt(x));return 0;
}

2. 编译链接

gcc main.c -lm -o math_demo

说明：

• -lm 链接系统数学库 libm.so（标准库通常已在系统路径中）

• 不需要手动创建这个库，它是系统自带的

3. 运行程序

./math_demo

输出：

场景2：链接当前目录的自定义库

1. 创建文件

math_functions.c:

int add(int a, int b) {return a + b;
}int subtract(int a, int b) {return a - b;
}

math_functions.h:

#ifndef MATH_FUNCTIONS_H
#define MATH_FUNCTIONS_Hint add(int a, int b);
int subtract(int a, int b);#endif

main.c:

#include <stdio.h>
#include "math_functions.h"int main() {printf("2 + 3 = %d\n", add(2, 3));printf("5 - 3 = %d\n", subtract(5, 3));return 0;
}

2. 创建静态库

# 编译为目标文件
gcc -c math_functions.c -o math_functions.o# 创建静态库（命名为libmymath.a）
ar rcs libmymath.a math_functions.o

3. 编译链接

gcc main.c -L. -lmymath -o custom_lib_demo

说明：

• -L. 在当前目录查找库

• -lmymath 链接 libmymath.a

4. 运行程序

./custom_lib_demo

输出：

场景3：指定头文件和库文件路径

1. 创建目录结构

mkdir -p include lib

2. 移动文件到指定位置

mv math_functions.h include/
mv libmymath.a lib/

3. 更新main.c位置

将main.c放在项目根目录下，内容不变。

4. 编译链接

gcc main.c -I./include -L./lib -lmymath -o path_specified_demo

说明：

• -I./include 指定头文件路径

• -L./lib 指定库文件路径

• -lmymath 链接库

5. 运行程序

./path_specified_demo

输出：

验证静态库独立性

# 删除静态库
rm lib/libmymath.a# 程序仍然可以运行
./path_specified_demo

生成可执行文件后，静态库可以删除而不影响程序运行： 

关键命令总结

编译选项说明

• -L: 指定库文件搜索路径
• -I: 指定头文件搜索路径
• -l: 指定链接的库名（去掉前缀lib和后缀.so/.a，如libc.so对应-lc）

经过上面的讲解，我们下面再举一个完整的例子：

静态库的打包与使用

        为了更容易理解，下面演示动静态库的打包与使用时，都以下面的四个文件为例，其中两个源文件add.c和sub.c，两个头文件add.h和sub.h。

add.h当中的内容如下：

#pragma onceextern int my_add(int x, int y);

add.c当中的内容如下： 

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

sub.h当中的内容如下： 

#pragma onceextern int my_sub(int x, int y);

sub.c当中的内容如下：

#include "sub.h"int my_sub(int x, int y)
{return x - y;
}

打包

下面我们就利用这四个文件打包生成一个静态库：

第一步：让所有源文件生成对应的目标文件

第二步：使用ar命令将所有目标文件打包为静态库

        ar命令是GNU的归档工具，常用于将目标文件打包为静态库，下面我们使用ar命令的-r选项和-c选项进行打包。

• r(replace)：若静态库文件当中的目标文件有更新，则用新的目标文件替换旧的目标文件。
• c(create)：建立静态库文件。

ar -rc libcal.a add.o sub.o

此外，我们可以用ar命令的-t选项和-v选项查看静态库当中的文件。

• -t：列出静态库中的文件。
• -v(verbose)：显示详细的信息。

ar -tv libcal.a

第三步：将头文件和生成的静态库组织起来

        当我们把自己的库给别人用的时候，实际上需要给别人两个文件夹，一个文件夹下面放的是一堆头文件的集合，另一个文件夹下面放的是所有的库文件。

        因此，在这里我们可以将add.h和sub.h这两个头文件放到一个名为include的目录下，将生成的静态库文件libcal.a放到一个名为lib的目录下，然后将这两个目录都放到mathlib下，此时就可以将mathlib给别人使用了。

mkdir -p mathlib/include
mkdir -p mathlib/lib
cp ./*.h mathlib/include/
cp ./*.a mathlib/lib
tree mathlib/

使用Makefile

        当然，我们可以将上述所要执行的命令全部写到Makefile当中，后续当我们要生成静态库以及组织头文件和库文件时就可以一步到位了，不至于每次重新生成的时候都要敲这么多命令，这也体现了Makefile的强大。

# 定义变量
mylib = libcal.a
CC = gcc# 编译目标：生成静态库 libcal.a
$(mylib): add.o sub.oar -rc -o $(mylib) $^# 模式规则：编译 .c 文件生成 .o 文件
%.o: %.c$(CC) -c $<# 清理生成的文件
.PHONY: clean
clean:rm -f $(mylib) ./*.o# 输出：将头文件和静态库复制到指定目录
.PHONY: output
output:mkdir -p mathlib/includemkdir -p mathlib/libcp ./*.h mathlib/includecp ./*.a mathlib/lib

编写Makefile后，只需一个make就能生成所有源文件对应的目标文件进而生成静态库。

一个make output就能将头文件和静态库组织起来。

使用

创建源文件main.c，编写下面这段简单的程序来尝试使用我们打包好的静态库。

#include <stdio.h>
#include <add.h>int main()
{int x = 20;int y = 10;int z = my_add(x, y);printf("%d + %d = %d\n", x, y, z);return 0;
}

现在该目录下就有main.c和我们刚才打包好的静态库。 

方法一：使用选项

此时使用gcc编译main.c生成可执行程序时需要携带三个选项：

• -I：指定头文件搜索路径。
• -L：指定库文件搜索路径。
• -l：指明需要链接库文件路径下的哪一个库。

gcc main.c -I./mathlib/include -L./mathlib/lib -lcal

此时就可以成功使用我们自己打包的库文件并生成可执行程序。

说明一下：

• 因为编译器不知道你所包含的头文件add.h在哪里，所以需要指定头文件的搜索路径。
• 因为头文件add.h当中只有my_add函数的声明，并没有该函数的定义，所以还需要指定所要链接库文件的搜索路径。
• 实际中，在库文件的lib目录下可能会有大量的库文件，因此我们需要指明需要链接库文件路径下的哪一个库。库文件名去掉前缀lib，再去掉后缀.so或者.a及其后面的版本号，剩下的就是这个库的名字。
• -I，-L，-l这三个选项后面可以加空格，也可以不加空格。

方法二：把头文件和库文件拷贝到系统路径下

        既然编译器找不到我们的头文件和库文件，那么我们直接将头文件和库文件拷贝到系统路径下不就行了。

sudo cp mathlib/include/* /usr/include/
sudo cp mathlib/lib/libcal.a /lib64/

        需要注意的是，虽然已经将头文件和库文件拷贝到系统路径下，但当我们使用gcc编译main.c生成可执行程序时，还是需要指明需要链接库文件路径下的哪一个库。此时才能成功使用我们自己打包的库文件并生成可执行程序。

为什么之前使用gcc编译的时候没有指明过库名字？

        因为我们使用gcc编译的是C语言，而gcc就是用来编译C程序的，所以gcc编译的时候默认就找的是C库，但此时我们要链接的是哪一个库编译器是不知道的，因此我们还是需要使用-l选项，指明需要链接库文件路径下的哪一个库。

扩展：

        实际上我们拷贝头文件和库文件到系统路径下的过程，就是安装库的过程。但并不推荐将自己写的头文件和库文件拷贝到系统路径下，这样做会对系统文件造成污染，我们要删除它们！！！

（1）删除头文件

sudo rm /usr/include/add.h /usr/include/sub.h  # 替换为实际的头文件名

或删除所有匹配的文件（谨慎使用）：

sudo rm /usr/include/your_lib_*.h  # 使用通配符匹配你的库文件

（2）删除静态库

sudo rm /lib64/libcal.a

五、动态库

        动态库（Dynamic Library），也称为共享库（Shared Library），是 Linux 系统中重要的代码共享机制。与静态库不同，动态库在程序运行时才被加载和链接，而不是在编译时就被打包进可执行文件中。

1、动态库基本概念

动态库的特点

1. 运行时链接：程序运行时才加载

2. 共享性：多个程序可共享同一个库文件

3. 独立性：库更新无需重新编译依赖它的程序

4. 节省空间：磁盘和内存中都只有一份副本

5. 链接机制：与动态库链接的可执行文件仅包含所用函数的入口地址表，而非外部函数的完整机器码。

6. 动态链接：程序运行前，操作系统会将所需函数的机器码从磁盘上的动态库加载到内存中，这一过程称为动态链接（dynamic linking）。

共享优势：

• 节省磁盘空间：多个程序可共享同一动态库，减小可执行文件体积。
• 节省内存空间：操作系统的虚拟内存机制允许不同进程共享物理内存中的同一动态库副本。

动态库文件扩展名

• .so：共享对象文件（Shared Object）

• .so.version：带版本号的共享库文件

        动态库在程序运行时才进行链接，多个程序可以共享同一动态库的代码。与动态库链接的可执行文件仅包含所用函数的入口地址表，而非外部函数的完整机器码。

        程序运行前，操作系统会将所需外部函数的机器码从磁盘上的动态库加载到内存中，这一过程称为动态链接。动态库可实现多程序共享，有效节省磁盘空间。操作系统通过虚拟内存机制，使物理内存中的同一份动态库能被多个进程共用，从而节省内存和磁盘空间。

2、动态库的打包与使用

动态库的使用场景与静态库的使用三个场景一样！！！可以类比！！！这里就不详细说明了！！！

打包

gcc -fPIC -c add.c
gcc -fPIC -c sub.c

gcc -shared -o libcal.so add.o sub.o

mkdir -p mlib/include
mkdir -p mlib/lib
cp ./*.h mlib/include/
cp ./*.so mlib/lib/
tree mlib

mylib=libcal.so
CC=gcc$(mylib): add.o sub.o$(CC) -shared -o $(mylib) $^%.o: %.c$(CC) -fPIC -c $<.PHONY: clean
clean:rm -rf $(mylib) ./*.o.PHONY: output
output:mkdir -p mlib/includemkdir -p mlib/libcp ./*.h mlib/includecp ./*.so mlib/lib

#include <stdio.h>
#include <add.h>int main()
{int x = 20;int y = 10;int z = my_add(x, y);printf("%d + %d = %d\n", x, y, z);return 0;
}

gcc main.c -I./mlib/include -L./mlib/lib -lcal

ldd 可执行程序

sudo cp mlib/lib/libcal.so /lib64

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/hmz

sudo ldconfig

ldd mathdemo

linux-vdso.so.1 (0x00007ffd3a3f0000)
libmath.so => ./libmath.so (0x00007f8c12345000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8c11f53000)
/lib64/ld-linux-x86-64.so.2 (0x00007f8c12349000)

sudo ldconfig  # 更新共享库缓存
ldconfig -p    # 打印当前缓存的所有共享库

nm -D libcal.so

objdump -T libcal.so  # 查看动态符号表

# 默认动态链接（即使同时存在动/静态库） 
gcc main.c -o dynamic_demo -lm # 强制静态链接（必须显式添加-static） 
gcc main.c -o static_demo -static -lm

#include <ncurses.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>#define PROGRESS_BAR_WIDTH 30
#define BORDER_PADDING 2
#define WINDOW_WIDTH (PROGRESS_BAR_WIDTH + 2 * BORDER_PADDING + 2)
#define WINDOW_HEIGHT 5
#define PROGRESS_INCREMENT 3
#define DELAY 300000 // 300毫秒int main() {initscr();start_color();init_pair(1, COLOR_GREEN, COLOR_BLACK); // 已完成部分：绿色前景，黑色背景init_pair(2, COLOR_RED, COLOR_BLACK);   // 剩余部分：红色背景（仅用于演示）cbreak();noecho();curs_set(FALSE);int max_y, max_x;getmaxyx(stdscr, max_y, max_x);int start_y = (max_y - WINDOW_HEIGHT) / 2;int start_x = (max_x - WINDOW_WIDTH) / 2;WINDOW *win = newwin(WINDOW_HEIGHT, WINDOW_WIDTH, start_y, start_x);box(win, 0, 0); // 添加边框wrefresh(win);int progress = 0;int max_progress = PROGRESS_BAR_WIDTH;while (progress <= max_progress) {werase(win); // 清除窗口内容box(win, 0, 0); // 重新绘制边框// 计算进度int completed = progress;int remaining = max_progress - progress;// 显示进度条int bar_x = BORDER_PADDING + 1;int bar_y = 1;// 已完成部分attron(COLOR_PAIR(1));for (int i = 0; i < completed; i++) {mvwprintw(win, bar_y, bar_x + i, "#");}attroff(COLOR_PAIR(1));// 剩余部分attron(A_BOLD | COLOR_PAIR(2));for (int i = completed; i < max_progress; i++) {mvwprintw(win, bar_y, bar_x + i, " ");}attroff(A_BOLD | COLOR_PAIR(2));// 显示百分比char percent_str[10];snprintf(percent_str, sizeof(percent_str), "%d%%", (progress * 100) / max_progress);int percent_x = (WINDOW_WIDTH - strlen(percent_str)) / 2;mvwprintw(win, WINDOW_HEIGHT - 1, percent_x, percent_str);wrefresh(win);progress += PROGRESS_INCREMENT;usleep(DELAY);}delwin(win);endwin();return 0;
}