Linux中gcc的编译、静态库和动态库的制作

欢迎大家关注笔者&＃xff0c;你的关注是我持续更博的最大动力

gcc是文本编译器&＃xff0c;就是编译代码的工具&＃xff0c;下面介绍gcc编译C语言&＃xff08;.c文件&＃xff09;的流程。

1 gcc的编译过程

1.1 gcc的编译过程

gcc的编译分为以下四个阶段&＃xff1a;

• gcc预处理器&＃xff1a;把.c文件编译成预处理的.i文件
• gcc编译器&＃xff1a;把预处理的.i文件编译成.s的汇编文件
• gcc汇编器&＃xff1a;把.s的汇编文件编译成.o的二进制文件
• gcc链接器&＃xff1a;把.o的二进制文件链接成一个可执行文件

---

四个阶段的编译命令&＃xff1a;

• 预处理&＃xff1a;gcc -E hello.c -o hello.i
• 编译&＃xff1a;gcc -S hello.i -o hello.s
• 汇编&＃xff1a;gcc -c hello.s -o hello.o
• 链接&＃xff1a;gcc hello.o -o hello

上面的四个过程也可以用一个命令执行&＃xff0c;直接生成可执行的文件&＃xff1a;

gcc hello.c -o hello
# 或
gcc hello.c # 没有指定输出问价名&＃xff0c;默认是生成一个a.out可执行文件。


注意&＃xff1a;

1、记忆参数可以用ESc&＃xff0c;-o参数是指定输出文件的名字
2、在windows下&＃xff0c;如果gcc hello.c&＃xff0c;默认生成的可执行文件为a.exe&＃xff1b;如果gcc hello.c -o myapp&＃xff0c;会直接生成可执行文件myapp.exe&＃xff0c;自动添加后缀。
3、在第二阶段把预处理的.i文件编译成.s的汇编文件最浪费时间。
4、即使是直接生成可执行文件&＃xff0c;但是也是经过了预处理、编译、汇编、链接这些过程&＃xff0c;只是没有生成中间的这些文件。

---

四个阶段的具体功能&＃xff1a;

• 预处理&＃xff1a;1&＃xff09;把.c文件中的头文件展开添加到.i预处理文件的开头&＃xff1b;2&＃xff09;然后把.c文件代码添加到.i的头文件内容之后&＃xff1b;3&＃xff09;把宏定义的量值替换为具体的值&＃xff0c;去掉原代码中的注释。

• 编译&＃xff1a;把c文件翻译成汇编文件&＃xff0c;就是两种程序语法的转化。

• 汇编&＃xff1a;把汇编文件编程二进制文件&＃xff0c;此时的文件已经看不出具体的内容。

• 链接&＃xff1a;将函数库中相应的代码组合到目标文件中。

1.2 gcc的常用参数

下面具体实例&＃xff1a;

一、执行文件和头文件同级目录

1、创建一个sum.c文件&＃xff0c;内容如下&＃xff1a;

#include
// 双引号导入的头文件是自己写的
#include "head.h"
#define DEBUG// main是入口函数
int main(void)
{int a &＃61; NUM1;int aa;int b &＃61; NUM2;int sum &＃61; a &＃43; b;// 这是一个加法运算
#ifdef DEBUGprintf("The sum value is : %d &＃43; %d &＃61; %d\n", a, b, sum);
#endifreturn 0;
}


2、在sum.c的同级创建head.h头文件&＃xff0c;内容如下&＃xff1a;

#ifndef __HEAD_H_
#define __HEAD_H_#define NUM1 10
#define NUM2 20
#endif


两个文件的层级结构&＃xff0c;同级目录&＃xff1a;

├── head.h
├── sum.c


3、预处理&＃xff1a;gcc -E sum.c -o sum.i

执行完之后用vi sum.i查看预处理之后的sum.i内容&＃xff0c;如下&＃xff1a;

从文件中可以看到&＃xff0c;文件内容很长&＃xff0c;之前的导入的头文件&＃xff0c;被替换为具体的头文件代码内容&＃xff0c;代码中的宏定义量被替换为具体的值&＃xff0c;代码中的注释被去掉。&＃xff08;相当于做菜食材的准备阶段&＃xff09;

4、编译&＃xff1a;gcc -S sum.i -o sum.s

编译就是把预处理的.i文件编译成.s的汇编语言&＃xff0c;编译之后的sum.s内容&＃xff0c;如下&＃xff1a;

从文件中可以看出&＃xff0c;这个文件显示的已经不是C语言编写的代码&＃xff0c;已经被转换为汇编语言的代码&＃xff0c;如果你对单片机了解&＃xff0c;你可能也对汇编语言的语法有所了解。&＃xff08;编译&＃xff1a;就是把C语言翻译成汇编语言&＃xff09;

5、汇编&＃xff1a;gcc -c sum.s -o sum.o

汇编就是把汇编文件变成二进制文件&＃xff0c;汇编之后的sum.o内容&＃xff0c;如下&＃xff1a;

从文件中可以看出&＃xff0c;汇编成二进制文件之后&＃xff0c;里面的内容已经看不出来了。

6、链接&＃xff1a;gcc sum.o -o sum

使用gcc链接器把二进制文件链接成一个可执行文件&＃xff0c;将函数库中相应的代码组合到目标文件中。通过./sum即可执行该可执行文件&＃xff0c;执行结果如下&＃xff1a;

如果你打开可执行文件sum&＃xff0c;显示的内容和sum.o差不多。

二、执行文件和头文件同级目录

目录层级结构&＃xff1a;

├── include
│ └── head.h
├── sum.c


如果直接编译&＃xff08;gcc sum.c -o sum&＃xff09;&＃xff0c;会提示找不到头文件&＃xff0c;如下&＃xff1a;

找不到头文件有两种解决方法&＃xff1a;

• 直接在程序编写的时候指定头文件的位置
• 在编译的时候用-I参数&＃xff0c;指定头文件所在的文件夹位置

gcc sum.c -I ./include -o sum

三、gcc的其他参数使用

1、参数-D&＃xff1a;指定一个宏定义

上面的程序中有printf()打印程序调试的log信息&＃xff0c;但是程序发布的时候&＃xff0c;我们是不需要这些log信息的&＃xff0c;当然我们可以通过加调试的#define DEBUG宏的声明&＃xff0c;但是&＃xff0c;程序中需要调试输出的log信息比较多的时候&＃xff0c;这种方法显然不合适。

现在我们把DEBUG的宏定义注释掉

#include
// 双引号导入的头文件是自己写的
#include "head.h"
//#define DEBUG// main是入口函数
int main(void)
{int a &＃61; NUM1;int aa;int b &＃61; NUM2;int sum &＃61; a &＃43; b;// 这是一个加法运算// 程序有 DEBUG宏定义&＃xff0c;程序才会执行prinf()
#ifdef DEBUGprintf("The sum value is : %d &＃43; %d &＃61; %d\n", a, b, sum);
#endifreturn 0;
}


然后再执行:

>>>gcc sum.c -o sum
>>>./sum


结果&＃xff1a;

并不会输出print打印的信息了&＃xff0c;如果再次打印出信息呢&＃xff0c;此时可以通过参数-D&＃xff0c;在执行命令的时候给程序指定一个宏&＃xff0c;如下&＃xff1a;

>>>gcc sum.c -o sum -D DEBUG
>>>./sum


此时就可以打印出printf()信息了。

总结&＃xff1a;

-D参数的作用&＃xff1a;不在程序中定义宏&＃xff0c;在程序编译的时候定义。不指定&＃xff0c;在程序预处理的时候&＃xff0c;printf()就会被删掉了。

2、-O参数&＃xff1a;程序预处理的时候对代码优化

在程序预处理的时候对代码进行优化&＃xff0c;把冗余的代码去掉&＃xff0c;有三个优化等级&＃xff1a;

• -O1&＃xff1a;优化等级低
• -O2&＃xff1a;优化等级中
• -O3&＃xff1a;优化等级高

举个例子&＃xff1a;

int a &＃61; 10
int b &＃61; a
int c &＃61; b
int d &＃61; c# 优化完之后就是
int d &＃61; 10 // 就是对d的一个赋值操作


3、-Wall参数&＃xff1a;输出程序中的警告信息

例如我们在程序中定义一个变量int aa;&＃xff0c;但是没有使用&＃xff0c;此时就会输出警告信息。

4、-g参数&＃xff1a;在程序中添加一些调试信息

gcc sum.c -o sum -g

• 加-g参数之后&＃xff0c;输出的可执行文件会比不加的大&＃xff08;因为包含调试信息&＃xff09;
• 程序发布是不需要加-g参数
• 调试需要加-g参数&＃xff0c;否则没有调试信息不可以调试。&＃xff08;gdb调试的时候必须加此参数&＃xff09;

总结&＃xff1a;

参数&＃xff1a;-E、-S&＃xff0c;不是很重要&＃xff0c;-c比较重要&＃xff0c;后面我们在制作静态库和动态库的时候需要用到生成的.o二进制值文件。

2 gcc 静态库的制作

比如你和别人做项目合作&＃xff0c;你不可能直接把源代码给别人&＃xff0c;那样别人就可以自己开发&＃xff0c;因为源代码就是你的核心技术。你不应该卖给他源代码&＃xff0c;而是应该是程序&＃xff0c;这样你就可以根据他有什么需求进行改或添加什么功能模块等&＃xff0c;就可以改一次就可以收费一次&＃xff0c;这样就可以有一个长期合作。

那应该给到客户的是什么呢&＃xff1f;

• 生成的库
• 头文件

这样把生成的库和头文件给客户也能够使用&＃xff0c;只是他不知道里面具体怎么实现的。这样二者才能维持一个长期的合作。

头文件对应的.c文件都被打包到了静态库和动态库里面了。

2.1 静态库的制作流程

一、静态库的制作

1、命名规则

• 1&＃xff09;lib &＃43; 库的名字 &＃43; .a
• 2&＃xff09;例如&＃xff1a;libmytest.a

2、制作步骤:

• 1&＃xff09;生成对应的.o二进制文件 .c --> .o eg&＃xff1a;gcc sum.c -c sum.o
• 2&＃xff09;将生成的.o文件打包&＃xff0c;使用ar rcs &＃43; 静态库的名字(libMytest.a) &＃43; 生成的所有的.o
• 3&＃xff09;发布和使用静态库:
  • 发布静态库
  • 头文件

说明&＃xff1a;

• 把.c文件&＃xff0c;也就是源代码转化成.o的二进制文件之后&＃xff0c;客户就不知道到你的核心技术具体是怎么实现的了。
• ar是对.o的二进制文件进行打包&＃xff0c;rcs是打包参数&＃xff0c;把所有的.o二进制文件打包成一个.a文件&＃xff0c;即&＃xff1a;静态库。因此&＃xff1a;静态库是一个打包了二进制文件的集合。
• 接口API是在头文件中体现出来的。

实例&＃xff1a;

目录结构&＃xff1a;

Calc
├── include
│ └── head.h
├── lib
├── main.c
└── src├── add.c├── div.c├── mul.c└── sub.c

说明&＃xff1a;

• include文件夹&＃xff1a;存放头文件&＃xff0c;提供给用户调用的接口API
• lib文件夹&＃xff1a;存放库文件&＃xff0c;即&＃xff1a;生成的静态库、动态库
• src文件夹&＃xff1a;存放源文件
• main.c程序&＃xff1a;是用户调用head.h头文件里面的接口&＃xff0c;然后在调用静态库里面我们实现的算法&＃xff08;只不过已经不是源码&＃xff0c;而是被编译成二进制文件&＃xff09;

下面开始吧&＃xff1a;

源代码 src/add.c实现的是加法运算&＃xff1a;

#include "head.h"int add(int a, int b)
{int result &＃61; a &＃43; b;return result;
}


头文件 include/head.h实现是对源代码调用的接口API&＃xff1a;

#ifndef __HEAD_H_
#define __HEAD_H_
int add(int a, int b);
int sub(int a, int b);
int mul(int a, int b);
int div(int a, int b);
#endif


main.c是对头文件调用&＃xff0c;然后调用静态文件&＃xff0c;对算法的使用&＃xff0c;但是并不知道算法的具体实现源代码

#include
#include "head.h"int main(void)
{int sum &＃61; add(2, 24);printf("sum &＃61; %d\n", sum);return 0;
}


用户在main.c中引入头文件#include "head.h",即在./include/head.h&＃xff0c;就可以使用./include/head.h中定义的接口int add(int a, int b);,当main.c程序执行到add(int a, int b);接口时&＃xff0c;就会到./src文件夹下找静态文件&＃xff08;打包的二进制文件——即&＃xff1a;加法算法的具体实现&＃xff09;

---

下面是具体的制作流程&＃xff1a;

shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ tree
.
├── include
│ └── head.h
├── lib
├── main.c
└── src├── add.c├── div.c├── mul.c└── sub.c3 directories, 6 files
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ cd src
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ls
add.c div.c mul.c sub.c1、源代码生成二进制文件&＃xff08;.o文件&＃xff09;
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ gcc *.c -c -I ../include
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ls
add.c add.o div.c div.o mul.c mul.o sub.c sub.o2、对生成的二进制文件&＃xff08;.o文件&＃xff09;&＃xff0c;打包成静态文件&＃xff08;.a文件&＃xff09;&＃xff0c;并移动到lib目录下
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ar rcs libMyCalc.a *.o
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ls
add.c add.o div.c div.o libMyCalc.a mul.c mul.o sub.c sub.o
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ mv libMyCalc.a ../lib
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ cd ..
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ ls3、调用include目录下的头文件&＃xff08;即&＃xff1a;封装的API接口&＃xff09;
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ gcc main.c lib/libMyCalc.a -I ./include -o sum
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ ls
include lib main.c src sum
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ ./sum
sum &＃61; 26
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$


主要&＃xff1a;

• 制作好的静态文件要放到lib目录下
• 调用头文件中的接口API&＃xff0c;然后用gcc编译的自己调用的main.c文件&＃xff0c;需要加上静态文件&＃xff08;.a文件&＃xff09;。
• 程序发布的时候只需要给用户的文件&＃xff1a;
  • 1&＃xff09;include目录下的头文件&＃xff08;head.h&＃xff09;&＃xff1a;封装的是具体算法实现的接口API
  • 2&＃xff09;lib目录下的静态文件&＃xff08;.a文件&＃xff09;&＃xff1a;是源代码编译的之后的二进制文件&＃xff08;.o文件&＃xff09;&＃xff0c;然后被打包成静态文件&＃xff08;.a文件&＃xff09;

用于另外一种调用静态库的方法为&＃xff1a;

gcc main.c -Iinclude -L lib -l MyCalc -o myapp

参数说明&＃xff1a;

• -I参数&＃xff1a;指定头文所在的文件夹名&＃xff0c;文件夹名可以和参数贴着写在一起
• -L参数&＃xff1a;指定静态库的文件夹名
• -l参数&＃xff1a;指定静态库的名字&＃xff0c;但名字要掐头去尾&＃xff0c;eg&＃xff1a;原静态库名字为libMyCalc.a&＃xff0c;在指定-l参数值的时候为&＃xff1a;-l MyCalc
• -o参数&＃xff1a;输出编译之后可执行文件的名字

注意&＃xff1a;

之所以用-l指定静态库的名字&＃xff0c;是因为lib目录下可能有多个静态库文件&＃xff0c;但是我们只需要使用其中的某一个&＃xff0c;此时可以用这种方法指定相应的静态库文件。

二、静态库相关文件查看

1、nm命令查看静态库

可以使用nm命令查看静态库文件中具体打包了哪些二进制文件即.o文件

2、nm命令查看生成的可执行文件

T&＃xff1a;代表的含义是把add代码会被放到代码区

2.2 静态库的优缺点

1、通过静态库生成可执行文件

• 静态库中封装了多个.o文件
• main.c 中调用静态库中相应可执行文件&＃xff08;二进制文件&＃xff09;中的函数
• 图中只调用了add.o和sub.o中的函数&＃xff0c;因此main.c在生成可执行文件的时候只会把静态文件中的add.o和sub.o两个文件打包到可执行文件中&＃xff0c;静态文件中的其他没有用到的.o文件不会被打包进可执行文件中。
• 在生成可执行文件的时候也是以.o可执行文件为单位打包的&＃xff0c;并不会把整个静态文件.a都打包到可执行文件中。

静态库的优点&＃xff1a;

• 1&＃xff09;发布程序的时候&＃xff0c;不需要提供对应的库了&＃xff0c;因为库已经被打包到了可执行文件中去了。
• 2&＃xff09;库的加载速度比较快&＃xff0c;因为库已经被打包到可执行文件中去了。

静态库的缺点&＃xff1a;

• 1&＃xff09; 库被打包到应用程序&＃xff08;最后生成的可执行文件&＃xff09;中&＃xff0c;如果库很多的话就会导致应用程序的体积很大。
• 2&＃xff09;库发生了改变&＃xff0c;需要重新编译程序&＃xff0c;如果源代码比较多&＃xff0c;可能编译一遍一天就过去了。

3 gcc 动态库 / 共享库 的制作

动态库也叫共享库&＃xff0c;在windows中对用.dll文件

3.1 动态库 / 共享库的制作流程

一、动态库相关说明

1、命名规则:

• 1&＃xff09;lib &＃43; 名字 &＃43; .so
• 2&＃xff09;例如&＃xff1a;libMyCalc.so

2、制作步骤:

• 1&＃xff09;生成与位置无关的代码 (生成与位置无关的.o)
• 2&＃xff09;将.o打包成共享库(动态库)
• 3&＃xff09;发布和使用共享库:

注意&＃xff1a;

• 静态库生成的.o文件是和位置有关的
• 用gcc生成和位置无关的.o文件&＃xff0c;需要使用参数-fPIC&＃xff08;常用&＃xff09; 或 -fpic

二、动态库制作相关实例

在了解什么叫生成和位置无关的.o文件&＃xff0c;我们来先了解一下虚拟地址空间。

linux上打开一个运行的程序&＃xff08;进程&＃xff09;&＃xff0c;操作系统就会为其分配一个&＃xff08;针对32位操作系统&＃xff09;0-4G的地址空间&＃xff08;虚拟地址空间&＃xff09;&＃xff0c;虚拟地址空间不是在内存中&＃xff0c;而是来自硬盘的存储空间。

从下到上&＃xff1a;

0-3G&＃xff1a;是用户区

• .text 代码段&＃xff1a;存放的是代码
• .data &＃xff1a;存放的是已初始化的变量
• .bss&＃xff1a;存放的是未初始化的变量
• 堆空间&＃xff1a;
• 共享库&＃xff1a;动态库的空间&＃xff0c;每次程序运行的时候把动态库加载到这个空间
• 栈空间&＃xff1a;我们定义的局部变量都是在栈空间分配的内存
• 命令行参数
• 环境变量

在往上 3-4G是内核区

• 静态库生成与位置有关的二进制文件&＃xff08;.o文件&＃xff09;

虚拟地址空间是从0开始的&＃xff0c;生成的二进制文件(.o文件)会被放到代码段&＃xff0c;即.text代码区。生成的.o代码每次都被放到同一个位置&＃xff0c;是因为使用的是绝对地址。

• 动态库生成与位置无关的二进制文件&＃xff08;.o文件&＃xff09;

动态库 / 共享库 在程序打包的时候并不会把.o文件打包到可执行文件中&＃xff0c;只是做了一个记录&＃xff0c;当程序运行之后才去把动态库加载到程序中&＃xff0c;也就是加载到上图中的共享库空间&＃xff0c;但是每次加载到共享库空间的位置可能不同。
还是和上面静态库制作同样的目录结构&＃xff1a;

---

动态库制作实例

Calc
├── include
│ └── head.h
├── lib
├── main.c
└── src├── add.c├── div.c├── mul.c└── sub.c


shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ cd src/
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ls
add.c div.c mul.c sub.c1、把源码生成和位置无关的二进制文件
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ gcc -fPIC -c *c -I ../include
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ls
add.c add.o div.c div.o mul.c mul.o sub.c sub.o2、使用gcc把生成的二进制文件&＃xff08;.o文件&＃xff09;&＃xff0c;打包成动态库&＃xff08;.so文件&＃xff09;
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ gcc -shared -o libMyCalc.so *o -Iinclude
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ ls
add.c add.o div.c div.o libMyCalc.so mul.c mul.o sub.c sub.o3、把生成的动态库文件移动到lib目录下
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ mv libMyCalc.so ../lib
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc/src$ cd ..
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ ls
include lib main.c src
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$


参数说明&＃xff1a;

• -PIC&＃xff1a;生成和位置无关的.o文件
• -shared&＃xff1a;共享&＃xff0c;就是把.o文件&＃xff0c;打包成动态库 / 共享库

上面就已经完成动态库的制作&＃xff0c;然后把下面的两个文件发布给用户即可调用

• include/head.h&＃xff1a; 头文件&＃xff0c;定义接口API
• lib/libMyCalc.so&＃xff1a;动态库&＃xff0c;封装了编译之后的源代码二进制文件

用户使用动态库

用户使用动态库和静态库一样有两种方法&＃xff1a;

• 用户使用动态库方法一&＃xff1a;

gcc main.c lib/libMyCalc.so -o app -Iinclude

• 用户使用动态库方法二&＃xff1a;

gcc main.c -Iinclude -L lib -l MyCalc -o myapp

3.2 动态库查找不到解决方法

我们可以看到&＃xff0c;第二种方法&＃xff0c;至执行可执行程序的时候&＃xff0c;提示找不到动态库&＃xff0c;这并不一定是动态库文件不存在&＃xff0c;可能是由于链接不到

是不是真的链接不到&＃xff0c;我们可以通过一个命令ldd&＃xff1a;查看可执行文件在执行的时候&＃xff0c;依赖的所有共享库/动态库&＃xff08;.so文件&＃xff09;

ldd命令使用&＃xff1a;

ldd 可执行文件名

shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$ ldd myapp linux-vdso.so.1 &＃61;> (0x00007fff59d26000) # 后面的数字是库的地址# 提示我们自己的动态库 / 共享库 libMyCalc.so没有找到libMyCalc.so &＃61;> not found# libc.so.6 是linux下的标准C库 &＃xff08;写C程序都会调用标准C库里的一些函数&＃xff09;libc.so.6 &＃61;> /lib/x86_64-linux-gnu/libc.so.6 (0x00007f1e27462000)# 动态链接器&＃xff0c;动态链接器的本质就是一个动态库/lib64/ld-linux-x86-64.so.2 (0x00007f1e2782c000)
shliang&＃64;shliang-vm:~/shliang/gcc_learn/Calc$


如上图&＃xff1a;可执行程序./a.out在执行的时候&＃xff0c;调用需要调用动态库libmytest.so&＃xff0c;但是实际上这个调用是通过动态链接器的来调用的。动态库就是通过动态链接器--/lib64/ld-linux-x86-64.so.2加载到我们的可执行程序&＃xff08;应用程序&＃xff09;中的。

那么动态链接器是-- /lib64/ld-linux-x86-64.so.2是通过什么规则查找可执行文件在执行时&＃xff0c;需要的动态文件的呢&＃xff1f;

其实就是通过环境变量

在linux下查看环境变量&＃xff1a;

echo $PATH

当然PATH下并不是存放动态库的路径&＃xff0c;这里只是做一个演示&＃xff0c;如何查看环境变量。

一、动态库查找不到解决方法一&＃xff08;不推荐——不允许使用&＃xff09;

把自己制作的动态库放到根目录下的系统动态库中&＃xff0c;即/lib目录下

sudo cp ./lib/libMyCalc.so /lib

从上面的结果可以看到&＃xff0c;把自己制作的动态库拷贝到系统动态库中之后&＃xff0c;动态链接器根据环境变量就可以找到这个动态库&＃xff0c;然后正确加载到可执行程序中。

注意&＃xff1a;

这种方法一般不会使用的&＃xff0c;因为如果你的动态库的名字和系统中某个动态库的名字一样&＃xff0c;就可能会导致系统奔溃的&＃xff01;&＃xff01;&＃xff01;这里只是做一个演示&＃xff0c;证明动态链接器是根据环境变量去查找要加载的动态库。

二、动态库查找不到解决方法二&＃xff08;临时测试设置&＃xff09;

通过把动态库添加到动态库环境变量中&＃xff0c;即&＃xff1a;LD_LIBRARY_PATH

使用export添加环境变量&＃xff0c;把当前动态库所在的位置&＃xff08;文件夹位置&＃xff09;添加到LD_LIBRARY_PATH变量中&＃xff0c;可执行程序在执行的时候会在默认的动态库之前从LD_LIBARAY_PATH变量中查找有没有所需动态库。

# export
export LD_LIBARAY_PATH&＃61;./lib


注意&＃xff1a;

但是&＃xff0c;这种方法只是临时的&＃xff0c;当我们关闭终端&＃xff0c;下次再执行程序又会提示找不到动态库。因此&＃xff0c;这钟方法一般是再开发动态库的过程中&＃xff0c;用于临时的测试。

三、动态库查找不到解决方法三&＃xff08;永久设置——不常用&＃xff09;

在当前用户的家目录&＃xff08;home&＃xff09;下的.bashrc文件中配置LD_LIBRARY_PAHT环境变量。

cd ~
vi .bashrc# 然后再最后一行添加一个环境变量&＃xff0c;如果没有就创建(Shift&＃43;G跳到最后一行)
# 然后把动态库的绝对路径赋值给该变量
export LD_LIBARAY_PATH&＃61;/home/shliang/shliang/gcc_learn/Calc/lib# 保存退出&＃xff0c;用source激活配置&＃xff0c;如果不激活需要重启终端&＃xff0c;因为终端每次重启都会从.bashrc中加载一次配置
source .bashrc


上面添加完环境变量之后就可以找到动态库了。

四、动态库查找不到解决方法四&＃xff08;永久设置&＃xff09;

这种方法&＃xff0c;相对与前三种复杂一些&＃xff0c;一定要掌握&＃xff0c;可能以后用作中用到的就是这种。做法如下&＃xff1a;

1、需要找到动态连接器的配置文件&＃xff1a;/etc/ld.so.conf
2、把我们自己制作的动态库目录的绝对路径写到配置文件中
3、更新配置文件&＃xff1a;sudo ldconfig -v

• ld&＃xff1a;dynamic library 动态库的缩写
• -v &＃xff1a;是更细配置文件的时候输出更新信息。

修改配置文件的路径位置&＃xff1a;/etc/ld.so.conf

把/home/shliang/shliang/gcc_learn/Calc/lib添加到/etc/ld.so.conf配置文件中

之后就可以找到动态库了&＃xff0c;如下&＃xff1a;

3.3 动态库的优缺点

1、动态库的优点

• 执行程序的体积小&＃xff1a;程序在执行的时候采取加载动态库&＃xff0c;并没有和可执行程序打包在一起
• 动态库更新了&＃xff0c;不需要重新编译程序&＃xff08;不是绝对的&＃xff0c;前提是函数的接口不变&＃xff0c;内容便里没事&＃xff09;

2、动态库的缺点

• 程序发布的时候&＃xff0c;需要把动态库提供给用户
• 动态库没有被打包到应用程序中&＃xff0c;加载速度相对较慢

---

---

♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠