3

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

依赖项.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

也就是说，如果已经为 type 实例化了TestStruct<T>' ，则它staticVar会被正确初始化，但否则它会保持为 0 ，因为尚未初始化。取消注释 [1] 和 [2] 解决了类型问题和（即，所有输出 1.5，即使已注释 [3] 也是如此），但如果可能的话，我宁愿不必列出所有可能的类型或为那些实例化模板键入不使用它们的代码。我希望能够在（或）中放入一些东西来保证已经为该类型实例化，而不必指定 T 可能是什么类型。DependencyTDependency<T>::staticVarfloatdoubleTestStruct<T>testStruct.hppDependency

我看过C++ 静态成员初始化（里面的模板很有趣）和如何强制初始化静态成员？. 第一个很好地解释了情况，但没有为像我这样的问题提出解决方案。第二个有两个解决方案，但似乎都不能在 GCC 4.2.1 中工作（或者我错误地应用了它......）。

我应该尝试任何其他技巧或解决方法，还是我坚持显式实例化？

4

1 回答 1

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();
于 2015-04-10T20:28:40.593 回答