🚀 go-pugleaf

Sten Larsson <stenX@Xstenl.com> writes:

> Yes - I know... I just want to use some trick to guarantee that
> objects exist when I need them too. As far as I remember, with these
> global objects:
>
> string a;
> string b;
>
> There is really no way of knowing if a or b is created first (by
> reading the C++ standard), and this pretty much happens before the
> main thread kicks in (well, at least before main() is called.

If they are declared in the same source file, then their
initialization order is guaranteed to be in order of declaration.  If
they're declared in different source files that are later linked
together, then the order of initialization is indeterminate.

> Creating the objec using "new" instead of a local static wouldn't
> really improve things... right? I'm sure it would be a different error
> behaviour instead.

Actually it can help.  The much-maligned "singleton" pattern can help
with order-of-initialization problems, by creating the object on an
as-needed basis.  Thus, if we're creating singleton A and it uses
singleton B in its constructor, then creation A waits for the creation
of B to complete, and then A's construction continues, and so on.

One big problem of singleton pattern is cyclic dependencies, and if
you have a maze of different variables all initialized in different
files who all make use of each other, most likely it'll still fail,
because one singleton may make use of another singleton that is still
in the process of constructing, but that would cause another instance
to begin constructing, potentially creating an infinite recursive loop
until the program crashes.  Cyclic-dependencies are not a problem
specific to singletons at all, though.  It's just that singletons do
not help solve that problem.

Another problem with singletons is initialization in multi-threaded
applications is nearly impossible to do safely if you allow threads to
begin running before main (such as spawning them from the constructor
of a global variable.)  Double-checked locking attempts to help solve
the initialization problem in multiple threads in an efficient manner,
but has been shown to not work as well as desired.

-- 
Chris (TeamB);