When are static and global variables initialized?

by

By static and global objects, I presume you mean objects with
static lifetime defined at namespace scope. When such objects
are defined with local scope, the rules are slightly different.

Formally, C++ initializes such variables in three phases:
1. Zero initialization
2. Static initialization
3. Dynamic initialization
The language also distinguishes between variables which require
dynamic initialization, and those which require static
initialization: all static objects (objects with static
lifetime) are first zero initialized, then objects with static
initialization are initialized, and then dynamic initialization
occurs.

As a simple first approximation, dynamic initialization means
that some code must be executed; typically, static
initialization doesn’t. Thus:

extern int f();

int g1 = 42;    //  static initialization
int g2 = f();   //  dynamic initialization

Another approximization would be that static initialization is
what C supports (for variables with static lifetime), dynamic
everything else.

How the compiler does this depends, of course, on the
initialization, but on disk based systems, where the executable
is loaded into memory from disk, the values for static
initialization are part of the image on disk, and loaded
directly by the system from the disk. On a classical Unix
system, global variables would be divided into three “segments”:

text:
The code, loaded into a write protected area. Static
variables with `const` types would also be placed here.
data:
Static variables with static initializers.
bss:
Static variables with no-initializer (C and C++) or with dynamic
initialization (C++). The executable contains no image for this
segment, and the system simply sets it all to `0` before
starting your code.

I suspect that a lot of modern systems still use something
similar.

EDIT:

One additional remark: the above refers to C++03. For existing
programs, C++11 probably doesn’t change anything, but it does
add constexpr (which means that some user defined functions
can still be static initialization) and thread local variables,
which opens up a whole new can of worms.

More Related Contents:

  1. C++ cannot initialize static data member [duplicate]
  2. Why are global and static variables initialized to their default values?
  3. Initialize static variables in C++ class?
  4. When are static C++ class members initialized?
  5. Are function static variables thread-safe in GCC?
  6. C++ where to initialize static const
  7. static and extern global variables in C and C++
  8. C++ singleton vs. global static object
  9. How is static variable initialization implemented by the compiler?
  10. static member initialization for specialized template class
  11. How to execute a piece of code only once?
  12. Are global variables bad? [closed]
  13. Do the parentheses after the type name make a difference with new?
  14. How to initialize private static members in C++?
  15. Why is list initialization (using curly braces) better than the alternatives?
  16. Array[n] vs Array[10] – Initializing array with variable vs numeric literal
  17. Uninitialized variable behaviour in C++
  18. Static constant string (class member)
  19. C++ static virtual members?
  20. static constructors in C++? I need to initialize private static objects
  21. Static variables in member functions
  22. conversion of 2D array to pointer-to-pointer
  23. How to initialise memory with new operator in C++?
  24. How do you create a static class in C++?
  25. C++ Overload Static Function with Non-Static Function
  26. Trouble launching CUDA kernels from static initialization code
  27. How can I make `new[]` default-initialize the array of primitive types?
  28. How to do the equivalent of memset(this, …) without clobbering the vtbl?
  29. How are local and global variables initialized by default?
  30. Why static variable needs to be explicitly defined?

Leave a Comment