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

How to guarantee initialization ordering of const static members in templated structures

本文关键字：静态成员 const 初始化 顺序 结构 何保证      更新时间：2023-10-16

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

依赖.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);

testStruct.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;
};

主输出为

TestStruct<d> 0
Dependency<d> 1.5
Dependency<f> 1.5
TestStruct<f> 1.5

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

我已经看过C++静态成员初始化（里面的模板乐趣）和如何强制初始化静态成员？。第一个很好地解释了情况，但没有为像我这样的问题提出解决方案。第二个有两个解决方案，但在 GCC 4.2.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();
相关文章：