大家好，我是一个动态链接库！
这个名字，相信你一定早就如雷贯耳了。
在计算机早期时代，由于内存资源紧张，我可是发挥了重大的作用！
不论是在 Windows 系统中，还是在 Unix 系列平台上，到处都能见到我的身影，因为我能为大家节省很多资源啊，资源就是人民币！
愉快的玩耍
比如：我的主人编写了这么一段简单的代码：
＃ 文件：lib．c
＃include ＜stdio．h＞
int func＿in＿lib（int k）
｛
printf（＂func＿in＿lib is called ＂）；
return k ＋ 1；
｝
只要用如下命令来编译，我就诞生出来了 lib．so，也就是一个动态链接库：
＄ gcc －m32 －fPIC －－shared －o lib．so lib．c
这个时候，主人随便把我丢给谁，我都可以为他服务，只要他调用我肚子里的这个函数 func＿in＿lib 就可以了。
虽然目前你看到我提供的这个函数很简单，但是道理都是一样的，后面如果有机会，我就在这个函数里来计算机器人的运动轨迹，给你瞧一瞧！
例如：张三今天写了一段代码，需要调用我的这个函数。
张三这个人比较喜欢骚操作，明明他在编译可执行程序的时候，把我动态链接一下就可以了，就像下面这样：
＄ gcc －m32 －o main main．c ．／lib．so
但是张三偏偏不这么做，为了炫技，他选择使用 dlopen 动态加载的方式，来把我从硬盘上加载到进程中。
咱们来一起围观一下张三写的可执行程序代码：
＃ 文件：main．c
＃include ＜unistd．h＞
＃include ＜stdio．h＞
＃include ＜stdlib．h＞
＃include ＜dlfcn．h＞
typedef int （＊pfunc）（int）；
int main（int argc， char ＊agv［］）
｛
int a ＝ 1；
int b；
／／ 打开动态库
void ＊handle ＝ dlopen（＂．／lib．so＂， RTLD＿NOW）；
if （handle）
｛
／／ 查找动态库中的函数
pfunc func ＝ （pfunc） dlsym（handle， ＂func＿in＿lib＂）；
if （func）
｛
b ＝ func（a）；
printf（＂b ＝ ％d ＂， b）；
｝
else
｛
printf（＂dlsym failed！ ＂）；
｝
dlclose（handle）；
｝
else
｛
printf（＂dlopen failed！ ＂）；
｝
return 0；
｝
从代码中可以看到，张三预先知道我肚子里的这个函数名称是 func＿in＿lib，所以他使用了系统函数 dlsym（handle， ＂func＿in＿lib＂）； 来找到这个函数在内存中的加载地址，然后就可以直接调用这个函数了。
张三编译得到可执行文件 main 之后，执行结果完全正确，很开心！
悲从中来
可是有一天，我遇到一件烦人的事情，我的主人说：你这个服务函数的计算过程太单调了，给你找点乐子，你在执行的时候啊，到其他一个外部模块里调用一个函数。
话刚说完，就丢给我一个函数名：void func＿in＿main（void）；。
也就是说，我需要在我的服务函数中，去调用其他模块里的函数，就像下面这样：
＃include ＜stdio．h＞
／／ 外部函数声明
void func＿in＿main（void）；
int func＿in＿lib（int k）
｛
printf（＂func＿in＿lib is called ＂）；
／／ 调用外部函数
func＿in＿main（）；
return k ＋ 1；
｝
那么这个函数在哪里呢？天哪，我怎么知道这个函数是什么鬼？怎么才能找到它藏在内存的那个角落（地址）里？
不管怎么样，主人修改了代码之后，还是很顺利的把我编译了出来：
＄ gcc －m32 －fPIC －－shared －o lib．so lib．c
编译指令完全没有变化。
因为我仅仅是一个动态链接库，这个时候即使我不知道 func＿in＿main 函数的地址，也是可以编译成功的。
只不过我要把这个家伙标记一下：谁要是想使用我，就必须告诉我这个家伙的地址在哪里！，否则就别怪我耍赖。
无辜的张三
我的主人对张三说：兄弟，我的这个动态链接库升级了，功能更强大哦，想不想试一下？
张三心想：我是使用 dlopen 的方式来动态加载动态库文件的，不需要对可执行程序重新编译或者链接，直接运行就完事了！
于是他二话不说，直接就把我拿过去，丢在他的可执行程序目录下，然后执行 main 程序。
可是这一次，他看到的结果却是：
dlopen failed！
为什么会加载失败呢？上次明明是正常执行的！张三一脸懵逼！
其实，这压根就不能怪我！以为我刚才就说了：谁要是想使用我，就必须告诉我 func＿in＿main 这个函数的地址在哪里！
可是在张三的这个进程里，我到处都找不到这个函数的地址。既然你没法满足我，那我就没法满足你！
锦囊1： 导出符号表
张三这下也没辙了，只要找我的主人算账：我的应用程序代码一丝一毫都没有动，怎么换了你给的新动态链接库就不行了呢？
主人慢条斯理的回答：疏忽了，疏忽了，忘记跟你说一件事情了：这个动态库啊，它需要你多做一件事情：在你的程序中提供一个名为 func＿in＿main 的函数，这样就可以了。
张三一想：这个好办，加一个函数就是了。
因为这个可执行程序只有一个 main．c 文件，于是他在其中新加了一个函数：
void func＿in＿main（void）
｛
printf（＂func＿in＿main ＂）；
｝
然后就开始编译、执行，一顿操作猛如虎：
＃ gcc －m32 －o main main．c －ldl
＃ ．／main
dlopen failed！
咦？怎么还是失败？！已经按照要求加了 func＿in＿main 这个函数了啊？！
这个傻X张三，对，你确实是在 main．c 中加了这个函数，但是你仅仅是加在你的可执行程序中的，但是我却压根就看不到这个函数啊！
不信的话，你检查一下编译出来的可执行程序中，是否把 func＿in＿main 这个符号导出来了？如果不导出来，我怎么能看到？
＃ 查看导出的符号表
＄ objdump －e main －T ｜ grep func＿in＿main
＃ 这里输出为空
既然输出为空，就说明没有导出来！这个就不用我教你了吧？
茴香豆的“茴”字，一共有四种写法。。。
哦，不，导出符号，一共有两种方式：
方式1：导出所有的符号
＄ gcc －m32 －rdynamic －o main main．c －ldl
当然，下面这个指令也可以：
gcc －m32 －Wl，－－export－dynamic －o main main．c －ldl
方式2：导出指定的符号
先定义一个文件，把需要导出的符号全部罗列出来：
文件：exported．txt
｛
extern ＂C＂
｛
func＿in＿main；
｝；
｝；
然后，在编译选项中指定这个导出文件：
gcc －m32 －Wl，－dynamic－list＝．／exported．txt －o main main．c －ldl
使用以上两种方式的任意一种即可，编译之后，再使用 objdump 指令看一下导出符号：
＄ objdump －e main －T ｜ grep func＿in＿main
080485bb g DF ．text 00000019 Base func＿in＿main
嗯，很好很好！张三赶紧按照这样的方式操作了一下，果真成功执行了函数！
＄ ．／main
func＿in＿lib is called
func＿in＿main
b ＝ 2
也就是说，在我的动态库文件中，正确的找到了外部其他模块中的函数地址，并且愉快的执行成功了！
锦囊2： 动态注册
虽然执行成功了，张三的心里隐隐约约的仍然有一丝不爽的感觉，每次编译都要导出符号，真麻烦，能不能优化一下？
于是他找到我的主人，表达了自己的不满。
主人一瞧，有个性！既然你不想提供，那我就满足你：
首先，在动态库中提供一个默认的函数实现（func＿in＿main＿def）；
然后，再提供一个专门的注册函数（register＿func），如果外部模块想提供 func＿in＿main 这个函数，就调用注册函数注册进来；
此时，lib．c 最新的代码就变成这个样子了：
＃include ＜stdio．h＞
／／ 默认试下
void func＿in＿main＿def（void）
｛
printf（＂the main is lazy， do NOT register me！ ＂）；
｝
／／ 定义外部函数指针
void （＊func＿in＿main）（） ＝ func＿in＿main＿def；
void register＿func（void （＊pf）（））
｛
func＿in＿main ＝ pf；
｝
int func＿in＿lib（int k）
｛
printf（＂func＿in＿lib is called ＂）；
if （func＿in＿main）
func＿in＿main（）；
return k ＋ 1；
｝
然后编译，全新的我再一次诞生了 lib．so：
gcc －m32 －fPIC －－shared －o lib．so lib．c
主人把我丢给张三的时候说：好了，满足你的需求，这一次你不用提供 func＿in＿main 这个函数了，当然也就不用再导出符号了。
不过，如果如果有一天，你改变了注意，又想提供这个函数了，那么你就要通过动态库中的 register＿func 函数，把你的函数注册进来。
Have you got it？赶紧再去试一下！
这个时候，张三再次使用我的时候，就不需要导出他的 main．c 里的那个函数 func＿in＿main 了，实际上他可以把这个函数从代码中删掉！
编译、执行，张三再一次猛如虎的操作：
＄ gcc －m32 －o main main．c －ldl
＄ ．／main
func＿in＿lib is called
the main is lazy， do NOT register me！
b ＝ 2
嗯，结果看起来是正确的。
咦？怎么多了一行字：the main is lazy， do NOT register me！
难道是在质疑我的技术能力吗？好吧，既然如此，我也满足你，不就是注册一个函数嘛，简单：
／／ 文件： main．c
＃include ＜unistd．h＞
＃include ＜stdio．h＞
＃include ＜stdlib．h＞
＃include ＜dlfcn．h＞
typedef int （＊pfunc）（int）；
typedef int （＊pregister）（void （＊）（））；
／／ 控制注册函数的宏定义
＃define REG＿FUNC
＃ifdef REG＿FUNC
void func＿in＿main（void）
｛
printf（＂func＿in＿main ＂）；
｝
＃endif
int main（int argc， char ＊agv［］）
｛
int a ＝ 1；
int b；
／／ 打开动态库
void ＊handle ＝ dlopen（＂．／lib．so＂， RTLD＿NOW）；
if （handle）
｛
＃ifdef REG＿FUNC
／／ 查找动态库中的注册函数
pregister register＿func ＝ （pregister） dlsym（handle， ＂register＿func＂）；
if （register＿func）
｛
register＿func（func＿in＿main）；
｝
＃endif
／／ 查找动态库中的函数
pfunc func ＝ （pfunc） dlsym（handle， ＂func＿in＿lib＂）；
if （func）
｛
b ＝ func（a）；
printf（＂b ＝ ％d ＂， b）；
｝
else
｛
printf（＂dlsym failed！ ＂）；
｝
dlclose（handle）；
｝
else
｛
printf（＂dlopen failed！ ＂）；
｝
return 0；
｝
然后编译、执行：
＄ gcc －m32 －o main main．c －ldl
＄ ．／main
func＿in＿lib is called
func＿in＿main
b ＝ 2
完美收官！
PS：很多平台级的代码，例如一些工控领域的运行时（Runtime）软件，大部分都是通过注册的方式，来把平台代码、用户代码进行连接、绑定的。
