应用程序设计：在动态库中如何调用外部函数？

也想出现在这里？点击联系我~

大家好，我是一个动态链接库!

这个名字，相信你一定早就如雷贯耳了。

在计算机早期时代，由于内存资源紧张，我可是发挥了重大的作用!

不论是在 Windows 系统中，还是在 Unix 系列平台上，到处都能见到我的身影，因为我能为大家节省很多资源啊，资源就是人民币!

愉快的玩耍

比如：我的主人编写了这么一段简单的代码：

1. #文件：lib.c
3. #include<stdio.h>
5. intfunc_in_lib(intk)
6. {
7. printf("func_in_libiscalled\\n");
8. returnk+1;
9. }

只要用如下命令来编译，我就诞生出来了 lib.so，也就是一个动态链接库：

1. $gcc-m32-fPIC–shared-olib.solib.c

这个时候，主人随便把我丢给谁，我都可以为他服务，只要他调用我肚子里的这个函数 func_in_lib 就可以了。

虽然目前你看到我提供的这个函数很简单，但是道理都是一样的，后面如果有机会，我就在这个函数里来计算机器人的运动轨迹，给你瞧一瞧!

例如：张三今天写了一段代码，需要调用我的这个函数。

张三这个人比较喜欢骚操作，明明他在编译可执行程序的时候，把我动态链接一下就可以了，就像下面这样：

1. $gcc-m32-omainmain.c./lib.so

但是张三偏偏不这么做，为了炫技，他选择使用 dlopen 动态加载的方式，来把我从硬盘上加载到进程中。

咱们来一起围观一下张三写的可执行程序代码:

1. #文件：main.c
3. #include<unistd.h>
4. #include<stdio.h>
5. #include<stdlib.h>
6. #include<dlfcn.h>
8. typedefint(*pfunc)(int);
10. intmain(intargc,char*agv[])
11. {
12. inta=1;
13. intb;
15. //打开动态库
16. void*handle=dlopen("./lib.so",RTLD_NOW);
17. if(handle)
18. {
19. //查找动态库中的函数
20. pfuncfunc=(pfunc)dlsym(handle,"func_in_lib");
21. if(func)
22. {
23. b=func(a);
24. printf("b=%d\\n",b);
25. }
26. else
27. {
28. printf("dlsymfailed!\\n");
29. }
30. dlclose(handle);
31. }
32. else
33. {
34. printf("dlopenfailed!\\n");
35. }
37. return0;
38. }

从代码中可以看到，张三预先知道我肚子里的这个函数名称是 func_in_lib，所以他使用了系统函数 dlsym(handle, "func_in_lib"); 来找到这个函数在内存中的加载地址，然后就可以直接调用这个函数了。

张三编译得到可执行文件 main 之后，执行结果完全正确，很开心!

悲从中来

可是有一天，我遇到一件烦人的事情，我的主人说：你这个服务函数的计算过程太单调了，给你找点乐子，你在执行的时候啊，到其他一个外部模块里调用一个函数。

话刚说完，就丢给我一个函数名：void func_in_main(void);。

也就是说，我需要在我的服务函数中，去调用其他模块里的函数，就像下面这样：

1. #include<stdio.h>
3. //外部函数声明
4. voidfunc_in_main(void);
6. intfunc_in_lib(intk)
7. {
8. printf("func_in_libiscalled\\n");
10. //调用外部函数
11. func_in_main();
13. returnk+1;
14. }

那么这个函数在哪里呢?天哪，我怎么知道这个函数是什么鬼?怎么才能找到它藏在内存的那个角落(地址)里?

不管怎么样，主人修改了代码之后，还是很顺利的把我编译了出来:

1. $gcc-m32-fPIC–shared-olib.solib.c

编译指令完全没有变化。

因为我仅仅是一个动态链接库，这个时候即使我不知道 func_in_main 函数的地址，也是可以编译成功的。

只不过我要把这个家伙标记一下：谁要是想使用我，就必须告诉我这个家伙的地址在哪里!，否则就别怪我耍赖。

无辜的张三

我的主人对张三说：兄弟，我的这个动态链接库升级了，功能更强大哦，想不想试一下?

张三心想：我是使用 dlopen 的方式来动态加载动态库文件的，不需要对可执行程序重新编译或者链接，直接运行就完事了!

于是他二话不说，直接就把我拿过去，丢在他的可执行程序目录下，然后执行 main 程序。

可是这一次，他看到的结果却是：

1. dlopenfailed!

为什么会加载失败呢?上次明明是正常执行的!张三一脸懵!

其实，这压根就不能怪我!以为我刚才就说了：谁要是想使用我，就必须告诉我 func_in_main 这个函数的地址在哪里!

可是在张三的这个进程里，我到处都找不到这个函数的地址。既然你没法满足我，那我就没法满足你!

锦囊1: 导出符号表

张三这下也没辙了，只要找我的主人算账：我的应用程序代码一丝一毫都没有动，怎么换了你给的新动态链接库就不行了呢?

主人慢条斯理的回答：疏忽了，疏忽了，忘记跟你说一件事情了：这个动态库啊，它需要你多做一件事情：在你的程序中提供一个名为 func_in_main 的函数，这样就可以了。

张三一想：这个好办，加一个函数就是了。

因为这个可执行程序只有一个 main.c 文件，于是他在其中新加了一个函数：

1. voidfunc_in_main(void)
2. {
3. printf("func_in_main\\n");
4. }

然后就开始编译、执行，一顿操作猛如虎：

1. #gcc-m32-omainmain.c-ldl
2. #./main
3. dlopenfailed!

咦?怎么还是失败?!已经按照要求加了 func_in_main 这个函数了啊?!

这个傻X张三，对，你确实是在 main.c 中加了这个函数，但是你仅仅是加在你的可执行程序中的，但是我却压根就看不到这个函数啊!

不信的话，你检查一下编译出来的可执行程序中，是否把 func_in_main 这个符号导出来了?如果不导出来，我怎么能看到?

1. #查看导出的符号表
2. $objdump-emain-T|grepfunc_in_main
3. #这里输出为空

既然输出为空，就说明没有导出来!这个就不用我教你了吧?

茴香豆的“茴”字，一共有四种写法。。。

哦，不，导出符号，一共有两种方式：

方式1：导出所有的符号

1. $gcc-m32-rdynamic-omainmain.c-ldl

当然，下面这个指令也可以：

1. gcc-m32-Wl,–export-dynamic-omainmain.c-ldl

方式2：导出指定的符号

先定义一个文件，把需要导出的符号全部罗列出来：

文件：exported.txt

1. {
2. extern"C"
3. {
4. func_in_main;
5. };
6. };

然后，在编译选项中指定这个导出文件：

1. gcc-m32-Wl,-dynamic-list=./exported.txt-omainmain.c-ldl

使用以上两种方式的任意一种即可，编译之后，再使用 objdump 指令看一下导出符号：

1. $objdump-emain-T|grepfunc_in_main
2. 080485bbgDF.text00000019Basefunc_in_main

嗯，很好很好!张三赶紧按照这样的方式操作了一下，果真成功执行了函数!

1. $./main
2. func_in_libiscalled
3. func_in_main
4. b=2

也就是说，在我的动态库文件中，正确的找到了外部其他模块中的函数地址，并且愉快的执行成功了!

锦囊2: 动态注册

虽然执行成功了，张三的心里隐隐约约的仍然有一丝不爽的感觉，每次编译都要导出符号，真麻烦，能不能优化一下?

于是他找到我的主人，表达了自己的不满。

主人一瞧，有个性!既然你不想提供，那我就满足你：

1. 鸿蒙官方战略合作共建——HarmonyOS技术社区
2. 首先，在动态库中提供一个默认的函数实现(func_in_main_def);
3. 然后，再提供一个专门的注册函数(register_func)，如果外部模块想提供 func_in_main 这个函数，就调用注册函数注册进来;

此时，lib.c 最新的代码就变成这个样子了：

1. #include<stdio.h>
3. //默认试下
4. voidfunc_in_main_def(void)
5. {
6. printf("themainislazy,doNOTregisterme!\\n");
7. }
9. //定义外部函数指针
10. void(*func_in_main)()=func_in_main_def;
12. voidregister_func(void(*pf)())
13. {
14. func_in_main=pf;
15. }
17. intfunc_in_lib(intk)
18. {
19. printf("func_in_libiscalled\\n");
21. if(func_in_main)
22. func_in_main();
24. returnk+1;
25. }

然后编译，全新的我再一次诞生了 lib.so：

1. gcc-m32-fPIC–shared-olib.solib.c

主人把我丢给张三的时候说：好了，满足你的需求，这一次你不用提供 func_in_main 这个函数了，当然也就不用再导出符号了。

不过，如果如果有一天，你改变了注意，又想提供这个函数了，那么你就要通过动态库中的 register_func 函数，把你的函数注册进来。

Have you got it?赶紧再去试一下!

这个时候，张三再次使用我的时候，就不需要导出他的 main.c 里的那个函数 func_in_main了，实际上他可以把这个函数从代码中删掉!

编译、执行，张三再一次猛如虎的操作：

1. $gcc-m32-omainmain.c-ldl
2. $./main
3. func_in_libiscalled
4. themainislazy,doNOTregisterme!
5. b=2

嗯，结果看起来是正确的。

咦?怎么多了一行字：the main is lazy, do NOT register me!

难道是在质疑我的技术能力吗?好吧，既然如此，我也满足你，不就是注册一个函数嘛，简单：

1. //文件:main.c
3. #include<unistd.h>
4. #include<stdio.h>
5. #include<stdlib.h>
6. #include<dlfcn.h>
8. typedefint(*pfunc)(int);
9. typedefint(*pregister)(void(*)());
11. //控制注册函数的宏定义
12. #defineREG_FUNC
14. #ifdefREG_FUNC
15. voidfunc_in_main(void)
16. {
17. printf("func_in_main\\n");
18. }
19. #endif
21. intmain(intargc,char*agv[])
22. {
23. inta=1;
24. intb;
26. //打开动态库
27. void*handle=dlopen("./lib.so",RTLD_NOW);
28. if(handle)
29. {
30. #ifdefREG_FUNC
31. //查找动态库中的注册函数
32. pregisterregister_func=(pregister)dlsym(handle,"register_func");
33. if(register_func)
34. {
36. register_func(func_in_main);
37. }
38. #endif
40. //查找动态库中的函数
41. pfuncfunc=(pfunc)dlsym(handle,"func_in_lib");
42. if(func)
43. {
44. b=func(a);
45. printf("b=%d\\n",b);
46. }
47. else
48. {
49. printf("dlsymfailed!\\n");
50. }
51. dlclose(handle);
52. }
53. else
54. {
55. printf("dlopenfailed!\\n");
56. }
58. return0;
59. }

然后编译、执行：

1. $gcc-m32-omainmain.c-ldl
2. $./main
3. func_in_libiscalled
4. func_in_main
5. b=2

完美收官!

PS：很多平台级的代码，例如一些工控领域的运行时(Runtime)软件，大部分都是通过注册的方式，来把平台代码、用户代码进行连接、绑定的。

原文链接：https://mp.weixin.qq.com/s/HSLySL557Df-h5SfU_INmg