How to write code to be executed before main() gets control?

Question

I am porting a class to C++ and need to execute some initialization code before the first instance of my class is created; executing the code before main() gets control suits me. How to do it in C++?

Answer 1

Initial answer

You could use a constructor of an object at namespace scope.

namespace {
struct Init
{
    Init()
    {
        // Initialization code here.
    }
} init_;
} // namespace

Beware, this has some limitations, especially on Windows. On Windows, the ctor is invoked with the loader lock held, thus you cannot do anything that would require loading DLLs and such. This includes initialization of WinSock because it can try to load external DLLs.

Update

According to some sources, you can work around this limitation by using QueueUserAPC. This technique has limitations as well, albeit different ones. I have used this and my experiments show that this only works if you are using Visual Studio and its C library as DLL, i.e., the MSVCRT.DLL, MSVCR100.DLL, etc. (/MD or /MDd switches)

Update 2

Here is a link to similar issue (mine, actually) with one important bit:

After some testing it seems that the APC method works if I queue the APC from DllMain() but it does not work if I queue the APC from a ctor of a static global instance of a class.

Answer 2

struct Init
{
   Init() 
   {
      /* Your Initialization Code */
   }
} x;

int main()
{

}

Answer 3

Global and static classes are constructed before main() starts executing.

class hello {

    hello () { std::cout << "hello" << std::endl; }

};


hello hi;

int main(){
   std::cout << "hello again" << std::endl;
   return 0;

}

output will always be

hello
hello again

since the hello object instance is created before main starts since hi is a global instance of class hello

Answer 4

My answer addresses your real problem - performing one-time initialization before the first instance of your class, not executing before main.

Just use a static variable to make sure you execute the one time init code only once. Use synchronization if you need to be thread-safe, though it would have a performance hit.

class MyClass {
    MyClass() {
         // Perform the one-time initialization.
         static bool passed = false;
         if (!passed) {
             performOneTimeInitialization();
             passed = true;
         }

         // Continue with normal construction.
    }
};

Answer 5

An additional solution to your real problem (using factory methods):

namespace 
{
    struct Initializer
    {
        Initializer()
        {
        /* initializing code goes here */
        }
    }
}

MyClass CreateMyClass()
{
    static Initializer init;
    return new MyClass();
}

The initializing code is executed the first time you call CreateMyClass. It should be even threadsafe with a C++11 compiler. If you don't have one and need the thread-safety, you can check boost::call_once.

Answer 6

You are in fact asking two different questions here, one describing the problem you want to solve:

I [...] need to execute some initialization code before the first instance of my class is created;

And the second is about how you think the problem can be solved:

executing the code before main() gets control suits me. How to do it in C++?

For that second question you already have one answer multiple times (the global variable). This can be a viable solution, although I'd prefer a private static class member to limit the visibility of that global variable:

class X {
  const static bool initialized;

};

//X.cpp:
namespace {
  bool preInitialization() {
    //your pre-main code here
    return true;
  }
}

bool X::initialized = preInitialization();

For the first question, you could delay the execution of the initialization code until right when the first variable of your class gets initialized:

class X {
  X();
};

//X.cpp:

namespace {
  bool preInitialization() {
    //your pre-main code here
    return true;
  }
}

X::X() {
  static bool b = preInitialization();
}

That way your code executes during the first constructor call of X. That may have some drawbacks, e.g. if the members of X can only be initialized after the initialization code has executed, or in the presence of multiple constructors. You can refine that method by pushing it into an empty base class:

class PreInit {
  static bool preInitialization() {
    //your pre-main code here
    return true;
  }
public:
  PreInit() {
    static bool b =preInitialization();
  }
};

class X : private PreInit {
  //normal class implementation
};

That way you can even execute the code before the first construction of any object of a number of classes, just by deriving all the classes in question from the PreInit class. It is only a better design to factor out the pre-initialization into a class of its own, obeying the SRP.