C++静态库与动态库(Linux)

目录

目标

什么是库

静态库

 创建与使用静态库

动态库

创建与使用动态库

动态库的显式调用

附件：Linux下库相关命令

总结

目标

       这次分享的宗旨是——让大家学会创建与使用静态库、动态库，知道静态库与动态库的区别，知道使用的时候如何选择。这里不深入介绍静态库、动态库的底层格式，内存布局等，有兴趣的同学，推荐一本书《程序员的自我修养——链接、装载与库》。

什么是库

库是写好的现有的，成熟的，可以复用的代码。现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。

本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。库有两种：

          1、静态库（.a）。

          2、动态库（.so）。

 所谓静态、动态是指链接。回顾一下，将一个程序编译成可执行程序的步骤：

   C++静态库与动态库(Linux)

静态库

之所以成为【静态库】，是因为在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。因此对应的链接方式称为静态链接。

试想一下，静态库与汇编生成的目标文件一起链接为可执行文件，那么静态库必定跟.o文件格式相似。其实一个静态库可以简单看成是一组目标文件（.o/.obj文件）的集合，即很多目标文件经过压缩打包后形成的一个文件。静态库特点总结：

  1.   静态库对函数库的链接是放在编译时期完成的。
  2.   程序在运行时与函数库再无瓜葛，移植方便。
  3.   浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。

下面编写一些简单的四则运算C++类，将其编译成静态库给他人用，头文件如下所示：

#pragma once
class StaticMath
{
public:
    StaticMath(void);
    ~StaticMath(void);
    static double add(double a, double b);//加法
    static double sub(double a, double b);//减法
    static double mul(double a, double b);//乘法
    static double div(double a, double b);//除法
};
#include "StaticMath.h"
double StaticMath::add(double a,double b)
{
	return a+b;
}
double StaticMath::sub(double a,double b)
{
	return a-b;
}
double StaticMath::mul(double a,double b)
{
	return a*b;
}
double StaticMath::div(double a,double b)
{
	if(b==0)
	{
		return a;
	}
	return a/b;
}

Linux下使用ar工具，将目标文件压缩到一起，并且对其进行编号和索引，以便于查找和检索。一般创建静态库的步骤如图所示：

         C++静态库与动态库(Linux)

 创建与使用静态库

       Linux静态库命名规则

Linux静态库命名规范，必须是"lib[your_library_name].a"：lib为前缀，中间是静态库名，扩展名为.a。

       创建静态库（.a）

通过上面的流程可以知道，Linux创建静态库过程如下：

  1.   首先，将代码文件编译成目标文件.o（StaticMath.o）

g++ -c StaticMath.cpp

注意带参数-c，否则直接编译为可执行文件

  1.   然后，通过ar工具将目标文件打包成.a静态库文件

ar -crv libstaticmath.a StaticMath.o

生成静态库libstaticmath.a。

        C++静态库与动态库(Linux)

大一点的项目会编写makefile文件（CMake等等工程管理工具）来生成静态库，输入多个命令太麻烦了。

#!/usr/sh

CC=cc -g
IFLAGS=-I. -I ${DSC_PATH}/include  
FEDXLFLAGS= -lm -L. -L${DSC_PATH}/lib -lxxx 

COMPILE = ${CC} ${IFLAGS} 
MAKEEXE = ${COMPILE} ${EXEFLAGS}
DECOBJ=main.o

all:	so_test  clean

so_test:${DECOBJ}
	${MAKEEXE} -o [email protected] ${DECOBJ} ${FEDXLFLAGS} -ldl 
.c.o:
	${COMPILE} -c $<
clean:
	rm -f  *.o

         使用静态库

编写使用上面创建的静态库的测试代码：

#include "StaticMath.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    double a = 10;
    double b = 2;
    cout << "a + b = " << StaticMath::add(a, b) << endl;
    cout << "a - b = " << StaticMath::sub(a, b) << endl;
    cout << "a * b = " << StaticMath::mul(a, b) << endl;
    cout << "a / b = " << StaticMath::div(a, b) << endl;
    return 0;
}

Linux下使用静态库，只需要在编译的时候，指定静态库的搜索路径（-L选项）、指定静态库名（不需要lib前缀和.a后缀，-l选项）。

g++ main.cpp -I../StaticLibrary  -L../StaticLibrary -lstaticmath

  C++静态库与动态库(Linux) 

  1.   -L：表示要连接的库所在目录
  2.   -l：指定链接时需要的动态库，编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.a或.so来确定库的名称。
  3.  -I：表示要使用的头文件所在目录

动态库

通过上面的介绍发现静态库，容易使用和理解，也达到了代码复用的目的，那为什么还需要动态库呢？

为什么还需要动态库？

为什么需要动态库，其实也是静态库的特点导致。

  1.   空间浪费是静态库的一个问题。

       C++静态库与动态库(Linux)

l  另一个问题是静态库对程序的更新、部署和发布页会带来麻烦。如果静态库liba.lib更新了，所以使用它的应用程序都需要重新编译、发布给用户（对于玩家来说，可能是一个很小的改动，却导致整个程序重新下载，全量更新）。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行是才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。

         C++静态库与动态库(Linux)

动态库特点总结：

  1.   动态库把对一些库函数的链接载入推迟到程序运行的时期。
  2.   可以实现进程之间的资源共享。（因此动态库也称为共享库）
  3.   将一些程序升级变得简单。
  4.   甚至可以真正做到链接载入完全由程序员在程序代码中控制（显示调用）。

Window与Linux执行文件格式不同，在创建动态库的时候有一些差异。

  1.   在Windows系统下的执行文件格式是PE格式，动态库需要一个DllMain函数做出初始化的入口，通常在导出函数的声明时需要有_declspec(dllexport)关键字。
  2.   Linux下gcc编译的执行文件默认是ELF格式，不需要初始化入口，亦不需要函数做特别的声明，编写比较方便。

与创建静态库不同的是，不需要打包工具（ar、lib.exe），直接使用编译器即可创建动态库。

创建与使用动态库

linux动态库的命名规则

动态链接库的名字形式为 libxxx.so，前缀是lib，后缀名为“.so”。

  1.   针对于实际库文件，每个共享库都有个特殊的名字“soname”。在程序启动后，程序通过这个名字来告诉动态加载器该载入哪个共享库。
  2.   在文件系统中，soname仅是一个链接到实际动态库的链接。对于动态库而言，每个库实际上都有另一个名字给编译器来用。它是一个指向实际库镜像文件的链接文件（lib+soname+.so）。

创建动态库（.so）

编写四则运算动态库代码：

#pragma once
class StaticMath
{
public:
    StaticMath(void);
    ~StaticMath(void);
    static double add(double a, double b);//加法
    static double sub(double a, double b);//减法
    static double mul(double a, double b);//乘法
    static double div(double a, double b);//除法
};

 1.首先，生成目标文件，此时要加编译器选项-fpic

g++ -fpic -c StaticMath.cpp

-fPIC 创建与地址无关的编译程序（pic，position independent code），是为了能够在多个应用程序间共享。

2.然后，生成动态库，此时要加链接器选项-shared

g++ -shared -o libdynmath.so DynamicMath.o

-shared指定生成动态链接库。

其实上面两个步骤可以合并为一个命令：

g++ -fpic -shared -o libdynmath.so StaticMath.cpp

使用动态库

编写使用动态库的测试代码：

#include "StaticMath.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    double a = 10;
    double b = 2;
    cout << "a + b = " << StaticMath::add(a, b) << endl;
    cout << "a - b = " << StaticMath::sub(a, b) << endl;
    cout << "a * b = " << StaticMath::mul(a, b) << endl;
    cout << "a / b = " << StaticMath::div(a, b) << endl;
    return 0;
}

引用动态库编译成可执行文件（跟静态库方式一样）：

g++ main.cpp -I../StaticLibrary  -L../StaticLibrary -lstaticmath

然后运行：./a.out，发现竟然报错了！！！

   C++静态库与动态库(Linux)

可能大家会猜测，是因为动态库跟测试程序不是一个目录，那我们验证下是否如此：

     C++静态库与动态库(Linux)

发现还是报错！！！那么，在执行的时候是如何定位共享库文件的呢？

  1. 当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径。此时就需要系统动态载入器(dynamic linker/loader)。
  2.  对于elf格式的可执行程序，是由ld-linux.so*来完成的，它先后搜索elf文件的 DT_RPATH段—环境变量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表—/lib/,/usr/lib 目录找到库文件后将其载入内存。

如何让系统能够找到它：

  1.   如果安装在/lib或者/usr/lib下，那么ld默认能够找到，无需其他操作。
  2.   如果安装在其他目录，需要将其添加到/etc/ld.so.cache文件中，步骤如下：
    1.   编辑/etc/ld.so.conf文件，加入库文件所在目录的路径
    2.   运行ldconfig ，该命令会重建/etc/ld.so.cache文件

我们将创建的动态库复制到/usr/lib下面，然后运行测试程序。

        C++静态库与动态库(Linux)

动态库的显式调用

上面介绍的动态库使用方法和静态库类似属于隐式调用，编译的时候指定相应的库和查找路径。其实，动态库还可以显式调用。【在C语言中】，显示调用一个动态库轻而易举！

在Linux下显式调用动态库

#include <dlfcn.h>，提供了下面几个接口：

  1.   void * dlopen( const char * pathname, int mode )：函数以指定模式打开指定的动态连接库文件，并返回一个句柄给调用进程。
  2.   void* dlsym(void* handle,const char* symbol)：dlsym根据动态链接库操作句柄(pHandle)与符号(symbol)，返回符号对应的地址。使用这个函数不但可以获取函数地址，也可以获取变量地址。
  3.   int dlclose (void *handle)：dlclose用于关闭指定句柄的动态链接库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载。
  4.   const char *dlerror(void)：当动态链接库操作函数执行失败时，dlerror可以返回出错信息，返回值为NULL时表示操作函数执行成功。

附件：Linux下库相关命令

g++(gcc)编译选项

  1.   -shared ：指定生成动态链接库。
  2.   -static ：指定生成静态链接库。
  3.   -fPIC ：表示编译为位置独立的代码，用于编译共享库。目标文件需要创建成位置无关码， 念上就是在可执行程序装载它们的时候，它们可以放在可执行程序的内存里的任何地方。
  4.   -L. ：表示要连接的库所在的目录。
  5.   -l：指定链接时需要的动态库。编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.a/.so来确定库的名称。
  6.   -Wall ：生成所有警告信息。
  7.   -ggdb ：此选项将尽可能的生成gdb 的可以使用的调试信息。
  8.   -g ：编译器在编译的时候产生调试信息。
  9.   -c ：只**预处理、编译和汇编,也就是把程序做成目标文件(.o文件) 。
  10.   -Wl,options ：把参数(options)传递给链接器ld 。如果options 中间有逗号,就将options分成多个选项,然后传递给链接程序。

nm命令

有时候可能需要查看一个库中到底有哪些函数，nm命令可以打印出库中的涉及到的所有符号。库既可以是静态的也可以是动态的。nm列出的符号有很多，常见的有三种：

  1.   一种是在库中被调用，但并没有在库中定义(表明需要其他库支持)，用U表示；
  2.   一种是库中定义的函数，用T表示，这是最常见的；
  3.   一种是所谓的弱态”符号，它们虽然在库中被定义，但是可能被其他库中的同名符号覆盖，用W表示。

$nm libhello.h

ldd命令

ldd命令可以查看一个可执行程序依赖的共享库，例如我们编写的四则运算动态库依赖下面这些库：

总结

二者的不同点在于代码被载入的时刻不同。

  1.   静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，因此体积较大。
  2.   动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在，因此代码体积较小。

动态库的好处是，不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例。带来好处的同时，也会有问题！如经典的DLL Hell问题，关于如何规避动态库管理问题，可以自行查找相关资料。

转自：吴秦

作者：吴秦
出处：http://www.cnblogs.com/skynet/

 

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode