5

我有一个头文件，它声明了一个带有静态变量的模板并定义了它：

/* my_header.hpp */
#ifndef MY_HEADER_HPP_
#define MY_HEADER_HPP_

#include <cstdio>

template<int n>
struct foo {
    static int bar;

    static void dump() { printf("%d\n", bar); }
};

template<int n>
int foo<n>::bar;

#endif // MY_HEADER_HPP_

此标头包含在main.cpp共享库和共享库mylib中。特别是，mylib_baz.hpp只包含这个模板并声明一个修改模板特化的函数。

/* mylib_baz.hpp */
#ifndef MYLIB_BAZ_HPP_
#define MYLIB_BAZ_HPP_

#include "my_header.hpp"

typedef foo<123> mylib_foo;
void init_mylib_foo();

#endif // MYLIB_BAZ_HPP_

和

/* mylib_baz.cpp */
#include "mylib_baz.hpp"
void init_mylib_foo() {
    mylib_foo::bar = 123;
    mylib_foo::dump();
};

当我制作mylib.so（包含mylib_baz.o）时，符号 forfoo<123>::bar存在并声明为弱。但是，在 my 中，符号 forfoo<123>::bar也被声明为弱main.o：

/* main.cpp */
#include "my_header.hpp"
#include "mylib_baz.hpp"

int main() {
    foo<123>::bar = 456;
    foo<123>::dump(); /* outputs 456 */
    init_mylib_foo(); /* outputs 123 */
    foo<123>::dump(); /* outputs 123 -- is this guaranteed? */
}

看来我违反了一个定义规则（foo<123>::bar在my_header.cpp和中定义main.cpp）。但是，对于 g++ 和 clang，符号都被声明为弱（或唯一），所以我不会被这个所困扰——所有访问都是为了foo<123>::bar修改同一个对象。

问题 1：这是一个巧合（也许 ODR 对模板的静态成员的工作方式不同？）还是我实际上通过标准保证了这种行为？

问题 2：我怎么能预测我观察到的行为？也就是说，究竟是什么让编译器声明符号为弱？

4

1 回答 1

1

不存在 ODR 违规。你有一个的定义bar。是这里：

template<int n>
int foo<n>::bar; // <==

照bar原样static，这表明所有翻译单元都有一个定义。即使bar会在所有目标文件中出现一次（毕竟它们需要一个符号），链接器会将它们合并在一起成为bar. 你可以看到：

$ g++ -std=c++11 -c mylib_baz.cpp -o mylib_baz.o
$ g++ -std=c++11 -c main.cpp -o main.o
$ g++ main.o mylib_baz.o -o a.out

产生：

$ nm mylib_baz.o | c++filt | grep bar
0000000000000000 u foo<123>::bar
$ nm main.o | c++filt | grep bar
0000000000000000 u foo<123>::bar
$ nm a.out | c++filt | grep bar
0000000000601038 u foo<123>::bar

其中u表示：

"u"
该符号是唯一的全局符号。这是标准 ELF 符号绑定集的 GNU 扩展。对于这样的符号，动态链接器将确保在整个过程中只有一个具有此名称和类型的符号在使用中。

于 2015-09-18T16:04:04.613 回答