关于非本地静态变量初始化的规则是什么？

Question

Suppose I have a class whose only purpose is the side-effects caused during construction of its objects (eg, registering a class with a factory):

class SideEffectCauser {
public:
  SideEffectCauser() { /* code causing side-effects */ }
};

Also suppose I'd like to have an object create such side-effects once for each of several translation units. For each such translation unit, I'd like to be able to just put an a SideEffectCauser object at namespace scope in the .cpp file, eg,

SideEffectCauser dummyGlobal;

but 3.6.2/3 of the C++03 standard suggests that this object need not be constructed at all unless an object or function in the .cpp file is used, and articles such as this and online discussions such as this suggest that such objects are sometimes not initialized.

On the other hand, Is there a way to instantiate objects from a string holding their class name? has a solution that is claimed to work, and I note that it's based on using an object of a type like SideEffectCauser as a static data member, not as a global, eg,

class Holder {
  static SideEffectHolder dummyInClass;
};

SideEffectHolder Holder::dummyInClass;

Both dummyGlobal and dummyInClass are non-local statics, but a closer look at 3.6.2/3 of the C++03 standard shows that that passage applies only to objects at namespace scope. I can't actually find anything in the C++03 standard that says when non-local statics at class scope are dynamically initialized, though 9.4.2/7 suggests that the same rules apply to them as to non-local statics at namespace scope.

Question 1: In C++03, is there any reason to believe that dummyInClass is any more likely to be initialized than dummyGlobal ? Or may both go uninitialized if no functions or objects in the same translation unit are used?

Question 2: Does anything change in C++11? The wording in 3.6.2 and 9.4.2 is not the same as the C++03 versions, but, from what I can tell, there is no behavioral difference specified for the scenarios I describe above.

Question 3: Is there a reliable way to use objects of a class like SideEffectHolder outside a function body to force side-effects to take place?

Answer 1

I think the only reliable solution is to design this for specific compiler(s) and runtime. No standard covers the initialization of globals in a shared library which I think is the most intricate case, as this is much dependent on the loader and thus OS dependent.

Q1: No Q2: Not in any practical sense Q3: Not in a standard way

Answer 2

I'm using something similar with g++ / C++11 under Linux and get my factories registered as expected. I'm not sure why you wouldn't get the functions called. If what you describes is to be implemented it will mean that every single function in that unit has to call the initialization function. I'm not too sure how that could be done. My factories are also inside namespaces, although it is named namespaces. But I don't see why it wouldn't be called.

namespace snap {
namespace plugin_name {
class plugin_name_factory {
public:
  plugin_name_factory() { plugin_register(this, name); }
...
} g_plugin_name_factory;
}
}

Note that the static keyword should not be used anymore in C++ anyway. It is often slower to have a static definition than a global.