What exactly does "static initialization" mean?

Question

I've been reading up on PODs in C++11, and several of the places I've read have said something about PODs supporting static initialization. For example:

On StackOverflow:

The idea of a POD is to capture basically two distinct properties:
1. It supports static initialization, and
2. Compiling a POD in C++ gives you the same memory layout as a struct compiled in C.

(only the bolded part is relavent)

On Wikipedia:

A type that is trivial can be statically initialized.

Apparently I'm not understanding what static initialization is. I thought making a global variable was an example of static initialization, but I can do the following and yet Foo isn't a POD:

#include <type_traits>
#include <iostream>

struct Foo {
  Foo() : x(0), y(0) {}
  int x;
  int y;
};

struct Bar {
  Bar() = default;
  int x;
  int y;
};

// Apparently the following two lines are not "static initialization" because
// Foo is non-POD yet we can still do this:
Foo f;
Bar b;

int main()
{
    if (std::is_pod<Foo>::value) std::cout << "Foo is a POD" << std::endl;
    else                         std::cout << "Foo is *not* a POD" << std::endl;

    if (std::is_pod<Bar>::value) std::cout << "Bar is a POD" << std::endl;
    else                         std::cout << "Bar is *not* a POD" << std::endl;
}

Output:

Foo is *not* a POD
Bar is a POD

So what exactly is static initialization, and how does it relate to trivial classes? Examples would be awesome.

Answer 1

Static initialization is initialization of some variable with a compile-time value such that the value ends up being "baked into" the executable image (no code needs to be actually run):

struct Foo {
  int x;
  int y;
};

Foo foo = { 0, 1 };

In the above example struct Foo is POD, so the compiler knows that its memory layout is just two integers next to each other. It also knows that foo.x should be initialized to 0 and foo.y to 1. This is enough information to produce a "memory image" of how foo should look at compile time and write it into the executable image.

When the image is later run, the OS loader maps its contents to a memory address and in this way makes foo "alive". The important thing is that the "initialization" of foo has actually completed before the process (which includes your code and also code from the C/C++ runtimes, which get to run first) has had time to execute even a single CPU instruction.

Answer 2

Initialization of objects with static duration is divided in two passes, static initialization and dynamic initialization (note the abuse of the term static :)).

Dynamic initialization refers to initialization that involves calling functions, and thus must take place at runtime, compared with initialization from literals that can be stored in the executable itself and just loaded.

Answer 3

Static initialization applies to variables with static or thread storage duration. It happens in two phases.

First, variables with static storage duration are zero-initialized before any other initialization.

Then constant initialization is performed. Constant initialization has to be one of the following three possibilities (§3.6.2/2):

• if each full-expression (including implicit conversions) that appears in the initializer of a reference with static or thread storage duration is a constant expression (5.19) and the reference is bound to an lvalue designating an object with static storage duration or to a temporary (see 12.2);

• if an object with static or thread storage duration is initialized by a constructor call, if the constructor is a constexpr constructor, if all constructor arguments are constant expressions (including conversions), and if, after function invocation substitution (7.1.5), every constructor call and full-expression in the mem-initializers and in the brace-or-equal-initializers for non-static data members is a constant expression;

• if an object with static or thread storage duration is not initialized by a constructor call and if every full-expression that appears in its initializer is a constant expression.

Any other initialization (even of a global variable) is dynamic initialization. A compiler is, however, allowed to treat dynamic initialization as if it were static initialization, provided that doing so doesn't change the externally visible effects of the program, assuming it can figure out the correct value (even if that value doesn't officially qualify as a constant expression).

The definition of a constant expression is (unfortunately) rather long and involved. The basic style of the definition is to define a core constant expression as any expression except those fitting a list of exceptions (that, unfortunately, is more than a page long so summarizing it to something that's quick and easy to understand wouldn't be easy).

Answer 4

Static member initialization occurs in class scope. Therefore, they can access other member data or functions.

That's quoted from MSDN

There is a good example of how it works there.