什么是静态初始化块？
在 Java 中，有一种称为静态初始化块的结构。静态初始化块将在 Java 第一次运行时被加载。例如，请考虑以下代码片段：
class Foo {
static {
// initialization code goes here
// called only once, when the class is loaded by the runtime
System.out.println("I'm the static initialization block of Foo\n");
}
public Foo() {
System.out.println("I'm the constructor of Foo\n");
}
public static void Main(String[] args) {
Foo foo1 = new Foo();
Foo foo2 = new Foo();
}
}
这产生类似下面的输出：
I'm the static initialization block of Foo
I'm the constructor of Foo
I'm the constructor of Foo
这种构造可以在各种情况下有用。在 Java 中，预期的用例是允许对类的静态成员进行多行初始化。它也可以用于日志记录和任何种类的“注册”或“订阅”代码（如脚本绑定）。
更多关于 Java 的静态初始化块的介绍可以参考这篇文章：http://www.jianshu.com/p/e10871b7cbd4
C++ 缺乏这种构造方法，但是通过巧妙地设计，可以模仿它的某些方面的特性。
什么可以模拟？
首先，在 C++ 中没有运行库这样的东西，至少不是 Java 的意义上的运行库。这意味着上述定义不能完全在 C++ 中复制。因此，目标是要有一个构造：
- 使用最少的样板
- 很容易理解（也就是说，语法很简单）
- 作为静态函数，在类的范围内运行
- 在确定点执行代码，最好在 main 的开始
语法
从上面的要求（以及一些要提到的限制）出发，以下是静态初始化块的预期语法：
In foo.h:
#pragma once
#include "static_init.h"
class Foo
{
public:
Foo();
DECLARE_STATIC_INIT(Foo);
};
In foo.cc:
#include <iostream>
#include "foo.h"
Foo::Foo()
{
std::cout << "I'm the constructor of Foon";
}
STATIC_INIT(Foo)
{
std::cout << "I'm the static initialization block of Foon";
}
In main.cc:
#include <iostream>
#include "static_init.h"
#include "foo.h"
int main()
{
static_init::execute();
Foo foo1, foo2;
}
我们期望这个代码将产生与上面的 Java 代码片段相同的输出。
实现上述想法
那么进入 static_init.h 呢？ 从主要的代码中，不难猜出实现的一部分是某种注册表。我们没有猜错，它看起来像这样：
typedef void (*init_func_type)();
class static_init
{
public:
static static_init& instance()
{
static static_init inst;
return inst;
}
void add_init_func(init_func_type f) { funcs_.push_back(f); }
static void execute()
{
auto& inst = instance();
for (auto& c : inst.funcs_) c();
}
private:
static_init() {}
std::vector<init_func_type> funcs_;
};
static_init 是一个管理和执行 void 函数的单例类。init_func_type 是一个函数指针的 typedef，它指向一个不带参数的函数。他们将被用来指向静态成员函数。std :: function 也可以在这里工作，但效率会比较低。执行成员函数设计成静态的，仅仅是为了在调用方面方便，没有别的意图。
add_init_func 在哪里调用？ 诀窍是在一个静态成员的构造函数中调用它。这个构造函数将 init 函数作为参数传递给 add_init_func。 理论上，可以在那里调用该函数（并且不需要 “init 函数注册表”），但是这样做会使我们的代码受到 “静态初始化顺序失败” 的影响。 我们不想对我们的库的客户施加任何限制，所以我们正在采取这种方法：
对于在注册代码中偷偷引入的静态成员，我们需要定义一个助手类。这是非常简单的:
class static_init_helper
{
public:
static_init_helper(init_func_type f)
{
static_init::instance().add_init_func(f);
}
};
在这一点上，我们有我们所需要的一切功能。 Foo.h 会有这样的代码：
#pragma once
#include "static_init.h"
class Foo
{
public:
Foo();
static void static_init_func();
static static_init_helper Foo_static_init_helper;
};
在 foo.cc 中：
#include <iostream>
#include "foo.h"
Foo::Foo()
{
std::cout << "I'm the constructor of Foon";
}
// This is where the registration code (i.e. the constructor of the helper class) gets called:
static_init_helper Foo::Foo_static_init_helper(&Foo::static_init_func);
// And this is the implementation of the static init function,
// an actual static member function of the class.
void Foo::static_init_func()
{
std::cout << "I'm the static initialization block of Foon";
}
它能够正常工作，但是一点也不漂亮和优雅。
使它更漂亮一点
我们有意安排了上面的代码，这样可以很容易地看到宏可以派上多大的用场啦。 声明部分非常简单：
#define DECLARE_STATIC_INIT(ClassName)
static void static_init_func();
static static_init_helper ClassName##_static_init_helper
注意最后缺少分号。这只是作者的一个个人喜好，我们可以根据自己的习惯进行添加。
同样，实现部分：
#define STATIC_INIT(ClassName)
static_init_helper ClassName::ClassName##_static_init_helper(&ClassName::static_init_func);
void ClassName::static_init_func()
但是，在这里，我们可能不会在最后添加一个分号，因为宏将在将要写入的成员函数的签名中结束。这就是允许宏充当函数定义的一部分的原因。
缺点
上面已经提到了一个问题：虽然静态初始化函数并不直接受到 “静态初始化顺序失败” 的影响（也就是说，它们可以期望任何类的静态成员被完全构建），但它们可能并不相互依赖，因为他们将被称为未定义的顺序。
这个解决方案在 C++ 领域引入了一些有点陌生的概念。这意味着程序员阅读使用它的代码会增加开销。不过，用正确的代码命名将使我们的意图应该很容易被猜到。
另外，这也为类添加了一个数据成员。虽然这个数据成员是 0 大小，但它仍然需要存在于一个源文件中才能正确链接。这意味着静态的 init 函数不可能是 inline 的。
源代码
本文的源代码（以及一些示例代码）可在 Github repository 中查看
本文翻译自文章：
http://szelei.me/cpp-static-init-block/
感谢原文作者
