深析静态链接库和动态链接库相同函数覆盖及库调用顺序问题

最近一个项目遇到的一个问题,MongoDB和自家库中的md5函数出现冲突, 而且报的是莫名错误，经过仔细debug终于找到md5中的md5_finish覆盖出现的问题,今天抽了点时间写了些小程序测试了下

注意:编译器为gcc,若使用g++, 请在库里面加上extern "C" 

两个静态库

首先测试静态链接库，大概的代码如下：

libA.c

view
plain

#include <stdio.h>  

#include <stdlib.h>  

#include "libA.h"  

void libA(){  

        common();  

}  

  

void common() {  

        printf("libA common!\n");  

}  

libA.h

view
plain

#ifndef __LIBA_H__  

#define __LIBA_H__  

  

void libA();  

void common();  

  

#endif  

。。。。。。。。。。。。。。。。。。。下面是libB的代码。。。。。。。。。。。。。。。。

libB.c

view
plain

#include <stdio.h>  

#include <stdlib.h>  

#include "libB.h"  

void libB(){  

        common();  

}  

  

void common() {  

        printf("libB common!\n");  

}  

libB.h

view
plain

#ifndef __LIBB_H__  

#define __LIBB_H__  

  

void libB();  

void common();  

  

#endif  

静态库生成:

view
plain

gcc -c libX.c  

ar -rs libX.a libX.o  

动态库生成:

view
plain

gcc -fpic -shared -o libX.so libX.c  

fpic: 表示为位置无关,也即在任何内存位置都可以运行

可以看到libA和libB都有相同的common函数 但是答应出的内容都是自家的。

下面我们分别生成静态链接库做测试.生成好后,写个测试主程序进行测试

view
plain

#include <stdio.h>  

#include <stdlib.h>  

#include <string.h>  

#include <dlfcn.h>  

  

int main()   

{  

        libA();  

    libB();  

        return 0;  

}  

编译生成结果如下:

view
plain

>>gcc -L./ main.c -lA -lB                                                            @crazybaby  

.//libB.a(libB.o): In function `common':  

libB.c:(.text+0x10): multiple definition of `common'  

.//libA.a(libA.o):libA.c:(.text+0x10): first defined here  

collect2: ld returned 1 exit status  

可以得出第一个结论:都为静态链接库,有同名函数参与情况下,链接会出现符号多次定义的错误!

两个动态库

再来看看动态链接库,同样的libA libB 生成动态链接库 

测试主程序不修改 ! 还是为:

view
plain

#include <stdio.h>  

#include <stdlib.h>  

#include <string.h>  

#include <dlfcn.h>  

  

int main()   

{  

    libA();  

    libB();  

    return 0;  

}  

编译结果和顺序,结果如下:

view
plain

 >>gcc main.c ./libA.so ./libB.so                                                     @crazybaby  

 >>./a.out                                                                            @crazybaby  

libA common!  

libA common!  

view
plain

 >>gcc main.c ./libB.so ./libA.so                                                     @crazybaby  

 >>./a.out                                                                            @crazybaby  

libB common!  

libB common!  

这种编译方式叫做动态库的隐式调用, 如果你删除一个libA.so , 运行a.out 会出现不能找到动态库的错误.

这种情况也可以称为 加载时链接! 静态库属于编译时链接!

可以得出第二个结论: 若都为动态库,并且进行隐式调用,输出结果和动态库的顺序有关.

再继续看看动态加载动态库.

修改测试主程序

view
plain

#include <stdio.h>  

#include <stdlib.h>  

#include <string.h>  

#include <dlfcn.h>  

  

int main()   

{  

    void* handle2 = NULL;  

    void (*testLibA)();  

    handle2 = dlopen("./libA.so", RTLD_LAZY);  

    if (handle2 == NULL) {  

        perror("error!");  

        return ;  

    }  

    testLibA = dlsym(handle2, "libA");  

    if (testLibA == NULL) {  

        perror("error!");  

        return ;  

    }  

  

  

    void* handle = NULL;  

    void (*testLibB)();  

    handle = dlopen("./libB.so", RTLD_LAZY);  

    if (handle == NULL) {  

        perror("error!");  

        return ;  

    }  

    testLibB = dlsym(handle, "libB");  

    if (testLibB == NULL) {  

        perror("error!");  

        return ;  

    }  

    testLibA();  

    testLibB();  

  

    return 0;  

}  

编译生成结果如下：

view
plain

^_^[root@:~/fjx-test]#gcc main.c -ldl  

^_^[root@:~/fjx-test]#./a.out   

libA common!  

libB common!  

这种情况称为运行时链接 !

如果我们再把动态库的名字加上去呢?

view
plain

 >>gcc main.c -ldl ./libA.so ./libB.so                                                @crazybaby  

 >>./a.out                                                                            @crazybaby  

libA common!  

libA common!  

view
plain

 >>gcc main.c -ldl ./libB.so ./libA.so                                                @crazybaby  

 >>./a.out                                                                            @crazybaby  

libB common!  

libB common!  

同样可以得出结论，动态链接库如果不加库连选项 ,函数调用是正确的 加库路径,会以库的路径顺序为主! 左边覆盖右边. 而且当只链接其中一个时 也生效 如:

view
plain

>>gcc main.c -ldl ./libB.so                                                          @crazybaby  

>>./a.out                                                                            @crazybaby  

libB common!  

libB common!  

view
plain

>>gcc main.c -ldl ./libA.so                                                          @crazybaby  

>>./a.out                                                                            @crazybaby  

libA common!  

libA common!  

一个静态,一个动态

再来看看一个静态文件和一个动态文件

修改测试主程序

view
plain

#include <stdio.h>  

#include <stdlib.h>  

#include <string.h>  

#include <dlfcn.h>  

  

int main()   

{  

    void* handle2 = NULL;  

    void (*testLibA)();  

    handle2 = dlopen("./libA.so", RTLD_LAZY);  

    if (handle2 == NULL) {  

        perror("error!");  

        return ;  

    }  

    testLibA = dlsym(handle2, "libA");  

    if (testLibA == NULL) {  

        perror("error!");  

        return ;  

    }  

    testLibA();  

  

    libB();  

    return 0;  

}  

测试结果如下：

libB为静态链接!, libA为动态加载.

view
plain

 >>gcc -L./ main.c -ldl -lB                                                           @crazybaby  

 >>./a.out                                                                            @crazybaby  

libA common!  

libB common!  

输出正常!

再看下如果动态库的库名显示的加载入编译选项中：

view
plain

 >>gcc -L./ main.c -ldl -lB ./libA.so                                                 @crazybaby  

 >>./a.out                                                                            @crazybaby  

libB common!  

libB common!  

view
plain

 >>gcc -L./ main.c -ldl ./libA.so -lB                                                 @crazybaby  

 >>./a.out                                                                            @crazybaby  

libB common!  

libB common!  

在有静态和动态时，不把动态库库名显示加入编译选项,输出是正常的,如果加进去以静态库为主和link顺序无关！！

from: http://blog.csdn.net/liuysheng/article/details/7058227