​

一、什么是库文件?

本质上来说,库文件就是可执行代码的二进制形式,可以被操作系统载入内存中执行

Linux操作系统支持的函数库分为静态库和动态库,动态库又称共享库

Linux系统有几个重要的目录存放相应的函数库,如/lib、/usr/lib

二、静态库和动态库

静态库的名字一般为:libxxx.a,利用静态函数库编译生成的库文件一般较大,因为函数中的所有数据都被整合进目标代码中

它的优势在于在其运行时,编译后的可执行文件不需要再依赖其它外部函数库的支持

它的缺点则是如果函数发生变化,必须将整个文件重新编译,并且文件体积较大


动态库的名字一般为libxxx.so,动态库又称为共享库

相较于静态库,动态函数库在编译时并没有将其编译进目标代码中,它的程序执行到相关函数时才调用函数库里的调用相应的函数,因此动态库的文件体积较小

动态库的改变并不会影响你的程序,因此动态函数库的升级比较方便,并且一个动态函数库能够被多个程序使用,这大大减小了程序的体积

在运行程序的时候,程序运行的环境必须提供相应的函数库

不论是动态库还是静态库,都是由*.o文件生成的

三、函数库的创建


静态函数库的创建

ar -cr *.a *.o

ar:静态函数库创建的命令

-c :create的意思

-r :replace的意思,表示当前插入的模块名已经在库中存在,则替换同名的模块。如果若干模块中有一个模块在库中不存在,ar显示一个错误信息,并不替换其他同名的模块。默认的情况下,新的成员增加在库的尾处


动态库的创建

gcc -shared -fpic -o *.so *.c


-fpic:目标机器支持,则发出位置独立代码,适用于动态链接并避免全局偏移表的大小

-shared:生成共享库

四、静态库和动态库的使用

案例:

我们将学生管理系统的功能函数进行封装,每个功能函数作为单独的.c文件,就得到了如下结果:

linux的库文件_结点

文件内容如下:

create.c

#include <stdio.h>

typedef struct { // 定义结构体类型,包含四项内容,可以自由添加
int num;
char name[10];
int age;
char sex[5];
}st;

typedef struct node // 构造结点 (也是结构体变量)
{
st data; // 数据域
struct node *next; // 指针域(指向结构体,也就是自身)
}list;

list *create() // 建立一个单链表
{
list *p,*r,*head; // 定义结构体指针变量
int i,n; head = (list *)malloc(sizeof(list)); // 申请头结点
r = head; head->next = NULL; // 头结点的指针域先定义为空
printf(" 请输入学生人数 :\n");
scanf("%d",&n);
printf(" 请输入学生个人信息 :\n\n 学号,姓名,年龄,性别 \n");
for(i=1;i<=n;i++)
{
p = (list *)malloc(sizeof(list)); // 申请一个结点
scanf("%d%s%d%s",&p->data.num,&p->data.name,&p->data.age,&p->data.sex); // 向结点的数据域输入学生信息
p->next = NULL;
r->next = p; // 将头结点指向第一个结点,以此类推。
r = r->next;
}
return (head); // 返回头结点的地址
}

dele.c

#include <stdio.h>

typedef struct { // 定义结构体类型,包含四项内容,可以自由添加
int num;
char name[10];
int age;
char sex[5];
}st;

typedef struct node // 构造结点 (也是结构体变量)
{
st data; // 数据域
struct node *next; // 指针域(指向结构体,也就是自身)
}list;


void dele(list *h) // 在链表中删除某一位学生信息
{
int k;
list *p,*r;
r = h;
p = h->next;
printf(" 请输入要删除学生的学号: \n"); scanf("%d",&k);
while(p && p->data.num!=k)
{
r = p; // 找到学号为 k 的结点,如果没有,则 p 为空
p = p->next;
}
if(p)
{
r->next = p->next;
p->next = NULL;
free(p);
printf(" 学生信息已删除! \n\n");
}
else
printf(" 找不到此学生 \n\n");
}

insert.c

#include <stdio.h>

typedef struct { // 定义结构体类型,包含四项内容,可以自由添加
int num;
char name[10];
int age;
char sex[5];
}st;

typedef struct node // 构造结点 (也是结构体变量)
{
st data; // 数据域
struct node *next; // 指针域(指向结构体,也就是自身)
}list;


void insert(list *h) // 插入一个学生信息到链表中 (插到链表末尾)
{
list *p,*q,*r;
p = h->next;
r = h;
q = (list *)malloc(sizeof(list)); // 申请一个新结点

printf(" 请输入插入学生的学号,姓名,年龄,性别: \n");
scanf("%d%s%d%s",&q->data.num,&q->data.name,&q->data.age,&q->data.sex);
q->next = NULL;

while(p!=NULL)
{
r = p;
p = p->next;
}
r->next = q;
}

output.c

#include <stdio.h>

typedef struct { // 定义结构体类型,包含四项内容,可以自由添加
int num;
char name[10];
int age;
char sex[5];
}st;

typedef struct node // 构造结点 (也是结构体变量)
{
st data; // 数据域
struct node *next; // 指针域(指向结构体,也就是自身)
}list;


void output(list *h) // 输出链表中的学生信息
{
list *p; p = h->next; // 使 p 指向第一个结点
if(p == NULL)
printf("------------ 学生信息为空 ------------------\n\n");
while(p!=NULL)
{
printf(" 学号,姓名,年龄,性别分别是: \n");
printf("%d,%s,%d,%s\n",p->data.num,p->data.name,p->data.age,p->data.sex);
p = p->next;
}
}

research.c

#include <stdio.h>

typedef struct { // 定义结构体类型,包含四项内容,可以自由添加
int num;
char name[10];
int age;
char sex[5];
}st;

typedef struct node // 构造结点 (也是结构体变量)
{
st data; // 数据域
struct node *next; // 指针域(指向结构体,也就是自身)
}list;


void research(list *h) // 查找链表中某一位学生信息
{
list *p;
int k;
p = h->next; // 使 p 指向第一个结点
printf(" 请输入要查找学生的学号: \n"); scanf("%d",&k);
while(p && p->data.num!=k)
p = p->next; // 找到学号为 k 的结点,如果没有,则 p 为空
if(p)
{
printf(" 学号,姓名,年龄,性别为: \n");
printf("%d,%s,%d,%s\n",p->data.num,p->data.name,p->data.age,p->data.sex);
}
else
printf(" 找不到此学生: \n");
}

mian.c

#include<stdio.h> 
#include<stdlib.h> // 申请空间的函数 malloc 的头文件

#include"head.h"

int main()
{
int i,j=1;
struct list *p;
printf("-------------------------------------------\n");
printf(" 学生信息管理系统 \n");
printf("-------------------------------------------\n");

while(1)
{
printf(" 1,登记学生信息 \n");
printf(" 2,浏览学生信息 \n");
printf(" 3,查找学生信息 \n");
printf(" 4,插入学生信息 \n");
printf(" 5,删除学生信息 \n");
printf(" 6,退出程序 \n");
printf("-------------------------------------------\n");
printf(" 请输入你的选择: \n");
scanf("%d",&i);
switch(i)
{
case 1: p = create();
break;
case 2: output(p);
break;
case 3: research(p);
break;
case 4: insert(p);
break;
case 5: dele(p);
break;
case 6: exit(0);
}
}
return 0;
}

head.h

#ifndef _HEAD_H_
#define _HEAD_H_
extern struct list *create();
extern void output(list *h);
extern void research(list *h);
extern void insert(list *h);
extern void dele(list *h);
#endif
  1. 生成静态库

注:由于源文件过多,因此我将main.c文件放到了其它文件夹下,便于编译,等到库文件生成之后再将其拷贝到指定文件夹,并且将动态库和静态库放到了不同的目录

终端输入:gcc -c *.c

将本目录下所有的.c文件编译生成.o文件

linux的库文件_动态库_02

linux的库文件_结点_03

接下来利用这些.o文件,生成静态库student.a

终端输入:ar -cr libstudent.a *.o

linux的库文件_库文件的创建和使用_04

libstudent.a就是生成的静态库文件


接下来使用生成的库文件

拷贝main.c文件到当前文件夹

linux的库文件_Linux库文件_05

终端输入:gcc main.c -L. -lstudent -o student

linux的库文件_库文件的创建和使用_06

接下来执行student,并观察结果


终端输入:./student

linux的库文件_结点_07

程序正常运行,经过测试,功能正常



2.生成动态库

终端输入:gcc -shared -fpic -o libstudent1.so *.c

linux的库文件_动态库_08


该命令执行时提示大量警告信息,不影响动态库文件的生成

接下来将mian.c文件拷贝进来

终端输入:gcc main.c -L. -lstudent -o student

linux的库文件_Linux库文件_09

接下来运行可执行程序却提示如下错误信息:

./student: error while loading shared libraries: libstudent.so: cannot open shared object file: No such file or directory

这是由于程序在运行过程中,无法找到依赖的动态库文件,需要将libstudent.so文件的路径添加到环境变量或者将该文件复制到/lib或者/usr/lib中


我们先将文件复制到/lib中,观察程序运行效果

终端输入:cp libstudent.so /lib

linux的库文件_静态库和动态库_10

之后返回实验目录,执行student文件

linux的库文件_库文件的创建和使用_11

程序正常运行且功能正常


接下来我们将修改环境变量以保证student正常运行

终端输入:export LD_LIBRARY_PATH=/home/wang/test/work/share:$LD_LIBRARY_PATH


其中,红色部分为共享库的路径


接下来,我们查看动态库和静态库的大小

linux的库文件_静态库和动态库_12

我们可以直观的看到二者文件大小差异,同时,通过这个案例我们也能清楚的比较两种库的优缺点:静态库文件较大,但在运行时不需要其它依赖,能够直接运行;动态库文件较小,但是在程序运行时,需要添加依赖,否则程序不能正常运行