Linux分文件编程：静态库与动态库的生成和使用
Posted 朝熙d
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux分文件编程：静态库与动态库的生成和使用相关的知识，希望对你有一定的参考价值。
目录
一，Linux库引入之分文件编程
① 简单说明
一般写代码demo时，习惯用一个代码文件进行代码编辑和编译。如果代码工程量大，实现功能多时，使用一个代码文件编写代码，就会显得代码冗长，繁杂，也不便后期维护。于是，便出现了分文件编程的方式。
分文件编程类似我之前写的博文：C语言简单工厂模式的实现，两者操作原理大同小异。
② 分文件编程优点
● 分模块的编程思想；
● 便于功能责任划分；
● 方便后期的维护和调试；
● 主程序更加简洁。
③ 操作逻辑
一篇代码基本可以分为三个部分，头文件部分，功能区部分，主函数main部分。那么分文件编程就是将这三个模块分别生成单独的代码文件。
● 功能区.c ：只写功能实现的代码部分，可以不写头文件
● 主函数.c ：写主函数main()的部分 ，和自己生成的“头文件.h”，用双引号“”，不用<>。
● 头文件.h ：代码需要的所有头文件首先要写进去，然后功能区定义的函数及变量要写入(只写函数定义的区域，末尾加分号)。作用在于连接功能区代码和主函数代码。
④ 代码实现说明
输入两个数，分别计算出加减乘除后的值。
🔺源代码示例（没用使用分文件编程的方式）
orangepi@orangepizero2:~/file$ ./a.out
input a num:
66
input a num:
22
=============
66+22=88
66-22=44
66x22=1452
66/22=3.000000🔺 代码拆分：将头文件区，功能代码区，主函数区分别建立代码文件
● 头文件 —— demo.h
● 主函数区 —— demo.c
● 功能函数 —— demo1.c
demo.h —— 头文件
1 #include <stdio.h>
2
3 int add(int x,int y);//加法
4 int sub(int x,int y);//减法
5 int mul(int x,int y);//乘法
6 float div(int x,int y);//除法demo.c —— 主函数
2 #include "demo.h"//自建头文件，用双引号“”，里面包含功能区函数的定义及参数
3 //连接主函数和功能区代码
4 int main()
5
6 int data1;
7 int data2;
8 int value;
9
10 printf("input a num:\\n");
11 scanf("%d",&data1);
12 printf("input a num:\\n");
13 scanf("%d",&data2);
14
15 printf("=============\\n");
16
17 printf("%d+%d=%d\\n",data1,data2,add(data1,data2));//加
18 printf("%d-%d=%d\\n",data1,data2,sub(data1,data2));//减
19 printf("%dx%d=%d\\n",data1,data2,mul(data1,data2));//乘
20 printf("%d/%d=%f\\n",data1,data2,(float)div(data1,data2));//除
21 return 0;
22
demo1.c —— 功能代码区
1 int add(int x,int y)//加法
2
3 return x+y;
4
5 int sub(int x,int y)//减法
6
7 return x-y;
8
9 int mul(int x,int y)//乘法
10
11 return x*y;
12
13 float div(int x,int y)//除法
14
15 return (float)x/y;
16
编译说明：
二，Linux库的基本说明
一个“程序函数库”简单的说就是一个文件包含了一些编译好的代码和数据，这些编译好的代码和数据可以在事后供其他的程序使用。程序函数库可以使整个程序更加模块化，更容易重新编译，而且更方便升级。
通俗点说明：你可以使用我的代码，但是你不能看我的代码；
编译时，会链接到我们生成的库文件，程序可以正常编译运行，但如果常规使用vi打开库文件，就是一页乱码。
程序函数库可分为3种类型：静态函数库（static libraries）、共享函数库（shared libraries）、动态加载函数（dynamicallyloaded libraries）；
● 静态函数库：是在程序执行前就加入到目标程序中去了 ；
● 动态函数库与共享函数库：两者其实一样（在linux上叫共享对象库， 文件后缀是.so；windows上叫动态加载函数库， 文件后缀是.dll）
三，Linux库之静态库的生成与使用
静态函数库：是在程序执行前（编译）就加入到目标程序中去了 ；一般将功能性代码生成库文件
优点：
● 静态库在编译的时候就被打包到应用程序中，所以其加载的速度快;
● 发布程序的时候无需提供静态库，因为已经在app中，移植方便;
缺点：
● 链接时完整的拷贝到可执行文件中，被多次使用就会有多份冗余拷贝；
● 更新，部署，发布麻烦；
① 静态库命名规则
静态库文件的命名方式：“libxxx.a”,库名前加“lib”，后缀用“.a”，“xxx”为静态库名
② 静态库制作步骤
原材料：xxx.c文件
1，将 xxx.c 文件生成 xxx.o 文件：gcc xxx.c -c;
2，将 xxx.o 文件生成 libtest.a 静态库文件：ar rcs libtest.a xxx.o
生成的静态库文件通过主函数的链接后，正常编译运行，但并不能打开库文件查看里面的内容，也是库文件制作的目的所在
ar 命令里的内容 ：
③ 静态库的使用
1，mv xxx.c ~ 将原先的功能文件和生成的.o文件移至工作目录，只留下.h头文件和主函数文件，还有生成的静态库文件。
2，gcc xxx.c -ltest -L./ 编译
● -l(L小写)，链接生成的静态库文件，libtest.a需要“砍头去尾” test;
● -L:告诉gcc编译器从-L指定的路径去找静态库（当前路径）。默认是从/usr/lib或/usr/local/lib中去找
orangepi@orangepizero2:~/file$ ls
demo1.c demo1.o demo.c demo.h libtest.a
orangepi@orangepizero2:~/file$ mv demo1.c demo1.o ~ //把多余的文件移动到工作目录
orangepi@orangepizero2:~/file$ ls //只剩下库文件，头文件，主函数文件
demo.c demo.h libtest.a
orangepi@orangepizero2:~/file$ gcc demo.c -ltest -L./ //编译要链接库和路径
orangepi@orangepizero2:~/file$ ls //编译成功，生成可执行程序a.out
a.out demo.c demo.h libtest.a
orangepi@orangepizero2:~/file$ ./a.out //运行成功
input a num:
56
input a num:
89
=============
56+89=145
56-89=-33
56x89=4984
56/89=0.629214四，Linux库之动态库的生成与使用
动态函数库：是在程序执行时动态（临时）由目标程序去调用
优点：
● 链接时不复制，程序运行时由系统动态加载到内存，供程序调用，系统只加载一次，多个程序可以共用，节省内存；
● 程序升级简单，因为app中没有库的源代码，升级之后只要库的名字不变，函数名与及参数不变，只是做了优化，就能加载成功；
缺点：
● 加载速度比静态库慢；
● 发布程序时需要提供依赖的动态库；
① 动态库命名规则
动态库的命名方式：“libxxx.so”, 库名前加“lib”，后缀用“.so”，“xxx”为动态库名
② 动态库制作步骤
原材料：xxx.c 文件
生成.so文件：gcc -shared -fpic xxx.c -o libtest.so
● -shared：必须使用的关键字，指定生成动态库；
● -fpic：执行标准，作用于编译阶段，在生成目标文件时就得使用该选项；
③ 动态库的使用
gcc xxx.c -ltest -L./ 编译后生成默认a.out可执行程序，也可以自行-o生成执行程序
● -l(L小写)，链接生成的静态库文件，libtest.so需要“砍头去尾” test;
● -L:告诉gcc编译器从-L指定的路径去找静态库（当前路径）。默认是从/usr/lib或/usr/local/lib中去找
✳：编译没问题，但是结果出了问题。动态库运行和静态库的运行方式有区别的，静态库直接生在在可执行的程序中，而动态库是在程序执行时动态（临时）由目标程序去调用，需要去找到执行的文件目录，所以上面的动态库执行出错。
解决方法：把生成的动态库文件libtest.so拷贝到/usr/lib/这个路径下即可
深入探讨Linux静态库与动态库的详解（转）
2.生成动态库并使用
linux下编译时通过 -shared 参数可以生成动态库（.so）文件，如下
库从本质上来说是一种可执行代码的二进制格式，可以被载入内存中执行。库分静态库和动态库两种。
一、静态库和动态库的区别
1. 静态函数库
这类库的名字一般是libxxx.a；利用静态函数库编译成的文件比较大--空间，因为整个函数库的所有数据都会被整合进目标代码中，他的优点就显而易见了，即编译后的执行程序不需要外部的函数库支持，因为所有使用的函数都已经被编译进去了。当然这也会成为他的缺点，因为如果静态函数库改变了，那么你的程序必须重新编译。
2. 动态函数库
这类库的名字一般是libxxx.so;相对于静态函数库，动态函数库在编译的时候并没有被编译进目标代码中，你的程序执行到相关函数时才调用该函数库里的相应函数，因此动态函数库所产生的可执行文件比较小。由于函数库没有被整合进你的程序，而是程序运行时动态的申请并调用--时间，所以程序的运行环境中必须提供相应的库。动态函数库的改变并不影响你的程序，所以动态函数库的升级/更新比较方便。
二、静态库
（一）简单介绍
gcc main.c src/* -I./include -L./lib -lmpi -o main
main.c 为主函数
src/* 为源文件
-I后面接头文件
-L后面接库文件路径路径
-l后面接库文件名,全名为libmpi.a
.a为静态库
（二）编写及使用静态库
(1)设计库源码 pr1.c、pr2.c 和 main.c
[[email protected] make_lib]$ cat pr1.c #include <stdio.h> void print1(void) { printf("This is the first lib src!\\n"); } [[email protected] make_lib]$ cat pr2.c #include<stdio.h> void print2(void) { printf("This is the second src lib!\\n"); } [[email protected] make_lib]$ cat main.c int main(void) { print1(); print2(); return 0; }
(2) 编译pr1.c、pr2.c 文件
[[email protected] make_lib]$ gcc -O -c pr1.c pr2.c [[email protected] make_lib]$ ls -l pr*.o -rw-rw-r-- 1 bill bill 804 4 月 15 11:11 pr1.o -rw-rw-r-- 1 bill bill 804 4 月 15 11:11 pr2.o
(3) 链接静态库
为了在编译程序中正确找到库文件,静态库必须按照 lib[name].a 的规则命名,如下例中[name]=pr.
ar参数意义：
r：在库中插入模块(替换)。当插入的模块名已经在库中存在，则替换同名的模块。
s：写入一个目标文件索引到库中，或者更新一个存在的目标文件索引。
v：该选项用来显示执行操作选项的附加信息。
t：显示库的模块表清单。一般只显示模块名。
[[email protected] make_lib]$ ar -rsv libpr.a pr1.o pr2.o a - pr1.o a - pr2.o [[email protected] make_lib]$ ar -t libpr.a pr1.o pr2.o
(4) 编译链接选项
-L 及-l 参数放在后面.其中,-L 加载库文件路径,-l 指明库文件名字.
[[email protected] make_lib]$ gcc -o main main.c -L./ -lpr //生成main
(5)执行目标程序
[[email protected] make_lib]$ ./main This is the first lib src! This is the second src lib!
三、动态库（隐式调用）
(1)设计库代码
[[email protected] make_lib]$ cat pr1.c #include <stdio.h> int p = 2; void print(){ printf("%p:%d\\n", &p, p); printf("This is the first dll src!\\n"); }
(2)生成动态库 xxx.so
[[email protected] make_lib]$ gcc -O -fpic -shared -o xxx.so pr1.c [[email protected] make_lib]$ ls -l *.so -rwxrwxr-x 1 bill bill 6592 4 月 15 15:19 xxx.so
(3)动态库的隐式调用
[[email protected] make_lib]$ cat main.c int main() { print(); return 0; } [[email protected] make_lib]$ gcc -o main main.c ./xxx.so [[email protected] make_lib]$ ./main 0x97b5d4:2 this is the first lib src!
当动态库的位置发生改变时, 程序将无法正常运行; 而动态库取代静态库的好处之一则是通过更新动态库而随时升级库的内容.
示例：
首先是准备工作，把我们需要封装成库文件的函数的头文件与源文件写好，如下：
1 //myAPI.h 2 int ADD(int a, int b); 3 int MINUS(int a, int b);
1 //myAPI.cpp 2 #include "myAPI.h" 3 4 int ADD(int a, int b){ 5 return a + b; 6 } 7 8 int MINUS(int a, int b){ 9 return a - b; 10 }
接下来准备一个测试用的主函数源文件：
1 //main.cpp 2 #include "myAPI.h" 3 #include <iostream> 4 5 int main(){ 6 std::cout << "1 + 1 = " << ADD(1, 1) << std::endl; 7 std::cout << "1 - 1 = " << MINUS(1, 1) << std::endl; 8 return 0; 9 }
最后，先编译我们的 myAPI.cpp 文件生成 myAPI.o 目标文件
g++ -c myAPI.cpp
1.生成静态库并使用
linux下用生成静态库的命令 ar 处理 myAPI.o 文件生成静态库文件，生成的库文件应遵循规范，及linux下库文件加“lib”前缀。所以针对本例，通过如下一条命令即可生成 libmyAPI.a 静态库：
ar crv libmyAPI.a myAPI.o
接下来即可在项目编译过程中利用静态库了，此时 myAPI.cpp 这个库函数的定义文件已经不需要了。main.cpp 编译命令如下（注意，依赖的静态库文件要放在被依赖项后面）：
g++ main.cpp libmyAPI.a -o output
编译通过后即可运行可执行文件 output ， 此时 libmyAPI.a 也已经是不需要的了。执行命令并输出结果如下：
./output
2.生成动态库并使用
linux下编译时通过 -shared 参数可以生成动态库（.so）文件，如下
g++ -shared -fPIC -o libmyAPI.so myAPI.cpp
生成的动态库在编译时需要声明，运行时需要被依赖。声明如下
g++ main.cpp -L. -o output ./libmyAPI.so
”-L.”标记告诉G++函数库可能位于当前目录;使用”-lmyAPI”标记来告诉G++驱动程序在连接阶段引用共享函数库libmyAPI.so。
使用时如果提示如下错误，则将 libmyAPI.so 移到 /usr/lib 目录下即可：
./output
转自：http://blog.csdn.net/u013256622/article/details/51811072
http://www.jb51.net/article/37409.htm
以上是关于Linux分文件编程：静态库与动态库的生成和使用的主要内容，如果未能解决你的问题，请参考以下文章