linux 静态链接 库函数冲突,Linux静态链接库与模板类的处理方式

在阅读本文之前，小编先给大家介绍一篇相关文章：Linux静态链接库使用类模板的快速排序算法

大家首先看下以上的文章对理解下面的知识点会有很大的帮助。

当模板遇到静态链接库会发生什么呢。

我们先按照常规思路去考虑一个静态链接库的步骤：

1.将某些功能提取出来，放进一个cpp文件，并将接口或者对外导出的类放在头文件中

2.gcc -c编译该文件，生成.o

3.ar命令将.o文件打包成.a，即静态链接库

4.编译main函数，并将该静态链接库链接，生成可执行文件。

OK，按照这个思路，我们将之前写的快速排序代码修改后，如下：

lib_test.h:

//lib_test.h

//head file of quick sort

//users should realise operator > and <

#ifndef LIB_TEST_H

#define LIB_TEST_H

template

class SORT

{

public:

static void myQsort(T a[], int p, int r);

static void myQsortNoRecur(T a[], int p, int r);

private:

static int partition(T a[], int p, int r);

static void exchange(T a[], int i, int j);

};

#endif

lib_test.cc：

//lib_test.cc

#include

#include

#include"stdlib.h"

#include

#include "lib_test.h"

using namespace std;

template

void SORT::exchange(T a[], int i, int j)

{

T temp = a[i];

a[i] = a[j];

a[j] = temp;

return;

}

template

int SORT::partition(T a[],int p,int r)

{

int i = p;

int j = p-1;

T ref = a[p];

int refId = p;

srand((unsigned)time(NULL));

refId = (rand() % (r-p+1))+ p;

//cout<

ref = a[refId];

for(; i<=r; i++)

{

if(a[i] < ref)

{

j++;

exchange(a, i, j);

if(j == refId)

{

refId = i;

}

}

}

exchange(a, j+1, refId);

return j+1;

}

template

void SORT::myQsort(T a[],int p,int r)

{

int q = 0;

if(p

{

q = partition(a, p, r);

myQsort(a, p, q-1);

myQsort(a, p+1, r);

}

return;

}

template

void SORT::myQsortNoRecur(T a[], int p, int r)

{

int start = p;

int end = r;

int mid = 0;

std::stack sortStk;

sortStk.push(p);

sortStk.push(r);

while(!sortStk.empty())

{

end = sortStk.top();

sortStk.pop();

start = sortStk.top();

sortStk.pop();

if(start < end)

{

mid = partition(a, start, end);

sortStk.push(start);

sortStk.push(mid -1);

sortStk.push(mid + 1);

sortStk.push(end);

}

}

}

OK，我们尝试编译.a静态链接库

接下来，只需要将静态链接库编入main函数，就算完成了

出问题了，发现我们编译的静态链接库里面居然没有这个myQsortNoRecur函数，可是我明明在快速排序这个类SORT里面实现了这个函数啊。

用nm命令看下：

实实在在的，符号很少，确实没有我之前写的函数。这就奇怪了，今天下午在网上搜了很久，原来是模板类的原因导致的：

因为在编译动态链接库中，我们并没有指定template class的type，那么静态链接库中自然不知道按照什么type去编译该class中成员函数。

有没有解决办法呢？答案是肯定的，只要我们在静态链接库中申明一个type，并调用该指定type的函数，那么静态链接库中就有函数原型了。

我觉得可以把该过程称为接口的“实例化”过程........

现在把lib_test.cc修改如下：

//lib_test.cc

#include

#include

#include"stdlib.h"

#include

#include "lib_test.h"

using namespace std;

template

void SORT::exchange(T a[], int i, int j)

{

T temp = a[i];

a[i] = a[j];

a[j] = temp;

return;

}

template

int SORT::partition(T a[],int p,int r)

{

int i = p;

int j = p-1;

T ref = a[p];

int refId = p;

srand((unsigned)time(NULL));

refId = (rand() % (r-p+1))+ p;

//cout<

ref = a[refId];

for(; i<=r; i++)

{

if(a[i] < ref)

{

j++;

exchange(a, i, j);

if(j == refId)

{

refId = i;

}

}

}

exchange(a, j+1, refId);

return j+1;

}

template

void SORT::myQsort(T a[],int p,int r)

{

int q = 0;

if(p

{

q = partition(a, p, r);

myQsort(a, p, q-1);

myQsort(a, p+1, r);

}

return;

}

template

void SORT::myQsortNoRecur(T a[], int p, int r)

{

int start = p;

int end = r;

int mid = 0;

std::stack sortStk;

sortStk.push(p);

sortStk.push(r);

while(!sortStk.empty())

{

end = sortStk.top();

sortStk.pop();

start = sortStk.top();

sortStk.pop();

if(start < end)

{

mid = partition(a, start, end);

sortStk.push(start);

sortStk.push(mid -1);

sortStk.push(mid + 1);

sortStk.push(end);

}

}

}

namespace quick_sort_instance

{

void template_instance()

{

int a[]={1,2};

SORT::myQsortNoRecur(a, 0, 1);

}

}

好，重复上面的编译过程：

这些编译和执行过程就能正常进行了。

但是这种所谓的“实例化”过程有一个明显的缺点，那就是，本身这个SORT类是一个模板类，可以排序任意类型的数据，

就本例子而言，只“实例化”了一种int类型的接口。因此当我想排序一个float类型的数组时，我就必须在.a文件里面再“实例化”一个float接口。

显然，假如我想把该具有sort功能的类，抽象成一个独立的模块，但是我并不知道该.a的用户想排序的数据类型是什么，那么将必须穷举所有的数据类型

这显然是不可能的。这一局限性不只时模板类，同样的，模板函数也是如此。

结论：最好不要在静态链接库中使用模板，同样的，动态链接库也一样。

想到这里，脑子里忽然蹦出来一个想法：C++的STL到底是动态链接韩式静态链接的呢？STL使用了大量的模板，按照这篇博客在讨论的内容，似乎是矛盾的。在网上找了半天

参考知乎的大神们是怎么解释的吧：

https://www.zhihu.com/question/46098144

以上就是本文的全部心得和内容，如果大家还有所疑问和建议，可以在下面的留言区讨论。