Question

有很多关于C ++模板类的问题，它们包含静态成员变量，以及从动态库或共享对象中导出它们。但是这个更深一点：如果有多个共享对象怎么办，每个共享对象都有自己的一组实例，但可能使用另一个共享对象的实例化？

请考虑以下示例代码：

/* file: common.h */

#include <stdio.h>
#define PRINT fprintf (stderr, "(template %d) %d -> %d\n", parameter, data, new_data)

template <int parameter>
class SharedClass
{
    static int data;
public:
    static void Set(int new_data) { PRINT; data = new_data; }
};

template <int parameter>
int SharedClass<parameter>::data = parameter;


/* file: library1.h */

extern template class SharedClass<1>;
void Library1Function();


/* file: library1.cpp */

#include "common.h"
#include "library1.h"
#include "library2.h"

template class SharedClass<1>;

void Library1Function()
{
    SharedClass<1>::Set (100);
    SharedClass<2>::Set (200);
}


/* file: library2.h */

extern template class SharedClass<2>;
void Library2Function();


/* file: library2.cpp */

#include "common.h"
#include "library1.h"
#include "library2.h"

template class SharedClass<2>;

void Library2Function()
{
    SharedClass<1>::Set (1000);
    SharedClass<2>::Set (2000);
}


/* file: main.cpp */

#include "common.h"
#include "library1.h"
#include "library2.h"

int main()
{
    Library1Function();
    Library2Function();
    SharedClass<1>::Set (-1);
    SharedClass<2>::Set (-2);
}

我们假设我们使用GCC构建了两个库和一个应用程序：

$ g++ -fPIC -fvisibility=default -shared library1.cpp -o lib1.so
$ g++ -fPIC -fvisibility=default -shared library2.cpp -o lib2.so
$ g++ -fvisibility=default main.cpp -o main -Wl,-rpath=. -L. -l1 -l2

然后运行可执行文件，我们将得到以下结果：

$ ./main
(template 1) 1 -> 100
(template 2) 2 -> 200
(template 1) 100 -> 1000
(template 2) 200 -> 2000
(template 1) 1000 -> -1
(template 2) 2000 -> -2

这意味着库和可执行文件都访问相同的每个模板静态存储如果我们在二进制文件上运行“nm -C”，我们将看到每个静态成员只定义一次并在相应的库中：

$ nm -C -A *.so main | grep ::data
lib1.so:0000000000001c30 u SharedClass<1>::data
lib2.so:0000000000001c30 u SharedClass<2>::data

但我有一些问题。

为什么，如果我们从两个标题中删除extern template class ...，我们会看到每个二进制文件中都存在静态成员，但测试应用程序将继续正常工作？

$ nm -C -A *.so main | grep ::data
lib1.so:0000000000001c90 u SharedClass<1>::data
lib1.so:0000000000001c94 u SharedClass<2>::data
lib2.so:0000000000001c94 u SharedClass<1>::data
lib2.so:0000000000001c90 u SharedClass<2>::data
main:0000000000401e48 u SharedClass<1>::data
main:0000000000401e4c u SharedClass<2>::data

是否可以在MSVC下构建它？
或者，更具体地说，如何处理__declspec(dllexport)和__declspec(dllimport)以导出一些实例化，还有一些 - 导入？
最后：这是一个未定义行为的例子吗？

Answer 1

回答第1点：当动态链接器解析符号时，它使用要链接的模块列表。首先检查加载的第一个模块，然后检查第二个模块，依此类推。

IIRC，当在main，lib1.so和lib2.so中使用data成员时，即使成员在同一模块中声明，仍然将其视为动态符号引用。因此，当链接器在运行程序时解析符号时，所有三个模块最终只使用三个模块中的一个模块中的data成员实现：无论先加载哪个。其他两对仍然加载到内存中，但未使用。

（在所有三个模块中尝试std::cout << &(SharedClass<n>::data) << std::endl;所有六个案例的打印地址应该相同。）

为了回答第3点，我不相信这种行为是完全没有定义的。完全取决于系统的动态链接器，但我不知道任何链接器都不会以完全相同的方式处理这种情况。

我不能说第2点，因为我对MSVC没有很多经验。

跨多个DLL / DSO的静态成员的模板类

1 个答案: