Can I change static variable initialization order in C++?

Question

I use C++ in Visual Studio 2015 sp3. By

#pragma init_seg(compiler)

, I initialize some static variables first(to memory management). https://msdn.microsoft.com/en-us/library/7977wcck.aspx

But, there is

#pragma init_seg(compiler)

in wcerr.cpp(Microsoft Visual Studio 14.0\VC\crt\src\stl\wcerr.cpp), so these objects are initialized before my objects.

Can I compel my object to be initialized first before wcerr.cpp objects by any compile / link options?

Answer 1

One of solutions is to try wrap your static variables to static functions:

static type& My_static_obj() {
    static type my_static_obj_;
    return my_static_obj_;
}

It looks like a simple type of Singleton and calls Construct On First Use Idiom. Due to standard (C++11 and above) it guaranteed to be initialized once (and even atomically!), and inside its c-tor such an object can access to other "static" variables, so, if there aren't circular dependencies between variables, the order of initialization will be strictly defined.

For additional information see this question and other descriptions of this Construct On First Use Idiom.

Answer 2

Probably the nifty counter idiom can help you somehow in this case:

Ensure a non-local static object is initialized before its first use and destroyed only after last use of the object.

Its motivation is pretty clear:

When static objects use other static objects, the initialization problem becomes more complex. A static object must be initialized before its use if it has non-trivial initialization. Initialization order of static objects across compilation units is not well-defined. Multiple static objects, spread across multiple compilation units, might be using a single static object. Therefore, it must be initialized before use. One example is std::cout, which is typically used by a number of other static objects.

It's worth it to copy and paste directly the example from the above linked page:

Stream.h

#ifndef STREAM_H
#define STREAM_H

struct Stream {
  Stream ();
  ~Stream ();
};
extern Stream& stream; // global stream object

static struct StreamInitializer {
  StreamInitializer ();
  ~StreamInitializer ();
} streamInitializer; // static initializer for every translation unit

#endif // STREAM_H

Stream.cpp

#include "Stream.h"

#include <new>         // placement new
#include <type_traits> // aligned_storage

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 ();
}

The header file of the Stream class must be included before any member function can be called on the Stream object. An instance of the StreamInitializer class is included in each compilation unit. Any use of the Stream object follows the inclusion of the header, which ensures that the constructor of the initializer object is called before the Stream object is used.

See the link above for further details.

Answer 3

EDIT: I think the solution you need is to use another STL implementation, if you need to use MSVC 2015 and also avoid reimplementing your current memory management hack (sorry to call it that but that's what it sounds like, but then again I've used a few hacks of my own to work with MSVC).

I have never used an STL implementation that was not included with the development environment, but it is possible. It should be a simple matter of setting your include and library paths to the alternative STL implementation. You might start with trying STLPort

Otherwise, my original advice regarding your question, before the last edit:

Static initialization order within a compilation unit (cpp file) is the order in which the declarations are made. Static initilization order between compilation units is undefined. Do not use static initialization to solve this problem.

It looks like RustyX is pointing you in the right direction with his comment linking to Overriding memory allocator in MSVC++.

EDIT: It looks like the answer you are looking for might be here: How to properly replace global new & delete operators. Note that both answers are relevant, you will want to replace new, delete, new[] and delete[]. Since this is applied during linking, apparently Windows will not use these for DLLs you load (see comments on the first answer).