我正在尝试了解静态对象的初始化。假设您了解常量表达式和 constexpr，静态初始化看起来很简单。动态初始化似乎有点棘手。

[basic.start.init]/4

It is implementation-defined whether the dynamic initialization of a non-local variable with static storage duration is done before the first statement of main. If the initialization is deferred to some point in time after the first statement of main, it shall occur before the first odr-use (3.2) of any function or variable defined in the same translation unit as the variable to be initialized.

脚注 34

A non-local variable with static storage duration having initialization with side-effects must be initialized even if it is not odr-used (3.2, 3.7.1).

[basic.start.init]/5

It is implementation-defined whether the dynamic initialization of a non-local variable with static or thread storage duration is done before the first statement of the initial function of the thread. If the initialization is deferred to some point in time after the first statement of the initial function of the thread, it shall occur before the first odr-use (3.2) of any variable with thread storage duration defined in the same translation unit as the variable to be initialized.

我假设“线程的初始函数”指的是 main，而不仅仅是以 std::thread 开头的线程。

h1.h

#ifndef H1_H_
#define H1_H_

extern int count;

#endif

tu1.cpp

#include "h1.h"

struct S
{
   S()
   {
      ++count;
   }
};

S s;

tu2.cpp

#include "h1.h"

int main(int argc, char *argv[])
{
   return count;
}

tu3.cpp

#include "h1.h"

int count;

因此，如果编译器推迟动态初始化，脚注 34 似乎指出 s 必须在某个时候进行初始化。由于翻译单元中没有其他具有动态初始化的变量，因此没有其他变量可以使用 odr 来强制初始化 tu1 中的变量。 s 在什么时候保证被初始化？

main 是否保证返回 1？另外，有没有办法改变这个程序，使它不再保证返回 1？或者，如果不能保证，有没有办法改变这个程序，使它成为保证？

我分解了代码，以便 s 的定义位于与 main 不同的翻译单元中。这避免了 main 是否使用 odr 的问题。鉴于 s 是翻译单元中唯一的对象，是否保证 main 将返回 1？

最佳答案

我认为所有这些措辞都是为了描述动态加载的库中会发生什么，但没有明确命名它们。

总结一下我的解释:具有静态存储持续时间和动态初始化的非局部变量将:

1. 在第一次使用翻译单元中的任何内容之前进行初始化；
2. 可能在开始 main 之前，但也可能在它之后。

我将脚注 34 解释为(但请记住，脚注不是规范性的):

When anything in a TU is ord-used, then every non-local variable with static storage duration having initialization with side-effects must be initialized, even the variables that are not odr-used.

所以，如果有一个 TU 没有使用任何东西，那么它的动态初始化可能不会发生。

示例

h1.h

extern int count;
struct S
{
    S();
};

h1.cpp

#include "h1.h"

int count;
S::S()
{
   ++count;
}

h2.cpp

#include "h1.h"
S s;

main.cpp

#include "h1.h"
#include <stdio.h>
int main()
{
    printf("%d\n", count);
}

这可以打印 0 或 1:由于 TU h2 中的任何内容都不会被 odr 使用，因此未指定 s 的代码初始化何时完成(如果有的话)。

自然，理智的编译器会在 main 之前初始化 s，所以它肯定会打印 1:

$ g++ main.cpp h2.cpp h1.cpp -o test1
$ ./test1
1

现在，假设 h2.cpp 在共享库中:

$ g++ -shared -fPIC h2.cpp -o h2.so

现在主要文件是:

main2.cpp

#include "h1.h"
#include <dlfcn.h>
#include <stdio.h>

int main()
{
    printf("%d\n", count);
    dlopen("./h2.so", RTLD_NOW);
    printf("%d\n", count);
    return 0;
}

编译运行:

$ g++ -shared -fPIC h2.cpp -o h2.so
$ g++ -rdynamic main.cpp h1.cpp -ldl -o test2
$ ./test2
0
1

看到了吗？ s 的初始化被延迟了!好的部分是，如果不先加载动态加载库，就无法引用动态加载库中的任何内容，加载它会触发动态初始化。所以一切都很好。

如果您认为使用 dlopen 是作弊，请记住有些编译器支持延迟加载共享库(例如 VC++)，其中加载库的系统调用将由编译器只是第一次需要它。

关于c++ - 静态对象是否保证被初始化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18600034/