如何强制静态成员初始化？

Question

考虑这个示例代码：（

template<class D>
char register_(){
    return D::get_dummy(); // static function
}

template<class D>
struct Foo{
    static char const dummy;
};

template<class D>
char const Foo<D>::dummy = register_<D>();

struct Bar
    : Foo<Bar>
{
    static char const get_dummy() { return 42; }
};

也在 Ideone 上。）

我希望 dummy 得到一旦有 Foo 的具体实例化，我就用 Bar 进行初始化。 这个问题（以及最后的标准引用）解释得很清楚，为什么这没有发生。

[...] 特别是，静态数据成员的初始化（以及任何相关的副作用）不会发生，除非静态数据成员本身的使用方式需要静态数据成员的定义存在。

有没有办法强制 dummy 初始化（有效调用register_）没有任何实例Bar 或 Foo （没有实例，因此没有构造函数欺骗）并且 Foo 的用户不需要以某种方式显式声明成员？不需要派生类做任何事情的额外cookie。

---

编辑：找到一种对派生类影响最小的方法：

struct Bar
    : Foo<Bar>
{   //                              vvvvvvvvvvvv
    static char const get_dummy() { (void)dummy; return 42; }
};

不过，我会仍然喜欢派生类不必这样做。 :|

Answer 1

考虑一下：

template<typename T, T> struct value { };

template<typename T>
struct HasStatics {
  static int a; // we force this to be initialized
  typedef value<int&, a> value_user;
};

template<typename T>
int HasStatics<T>::a = /* whatever side-effect you want */ 0;

不引入任何成员也是可能的：

template<typename T, T> struct var { enum { value }; };
typedef char user;

template<typename T>
struct HasStatics {
  static int a; // we force this to be initialized
  static int b; // and this

  // hope you like the syntax!
  user :var<int&, a>::value,
       :var<int&, b>::value;
};

template<typename T>
int HasStatics<T>::a = /* whatever side-effect you want */ 0;

template<typename T>
int HasStatics<T>::b = /* whatever side-effect you want */ 0;

Answer 2

我们可以使用一个基于必须用类实例化的声明的简单技巧：

template<…>
struct Auto {
  static Foo foo;
  static_assert(&foo);
};
template<…> Foo Auto::foo=…;

请注意，某些编译器会警告与 null 的比较；可以使用 &foo==&foo、(bool)&foo 或 ((void)&foo,true)< 来避免/code> 如果需要的话。

另请注意，GCC 9.0–9.2 不将此视为 odr-use< /a>.

Answer 3

我想到了类似的事情：

// in some c++ file (to make i with internal linkage)
static int i = init_dummy(Foo<int>::dummy);

init_dummy 的定义如下：

int init_dummy(...)
{
  return 1;
}

由于变量 args，您可以在那里放置更多初始化，例如：

static int i = init_dummy(Foo<int>::dummy, Foo<double>::dummy, Foo<whatever>::dummy);

Answer 4

我最近遇到了这个。官方解决方案是显式模板实例化，此处进行了描述。

在上述情况下，语句应如下所示：

template class Foo::Bar;

Answer 5

有没有办法在没有任何 Bar 或 Foo 实例的情况下强制初始化虚拟对象（有效地调用 register_）（没有实例，因此没有构造函数欺骗）？

这还不够吗？

std::cout << Foo<int>::dummy;