我能保证不会被这种 ODR 违规行为所困扰吗？

Question

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

/* 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）时，foo<123>::bar 的符号出现并被声明为弱。但是，foo<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：我怎么能预测我观察到的行为？也就是说，究竟是什么让编译器声明符号为弱？

Answer 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 表示：

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