使用什么来代替静态变量

Question

在 C++ 程序中，我需要一些辅助常量对象，这些对象将被实例化一次，最好是在程序启动时实例化。这些对象主要在同一个翻译单元中使用，因此最简单的方法是将它们设为静态：

static const Helper h(params);

但是还有这个 静态初始化顺序 问题，因此如果 Helper 引用其他一些静态变量（通过 params ），这可能会导致 UB。

另一点是我最终可能需要在多个单元之间共享这个对象。如果我只是将其保留为静态并放入 .h 文件中，则会产生多个对象。我可以通过使用 extern 等来避免这种情况，但这最终会引发相同的初始化顺序问题（并不是说它看起来非常 C 风格）。

我考虑过单例，但由于样板代码和不方便的语法（例如 MySingleton::GetInstance().MyVar），这太过分了 - 这些对象是助手，所以它们应该简化事情，不要让它们复杂化...

相同的 C++ FAQ 提及 这个选项：

 Fred& x()
 {
   static Fred* ans = new Fred();
   return *ans;
 } 

这真的被使用并被认为是一件好事吗？我应该这样做，还是你会建议其他选择？谢谢。

编辑：我应该澄清为什么我实际上需要这些助手：它们非常像普通常量，并且可以预先计算，但在运行时执行此操作更方便。我更喜欢在 main 之前实例化它们，因为它会自动解决多线程问题（在 C++03 中本地静态不受保护）。另外，正如我所说，它们通常仅限于翻译单元，因此导出它们并在 main() 中初始化是没有意义的。您可以将它们视为常量，但仅在运行时才知道。

Answer 1

全局状态有多种可能性（无论是否可变）。

如果您担心会遇到初始化问题，那么您应该使用本地静态方法来创建实例。

请注意，您提供的笨重的单例设计不是强制性设计：

class Singleton
{
public:
  static void DoSomething(int i)
  {
    Singleton& s = Instance();
    // do something with i
  }


private:
  Singleton() {}
  ~Singleton() {}

  static Singleton& Instance()
  {
    static Singleton S; // no dynamic allocation, it's unnecessary
    return S;
  }
};

// Invocation
Singleton::DoSomething(i);

另一个设计有点相似，尽管我更喜欢它，因为它使向非全局设计的过渡更加容易。

class Monoid
{
public:
  Monoid()
  {
    static State S;
    state = &s;
  }

  void doSomething(int i)
  {
    state->count += i;
  }

private:
  struct State
  {
    int count;
  };

  State* state;
};


// Use
Monoid m;
m.doSomething(1);

这里的净优势是状态的“全局性”是隐藏的，这是客户无需担心的实现细节。对于缓存非常有用。

让我们质疑这个设计：

• 你真的需要强制执行奇点吗？
• 您实际上需要在 main 启动之前构建该对象吗？

奇点性通常被过分强调。 C++0x 在这里会有所帮助，但即便如此，从技术上强制执行奇点而不是依赖程序员自己表现可能会非常烦人......例如，在编写测试时：您真的想在每个单元测试之间卸载/重新加载程序吗只是为了更改每个之间的配置？啊。实例化一次并对你的程序员同事有信心......或功能测试要简单得多；）

第二个问题更多的是技术性的，而不是功能性的。如果您确实需要程序入口点之前的配置，那么您只需在程序启动时读取它即可。

这听起来可能很幼稚，但实际上在库加载期间的计算存在一个问题：如何处理错误？如果抛出，则不会加载库。如果你不扔并继续，你就处于无效状态。没那么好笑，是吗？一旦真正的工作开始，事情就会变得简单得多，因为您可以使用常规的控制流逻辑。

如果您考虑测试状态是否有效......为什么不简单地在您要测试的地方构建所有内容？

最后，global 的真正问题是引入的隐藏依赖项。当依赖关系隐式地推理执行流程或重构的影响时，效果会好得多。

---

编辑：

关于初始化顺序问题：单个翻译单元内的对象保证按照它们定义的顺序进行初始化。

因此，根据标准，以下代码是有效的：

static int foo() { return std::numeric_limits<int>::max() / 2; }
static int bar(int c) { return c*2; }

static int const x = foo();
static int const y = bar(x);

初始化顺序仅在引用另一个翻译单元中定义的常量/变量时才是问题。因此，静态对象自然可以毫无问题地表达，只要它们仅引用同一翻译单元内的静态对象即可。

关于空间问题：as-if 规则在这里可以创造奇迹。通俗地说，as-if 规则意味着您指定一种行为并将其留给编译器/链接器/运行时来提供它，而无需关心它是如何提供的。这才是真正实现优化的原因。

因此，如果编译器链可以推断出常量的地址从未被占用，则它可能会完全忽略该常量。如果它可以推断出几个常量将始终相等，并且它们的地址再次从未被检查过，则它可能会将它们合并在一起。

Answer 2

是的，您可以使用首次使用时构建 习语，如果它简化了你的问题。它总是比更好，因为全局对象的初始化依赖其他全局对象。

另一种选择是单例模式。两者都可以解决类似的问题。但您必须决定哪个更适合具体情况并满足您的要求。

据我所知，没有什么比这两种方法“更好”了。

Answer 3

单例和全局对象通常被认为是邪恶的。最简单、最灵活的方法是在 main 函数中实例化该对象，并将该对象传递给其他函数：

void doSomething(const Helper& h);
int main() {
  const Parameters params(...);
  const Helper h(params);
  doSomething(h);
}

另一种方法是使辅助函数成为非成员。也许它们根本不需要任何状态，如果需要，您可以在调用它们时传递一个有状态对象。

我认为没有什么可以反对常见问题解答中提到的本地静态习惯用法。它很简单并且应该是线程安全的，如果对象不可变，它也应该很容易模拟并且不会引入远距离操作。

Answer 4

Helper 是否需要在 main 运行之前存在？如果没有，请将（一组？）全局指针变量初始化为0。然后使用 main 以确定的顺序用常量状态填充它们。如果您愿意，您甚至可以创建辅助函数来为您取消引用。