gcc如何生成静态库.a和动态库.so C语言编程gcc怎样生成静态库.a和动态库.so示例详解

系统环境：Ubuntu Desktop 18.04

一、什么是静态库和动态库

我们通常需要把一些公用函数制作成函数库，供其它程序使用，函数库分为静态库和动态库两种。

静态库在程序编译时会被连接到目标代码中，程序运行时不在需要该静态库。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行时才被载入。这样我们可以通过更改动态库，动态的改变程序的某些功能。

Linux下使用ar工具，将目标文件压缩到一起，并且对其进行编号和索引，以便于查找和检索。

二、gcc生成.a静态库和.so动态库

1.生成静态库(.a)

1.1编辑生成例子程序hello.h、hello.c和main.c

hello.h

#ifndef HELLO_H//如果源文件没有定义，则编译下面代码
#define HELLO_H//定义宏
void hello(const char *name);
#endif/HELLO_H//ifndef的结束

hello.c

#include<stdio.h>
void hello(const char *name)
{
	printf("Hello %s!\n",name);
}

main.c

#include "hello.h"
int main()
{
    hello("everyone");
    return 0;
}

1.2将hello.c编译成.o文件

无论静态库还是动态库都是由.o文件创建的。因此，我么必须将源代码hello.c通过gcc先编译成.o文件，在Linux系统终端下使用命令

gcc -c hello.c

为了确定我们得到了.o文件，可以使用ls命令

1.3由.o文件创建静态库

静态库文件名的命令规范是以lib为前缀，紧接着是静态库名，扩展名为.a，例如我们将创建的静态库名为hello，则静态库文件名就是libhello.a。在Linux系统下创建静态库需要使用ar命令，在终端输入以下命令.

ar -crv libmyhello.a hello.o

同样的我们可以使用ls命令查看结果。

1.4在程序中使用静态库

静态库制作完成了，如何使用它内部的函数呢？只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后再用gcc命令生成目标文件时指明静态库名。

方法一：

在终端输入以下命令：

gcc -o hello main.c -L. -lmyhello

自定义的库时，main.c还可以放在-L.和-lmyhello之间，但不能放在它俩之后，否则会提示myhello没定义，但是是系统的库时，如g++ -o main (-L/usr/lib) -lpthread main.cpp就不会出错。

方法二：

gcc main.c libmyhello.a -o hello

方法三：

先生成main.o

gcc -c main.c

再生成可执行文件：

gcc -o hello main.o libmyhello.a

1.5验证静态库的特点

下面我们在删除静态库的情况下，运行可执行文件，发现程序仍旧正常运行，表明静态库跟程序执行并没有联系。我们使用rm命令删除libmyhello.a文件，然后执行hello程序。

2.生成动态库(.so)

2.1由.o文件创建动态库文件

动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀lib，但其文件扩展名为.so。例如，我们将创建的动态库名为myhello，则动态库文件名就是libmyhello.so。在终端输入以下命令来得到动态库文件libmyhello.so。

gcc -shared -fPIC -o libmyhello.so hello.o

2.2在程序中使用动态库

在程序中使用动态库和使用静态库一样，也是在使用到这些函数的源程序中包含这些公有函数的声明，然后在用gcc命令生成目标文件时指明动态库名进行编译。在终端输入以下命令

gcc -o hello main.c -L. -lmyhello

或者可以使用命令

gcc main.c libmyhello.so -o hello

此时并不会报错（没有 libmyhello.so 的话，会报错），但是接下来运行该程序时会提示出错，因为虽然连接时用的是当前目录的动态库，但是运行时会到/usr/lib目录下查找库文件。可以将文件 libmyhello.so复制到目录/usr/lib下，这样运行就不会报错了。

在终端输入以下命令将libmyhello.so文件移动到/usr/lib目录下

sudo mv libmyhello.so /usr/lib

可以看到此时，执行成功了。

如果动态库和静态库同时存在，通过实验我们可以发现会优先使用动态库。

三、实例

1.实例1

1.1代码

代码如下：

A1.c

#include<stdio.h>
void print1(int arg){
    printf("A1 print arg:%d\n",arg);
}

A2.c

#include<stdio.h>
void print2(char *arg){
	printf("A2 printf arg:%s\n",arg);
}

A.h

#ifndef A_H
#define A_H
void print1(int);
void print2(char *);
#endif

test.c

#include<stdlib.h>
#include "A.h"
int main(){
    print1(1);
    print2("test");
    exit(0);
}

1.2 静态库.a文件的生成与使用

首先是生成.o文件，在终端输入以下命令

gcc -c A1.c A2.c

接下来是生成静态库.a文件，在终端输入以下命令

ar crv libafile.a A1.o A2.o

最后使用.a库文件，创建可执行程序（PS:若采用此种方式，需保证生成的.a文件与.c文件保存在同一目录下，即都在当前目录下）。在终端输入以下命令

gcc -o test test.c libafile.a
./test

1.3 动态库.so文件的生成与使用

首先是生成目标文件(.o)，此处生成.o文件必须添加"-fpic"（小模式，代码少），否则在生成.so文件时会报错。在终端输入以下命令

gcc -c -fpic A1.c A2.c

接下来是生成共享库（动态库）.so文件

gcc -shared *.o -o libsofile.so

使用.so库文件，创建可执行程序

gcc -o test test.c libsofile.so
./test

此时会报错，这是由于Linux系统只在/lib和/usr/lib目录下查找.so文件，所以需要将相应的.so文件拷贝到相对应的路径。在终端输入以下命令

sudo cp libsofile.so /usr/lib

再执行test程序，即可成功运行。

同时可直接使用

gcc -o test test.c -L. -lname

来使用相应库文件，其中

-L. ：表示在当前目录下，可自行定义路径path，即使用-Lpath即可。

-lname：name即对应库文件的名字（除开lib），即若使用libafile.a，则name为afile；若要使用libsofile.so，则name为sofile。

2.实例2

2.1代码

sub1.c

float x2x(int x1,int x2)
{
    return (float)(x1*x2);
}

sub2.c

float x2y(int x1,int x2)
{
    return (float)(x1)/x2;
}

sub.h

#ifndef SUB_H
#define SUB_H
float x2x(int x1,int x2);
float x2y(int x1,int x2);
#endif

main.c

#include<stdio.h>
#include "sub.h"
int main()
{
    int x1,x2;
    scanf("%d %d",&x1,&x2);
    printf("x1*x2=%f\n",x2x(x1,x2));
    printf("x1/x2=%f\n",x2y(x1,x2));
    return 0;
}

2.2 静态库.a文件的生成与使用

依次在终端输入以下命令

gcc -c sub1.c sub2.c
ar crv libsub.a sub1.o sub2.o
gcc -o main main.c libsub.a
./main
4 2

通过在终端输入下面的命令来查看文件的大小

du -h main

此时生成的可执行文件的大小为12k

2.3 动态库.so文件的生成与使用

依次在终端输入以下命令

gcc -shared -fpic -o libsub.so sub1.o sub2.o
sudo cp libsub.so /usr/lib
gcc -o main main.c libsub.so
./main
4 2

同样的，在终端输入命令查询main的大小

虽然和上面静态库生成的可执行文件一样大，但是这是由于函数太简单。对于复杂一点的文件编译来说，静态库生成的可执行文件的大小理论上应该大于动态库生成的可执行文件的大小。

总结

通过上面三个实例，基本上可以熟练使用gcc生成静态库和动态库，并且可以学习到有关静态库和动态库的有关知识。与之前一次实验类似，先生成.o文件，然后将.o文件连接到主程序中，生成可执行文件。不同的是，之前只有单个文件，本次实验连接了多个文件。对于以后开发某些项目时，如果只提供了静态库或者动态库，我们可以利用本次实验的知识来调用公用的函数，并生成可执行文件。