静态变量的初始化分为两个过程，一个是静态初始化，一个是动态初始化。

静态初始化在系统加载后执行第一条语句之前就已经完成。所以，可以认为所有的静态初始化过程是同步完成的。

动态初始化，则在main函数之前完成，对于同一个编译单元内的静态变量，动态初始化顺序等同于定义顺序，而对于跨编译单元的静态变量，初始化顺序未定义。

静态数据有两种：已初始化数据和未初始化数据。

在映像文件里,它们分别被放入 data 段和 bss段。只有 data 段的已初始化的数据才会真正被放入映像文件。

int a=5;//data 段 
int b;  //bss 段

一个静态定义的对象，却永远会被放在 bss 段，无论是否用初始化表达式。

Foo a; // bss 段
Foo b = Foo(); // bss 段

这是因为，对象的初始化依靠其构造函数的执行，所以一个对象的初始值是无法在编译时确定的。

静态对象被放在 bss 段，加载时首先被清零。

然后，程序在进入 main 函 数之前，静态对象的构造函数会被调用。

但跨编译单元的静态变量的初始化顺序是未定义的。

#include <iostream>
using namespace std;

struct MyHello
{
    MyHello()
    {
        cout<<"MyHello"<<endl;
    }
};

int hello()
{
    //调用了hello函数后才初始化;
    static MyHello myHello;
    return 0;
}

struct Hello
{
    Hello()
    {
        cout<<"Hello"<<endl;
    }
};

struct Test
{
    Test()
    {
        cout<<"Test"<<endl;
    }
    
    int assignA()
    {
        cout<<"call assignA"<<endl;
        cout<<"a"<<a<<endl<<"b"<<b<<endl;
        return b;
    }
    Hello hello;
    int a = assignA();
    int b;
};
/*
编译时编译器为静态对象test分配内存;
保存在bss段,加载时首先被清零(成员变量a = 0, b = 0);
在main函数之前,按照成员变量顺序初始化完后,再调用构造函数;
先初始化对象hello,再初始化a,然后是b;
*/
static Test test;// 在main函数之前初始化;

int main(void) 
{
    cout<<"======main start======="<<endl;
    /*
    ddd是自动变量,成员变量a,b没有被清零的过程,所以打印的值为垃圾值;
    */
    Test ddd;
    /*
        函数内的静态变量,在函数第一次调用的时候初始化;
    */
    hello();
    return 0;
}

执行结果：

daniel@daniel:~/桌面$ ./a.out 
Hello
call assignA
a0
b0
Test
======main start=======
Hello
call assignA
a-146855904
b32764
Test
MyHello

如果一个静态对象被定义在函数内，直到它所在的函数被第一次调用时才会被初始化。

利用这样的特性,我们可以确保一个静态实例被读取时已被 初始化。

这就消除了跨编译单元的静态对象的构造顺序不确定问题。

一个例子：

// Name        : ConstructOnFirstUse.h
struct C{
    C(){
        printf("Construct C\n");
    }
};
struct B{
    B(){
        C &v = getC();
        printf("C should be constructed before use\n");
        printf("Construct B\n");
    }
};
struct A{
    A(){
        B &v = getB();
        printf("B should be constructed before use\n");
        printf("Construct A\n");
    }
};

// Name        : B.cpp 
B& getB() {
    static B v;
    return v;
}

// Name        : C.cpp
C& getC() {
    static C v;
    return v;
}

// Name        : ConstructOnFirstUse.cpp
#include "ConstructOnFirstUse.h"
A a;
int main(void) {
    printf("Hello World!!!");
    return EXIT_SUCCESS;
}

运行结果：

Construct C
C should be constructed before use
Construct B
B should be constructed before use
Construct A
Hello World!!!

参考文献：

1. C++中static变量的初始化
2. C++静态变量初始化