c++ - C++ Nifty Counter 习语如何保证静态初始化和静态去初始化

Question

在学习 isocpp 时，我遇到了一个 FAQ .其中说:“什么是保证静态初始化和静态去初始化的技术？”简短的答案只是暗示:

Short answer: use the Nifty Counter Idiom (but make sure youunderstand the non-trivial tradeoffs!).

到现在为止，我不明白Nifty Counter Idiom是什么意思意思以及它如何解决 Fiasco 问题。我已经知道 Construct On First Use Idiom ，以及它在使用静态对象或静态指针时的副作用(包装在返回引用的全局函数中)

这是一个实际上容易出现 Fiasco 问题的简单示例:

//x.cpp
include "x.hpp" // struct X { X(int); void f(); };

X x{ 10 };
struct Y { Y(); };
Y::Y(){ x.f(); };

//y.cpp
include <iostream>
include "y.hpp" // struct Y { Y(); };

struct X { X(int); void f(); private: int _x; };
X::X(int i) { _x = i; }; 
void X::f() { std::cout << _x << std::endl; };
Y y;

来自 here ，提到了Nifty Counter Idiom的主要用途

Intent: Ensure a non-local static object is initialized before itsfirst use and destroyed only after last use of the object.

现在我现在需要的是，Nifty Counter Idiom具体是如何解决上面代码中的静态顺序初始化和去初始化的，而不管其他的解决方法如constinit。假设上面的程序是这样编译的:

~$ g++ x.cpp y.cpp && ./a.out >> 10

~$ g++ y.cpp x.cpp && ./a.out >> 0

Answer 1

我认为您提供的链接解释得很好。但这是我的尝试。

首先是什么问题

// stream.hpp

struct Stream {
  Stream ();
  ~Stream ();
  void operator<<(int);
};

extern Stream stream; // global stream object

// stream.cpp

#include "stream.hpp"

Stream::Stream () { /* initialize things */ }
Stream::~Stream () { /* clean up */ }
void Stream::operator<<(int a) { /* write to stream */ }

Stream stream{};

// app.cpp

#include "stream.hpp"

struct X
{
    X()
    {
         stream << 24; // use stream object
    }
    ~X()
    {
         stream << 1024; // use stream object
    }

};

X x{}; // in this static initialization the static stream object is used

C++ 标准不保证 TU 中静态对象的任何初始化顺序。 stream和 x在不同的 TU 中，所以 stream可以先初始化，这很好。或者 x可以在 stream 之前初始化这很糟糕，因为 x 的初始化使用 stream尚未初始化。

如果stream，析构函数也会出现同样的问题。在 x 之前销毁.

漂亮的计数器解决方案

它利用了在 TU 中对象按顺序初始化和销毁​​的事实。但是我们不能有 stream每个 TU 的对象，所以我们使用了一个技巧，我们改为使用 StreamInitializer每个 TU 的对象。这streamInitializer将在x之前 build 并在 x 之后销毁我们确保只有第一个 streamInitializer被构造的创建流对象，并且只有最后一个 streamInitializer被破坏破坏流对象:

// stream.hpp

struct Stream {
  Stream ();
  ~Stream ();
  void operator<<(int);
};
extern Stream& stream; // global stream object

struct StreamInitializer {
  StreamInitializer ();
  ~StreamInitializer ();
};

static StreamInitializer streamInitializer{}; // static initializer for every TU

// stream.cpp

#include "stream.hpp"

static int nifty_counter{}; // zero initialized at load time
static typename std::aligned_storage<sizeof (Stream), alignof (Stream)>::type
  stream_buf; // memory for the stream object
Stream& stream = reinterpret_cast<Stream&> (stream_buf);

Stream::Stream () { // initialize things }
Stream::~Stream () { // clean-up } 

StreamInitializer::StreamInitializer ()
{
  if (nifty_counter++ == 0) new (&stream) Stream (); // placement new
}
StreamInitializer::~StreamInitializer ()
{
  if (--nifty_counter == 0) (&stream)->~Stream ();
}

我们的app.cpp是一样的

// app.cpp

#include "stream.hpp"

struct X
{
    X()
    {
        stream << 24; // use stream object
    }
    ~X()
    {
         stream << 1024; // use stream object
    }

};

X x{}; // in this static initialization the static stream object is used

现在stream不是一个值，它是一个引用。所以在这一行 Stream& stream = reinterpret_cast<Stream&> (stream_buf);没有Stream对象被创建。只是引用绑定(bind)到驻留在 stream_buf 处的仍然不存在的对象内存。稍后将构造此对象。

每个编译单元都有一个streamInitializer目的。这些对象以任何顺序初始化，但这并不重要，因为只有其中一个 nifty_counter将是 0在那并且只有那一条线上 new (&stream) Stream ();被执行。这一行实际上创建了 stream内存位置的对象 stream_buf .

现在为什么行是X x{};在这种情况下可以吗？因为这个TU的streamInitializer对象在 x 之前初始化，这确保了 stream在 x 之前初始化.对于 stream.hpp 的每个 TU 都是如此在使用 stream 之前已正确包含对象。

相同的逻辑适用于析构函数，但顺序相反。

回顾

不同TU中的静态对象可以按任意顺序初始化。如果来自一个 TU 的静态对象在其构造函数或析构函数中使用来自另一个 TU 的另一个静态对象，则会出现问题。

在 TU 中，对象按顺序构造和销毁。

在漂亮的 connter 习语中:

• 一个TU持有流对象的原始内存
• stream是对该内存位置的对象的引用
• 一个streamInitializer在使用 stream 的每个 TU 中创建对象对象。
• 只有 1 streamInitializer将创建流对象，第一个被初始化
• 在每次使用 x 之前的 TU 中至少 streamInitializer因为那个 TU 已经初始化了。这意味着至少有一个 streamInitializer被构建，这意味着 stream在 x 的构造函数之前构造.

---

包含为简洁起见而省略的守卫