c++ - 如何保证模板结构中 const 静态成员的初始化顺序

Question

我有两个模板结构，每个结构都包含一个常量静态成员变量。这些成员变量之一的初始化取决于第二个。因此，我希望能够保证第二个在第一个之前初始化。这是一个简化的示例:

依赖.hpp:

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

template <typename T>
struct Dependency {
  Dependency() {}
  Dependency(T v) : var(v) {}
  const static Dependency staticVar;
  T var;
};

template <typename T>
const Dependency<T> Dependency<T>::staticVar = Dependency<T>(1.5);

测试结构.hpp:

#include "dependency.hpp"

//template class Dependency<double>; [1]
//template class Dependency<float>;  [2]

template <typename T>
struct TestStruct {
  TestStruct(Dependency<T> v) : var(v.var) {}

  const static TestStruct staticVar;
  T var;
};

template <typename T>
const TestStruct<T> TestStruct<T>::staticVar = TestStruct<T>(Dependency<T>(Dependency<T>::staticVar));

测试.cpp:

#include <iostream>
#include "testStruct.hpp"

using namespace std;

int main(int argc, char *argv[])
{
  cout << "TestStruct<d> " << TestStruct<double>::staticVar.var << endl;
  cout << "Dependency<d> " << Dependency<double>::staticVar.var << endl;

  cout << endl;

  cout << "Dependency<f> " << Dependency<float>::staticVar.var << endl; // [3]
  cout << "TestStruct<f> " << TestStruct<float>::staticVar.var << endl;

  return 0;
};

main的输出是

TestStruct<d> 0
Dependency<d> 1.5

Dependency<f> 1.5
TestStruct<f> 1.5

也就是TestStruct<T>的 staticVar如果 Dependency 则正确初始化已经为 T 类型实例化了, 但它仍然为 0，因为 Dependency<T>::staticVar尚未初始化。取消注释 [1] 和 [2] 解决了类型 float 的问题和 double (即，所有输出 1.5，即使有 [3] 注释)，但如果可能的话，我宁愿不必列出所有可能的类型或在不使用它们的代码中为那些类型实例化模板。我希望能够在 TestStruct<T> 中放入一些东西(或 testStruct.hpp )以保证 Dependency已为该类型实例化，而无需指定 T 可能是什么类型。

我看过C++ Static member initalization (template fun inside)和 How to force a static member to be initialized? .第一个很好地解释了情况，但没有为像我这样的问题提出解决方案。第二个有两个解决方案，但似乎都不适用于 GCC 4.2.1(或者我应用不正确...)。

是否有任何其他技巧或变通方法我应该尝试，或者我是否坚持使用显式实例化？

Answer 1

正如 cdhowie 所建议的，您可以使用静态方法来确保 TestStruct 和 Dependency 之间的初始化顺序。如果您真的关心维护静态变量而不是静态方法的外观，则可以使用由静态方法调用初始化的静态引用变量。

您只需要确保您的静态方法实现本身不使用静态引用变量，以便在全局初始化上下文期间可以安全地调用它们。

template <typename T>
struct Dependency {
  Dependency() {}
  Dependency(T v) : var(v) {}
  static const Dependency & staticMethod () {
      static const Dependency staticMethodVar(1.5);
      return staticMethodVar;
  }
  static const Dependency & staticVar;
  T var;
};

template <typename T>
const Dependency<T> & Dependency<T>::staticVar
        = Dependency<T>::staticMethod();

template <typename T>
struct TestStruct {
  TestStruct(Dependency<T> v) : var(v.var) {}
  static const TestStruct & staticMethod () {
      static const TestStruct staticMethodVar(Dependency<T>::staticMethod());
      return staticMethodVar;
  }
  static const TestStruct & staticVar;
  T var;
};

template <typename T>
const TestStruct<T> & TestStruct<T>::staticVar
        = TestStruct<T>::staticMethod();