如何确保std :: call_once真的只调用一次

Question

Some code I'm working with uses std::call_once so that some initialization only occurs once. However, there are global objects with constructors that can end up calling the initialization code.

In the following sample, call_once actually gets called twice. I guess it's because the once_flag constructor hasn't ran before it gets used. Is there a way around this so that some initialization code only gets called once without having to prohibit globals?

#include <mutex>
#include <iostream>

using namespace std;

void Init();

class Global
{
public:
    Global()
    {
        Init();
    }
};

Global global;

once_flag flag;

void Init()
{
    call_once(flag, []{  cout << "hello" << endl;  });
}



int main(int argc, char* argv[])
{
    Init();
    return 0;
}

Output is:

hello
hello

Answer 1

According to the specs, once_flag should have a trivial constexpr constructor (for example see here - http://en.cppreference.com/w/cpp/thread/once_flag ). With this in place, if it is global/static, it is not actually "constructed" (no actual function is executed), but more like "value initialized" - like any global/static POD type. In that case it is not possible to have any constructor run "before" this once_flag is properly initialized. Given your comment about using MSVC, I guess it can be a bug in the implementation...

EDIT: According to the comment below, constexpr is not supported on MSVC at all, so your options are really limited in here... If you have everything in one file, just put your once_flag "above" everything that uses it - the constructors in a file are executed in the order of declaration of objects. If you have the users spread across different files, your only option is to use a function that provides access to static internal once_flag - like in this answer http://www.parashift.com/c++-faq/static-init-order-on-first-use.html .