linux下静态库与动态库的生成与调用

首先，这里有2个概念:静态库，动态库.

静态库：

      是程序在链接时将静态库拷贝到可执行文件里，即生成可执行文件后，即使删除静态库，可执行文件仍可正常执行。

动态库：

      也叫共享库，程序只是在链接时在可执行文件时保存了该库的信息，可执行文件执行时候需要到LD_LIBRAY_PATH或者/etc/ld.so.config里指定的路径去寻找该库并加载调用，因此如果删除该库，可执行文件将无法正常执行。

      共享库还有一调用方法，使用dlopen和dlsym来获得方法指针，然后调用。

下面先说说生成静态库和动态库的方法。

1.静态库的生成方法：

[cpp] view plain copy

1. func1.c  
2.   
3. int func1()  
4. {  
5.     return 100;  
6. }  
7.   
8. func2.c  
9.   
10. int func2(int a)  
11. {  
12.     return a * a:  
13. }  
14.   
15. test.c  
16.   
17. #include <stdio.h>  
18.   
19. int func1();  
20.   
21. int func2(int);  
22.   
23. int main(int argc, char* argv[])  
24. {  
25.     printf("func1:%d/n", func1());  
26.     printf("func2:%d/n", func2(20));  
27.     return 0;  
28.   
29. }  

(1).编译func1.c和func2.c.

gcc -c func1.c func2.c

生成func1.o和func2.o

(2).利用ar来归档生成静态库

ar -rv libfunc.a func1.o func2.o

生成了libfunc.a,这个libxxxx.a是linux里静态库文件的固定格式。这时可以将libfunc.a拷贝到系统的lib路径，比如/usr/lib.

(3).编译test.c并链接libfunc.a

gcc -o test test.c -L. -lfunc

这里-L.是指定库文件路径。我碰到个一个奇怪的问题，如果是

gcc -o test -lfunc test.c -L.

的话会报错找不到func1和func2,一定要把-l和-L放到test.c之后才能编译过，目前还没了解原因。

C++生成静态库的方法是一样的。

g++ -c func1.c func2.c

ar -rv libfunc.a func1.o func2.o

g++ -o test test.c -L. -lfunc

a.如果C++里调用C的库，这时候函数声明要加上extern "C"就可以了,例如

[cpp] view plain copy

1. test.cpp  
2. #include <iostream>  
3. using namespace std;  
4. extern "C" int func1();  
5. extern "C" int func2(int);  
6.   
7. int main(int argc, char *argv[])  
8. {  
9.     cout<<"func1:"<<func1()<<endl;  
10.     cout<<"func2:"<<func2(20)<<endl;  
11.     return 0;  
12. }  

然后同样用

g++ -o test test.cpp -L. -lfunc可以调用C的库。

b.如果是C调用C++生成的库，需要用C封装一下C++的库，然后再调用。

添加一个文件

[cpp] view plain copy

1. adapter.cpp  
2.   
3. #include "func1.h"  
4. #include "func2.h"  
5. extern "C"  
6. {  
7.     int func3()  
8.     {  
9.         return func1();  
10.     }  
11.   
12.     int func4(int a)  
13.     {  
14.         return func2(a);  
15.     }  
16. }  

test.c里改成

[cpp] view plain copy

1. #include <stdio.h>  
2.   
3. int func3();  
4. int func4(int);  
5.   
6. int main(int argc, char *argv[])  
7. {  
8.     printf("func1:%d/n", func3());  
9.     printf("func2:%d/n", func4());  
10.     return 0;  
11. }  

编译adapter.cpp,请注意，使用g++来编译

g++ -c adapter.cpp

生成test.这里是用gcc.

gcc -o test test.c adapter.o -L. -lfunc -lstdc++

注意，一定要加上-lstdc++.

2.动态库的生成

假设还是最初的func1.c, func2.c, test.c那三个文件。

(1)生成动态库文件

gcc -fpic -shared -o libfunc.so func1.c func2.c

生成了一个libufnc.so文件，将此文件拷贝到系统的库缺省路径里。例如/usr/lib

(2)调用动态库， 编译test.c

gcc -o test test.c -lfunc

这样就能使用动态库了。

这里调用动态库的方法是隐式调用，也叫静态调用，还有一种方法是显式调用，也叫动态调用。

[cpp] view plain copy

1. test2.c  
2.   
3. #include <dlfcn.h>  
4. #include <stdio.h>  
5.   
6. int main(int argc, char* argv[])  
7. {  
8.     int (*pFunc1)();  
9.     int (*pFunc2)(int);  
10.    
11.     void *pdl = dlopen("libfunc.so", RTLD_LAZY);  
12.     if (!pdl)  
13.     {  
14.         printf("failed to open library libfunc.so./n");  
15.         return -1;  
16.     }  
17.   
18.     char* dlErr = dlerror();  
19.   
20.     if (dlErr)  
21.     {  
22.         printf("%s/n", dlErr);  
23.         return -1;  
24.     }  
25.    
26.     pFunc1 = dlsym(pdl, "func1");  
27.     pFunc2 = dlsym(pdl, "func2");  
28.     dlErr = dlerror();  
29.     if (dlErr)  
30.     {  
31.         printf("%/n", dlErr);  
32.         return -1;  
33.     }  
34.    
35.     printf("func1:%d/n", (*pFunc1)());  
36.     printf("func2:%d/n", (*pFunc2)(20));  
37.   
38.     dlclose(pdl);  
39.     return 0;  
40. }  

使用C++生成动态库的方法于gcc一样。

g++ -fpic -shared -o libfunc++.so func1.c func2.c

C和C++生成的库相互调用跟前面的静态库相互调用方法一样。