C++静态变量的初始化

C++静态变量的初始化

摘要

在开发中经常会有一些全局的静态的对象，譬如logHandler，这些全局对象的使用可以简化实现代码，但使用不当却会导致莫名其妙的程序崩溃。本文从工程实践碰到的因全局变量导致崩溃的现实问题中萃取出一个例子,旨在讨论静态变量的初始化问题，及工程实践中与静态变量相关的常用技法。

一个例子

需求

需要为收藏的图书进行编号统一管理，希望人文社科类的书与计算编程类的书分开编号：

• 小说，ID范围是[1, 500]
• 计算编程，ID范围是[501, 1000]
• 心理学，ID范围是[1001, 1800]
• 哲学，ID范围是[1801, 2000]
• .....................

分析

我们需要多个ID产生器来产生不同范围的ID，设计一个IdGernerator类，在构造时指定产生ID的范围，提供一个generate接口，产生一个新的ID。如果有可用的ID，则返回一个空闲的ID。如果没有可用的ID，则返回INVALID_ID（-1）。

IdGenerator代码实现

// Name        : IdGenerator.h

struct IdGenerator {
    IdGenerator( unsigned int first
               , unsigned int last);
    int generate();
private:
    unsigned int firstId;
    unsigned int lastId;
    unsigned int firstAvailableId;
};

// Name        : IdGenerator.cpp
IdGenerator::IdGenerator( unsigned int first
                        , unsigned int last)
        : firstId(first)
        , lastId(last)
        , firstAvailableId(firstId)
{}
int IdGenerator::generate() {
    if(firstAvailableId > lastId) {
        return INVALID_ID;
    }
    int result = firstAvailableId;
    firstAvailableId++;
    return result;
}

NovelIdGenerator

// Name        : NovelBookIdGenerator.cpp

namespace {
    const unsigned int NovelBookStartId = 1;
    const unsigned int NovelBookEndId = 500;
    IdGenerator generator(NovelBookStartId, NovelBookEndId);
}

int getNovelBookId() {
    return generator.generate();
}

main()

// Name        : main.cpp

#include 
#include "NovelBookIdGenerator.h"
#include "IdDefine.h"
using namespace std;

int novelBookId = getNovelBookId();
int main(void) {
    if(novelBookId == INVALID_ID) {
        cout << "no valid novel book id available" << endl;
    }
    else {
        cout << "novelBookId: " << novelBookId << endl;
    }
    return 0;
}

BUG？

执行结果：

novelBookId: 0

这么简单的程序竟然有BUG？可肉眼已经发现不了它的存在，那么加点trace吧。

// Name        : IdGenerator.cpp
IdGenerator::IdGenerator( unsigned int first
                        , unsigned int last)
        : firstId(first)
        , lastId(last)
        , firstAvailableId(firstId) {
    printf("enter %s\n", __FUNCTION__);
    printf("firstId: %d", firstId);
    printf("lastId: %d", lastId);
    printf("firstAvailableId: %d\n", firstAvailableId);
}

int IdGenerator::generate() {
    printf("enter %s\n", __FUNCTION__);
    if(firstAvailableId > lastId) {
        printf("all id consumed!!!\n");
        return INVALID_ID;
    }
    int result = firstAvailableId;
    firstAvailableId++;
    return result;
}

执行结果

enter generate
enter IdGenerator
novelBookId: 0

结果分析

从trace的结果来看generate的调用竟然是在IdGenerator的构造之后！也就是说我们在通过函数getNovelBookId调用generator的generate方法时，generate对象本身竟然没有被构造！引用一个未初始化的变量，后果很严重啊！！！

原因分析

仔细阅读阅读代码，我们发现了两个不太寻常的地方。首先generator对象是定义在NovelBookIdGenerator.cpp中的匿名名字空间里的，是具有永久生命期的静态变量。而novelBookId则是定义在main.cpp里静态变量，它需要调用函数getNovelBookId()来做初始化。
从trace来看，novelBookId的初始化先执行，而generator的构造后执行，从而导致了运行结果不符合预期。

静态变量的初始化顺序

那么有没有办法指定静态的初始化顺序呢？在C++标准'ISOIEC14882-1998 3.6.2 Initialization of nonlocal objects'里明确规定，在同一个编译单元内，静态变量初始化的顺序就是定义的顺序，跨编译单元的静态变量的初始化顺序未定义！！！具体的初始化顺序取决于编译器的实现。

静态变量初始化过程

一个例子

阅读下面一段代码，推断程序的输出：

#include 
using namespace std;
int f();

int a = f();
int x = 22;
int f() {
    int result = x;
    x++;
    return result;
}
int main(void) {
    cout << "a is:" << a << endl;
    cout << "x is:" << x << endl;
}

如前文所述，在同一个编译单元里，静态变量的初始化顺序等同于定义的顺序。那么在这个例子中，应该首先初始化变量a，a=f()，由于x的值未初始化，所以a值是个随机值。接下来，x被初始化为22。
然而运行结果却是：

a is: 22
x is: 23

从执行结果上看，先于a被初始化。我们漏掉了啥？

静态变量初始化过程

静态变量的初始化分为两个过程，一个是静态初始化，一个是动态初始化。静态初始化在系统加载后执行第一条语句之前就已经完成。所以，可以认为所有的静态初始化过程是同步完成的。
而动态初始化，则在main函数之前完成，对于同一个编译单元内的静态变量，动态初始化顺序等同于定义顺序，而对于跨编译单元的静态变量，初始化顺序未定义。

静态初始化过程

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

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

对于有初始值的data中的数据，程序加载器(Program Loader)会根据其大小在内存中分配空间，并根据映像文件里存储的初始值对变量做初始化。
对于未初始化的bss中的数据，程序加载器(Program Loader)会根据其大小在内存中分配空间，按'ISO IEC14882-1998 8.5 Initializers'里规定，根据类型将变量初始化成默认初值：

Paste_Image.png

动态初始化过程

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

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

这是因为，对象的初始化依靠其构造函数的执行，所以一个对象的初始值是无法在编译是确定的。静态对象被放在 bss 段，加载时首先被清零。然后，程序在进入 main 函 数之前，静态对象的构造函数会被调用。但跨编译单元的静态变量的初始化顺序是未定义的。

结果分析

1. 静态初始化过程中，a被初始化为0，x被初始化为22
2. 触发a的动态初始化过程，调用函数f()，a被初始化成22，x被赋值成23

防范措施

避免跨编译单元的初始化依赖

常用技法construt on first use idiom

如果一个静态对象被定义在函数内，直到它所在的函数被第一次调用时才会被初始化。利用这样的特性,我们可以确保一个静态实例被读取时已被 初始化。这就消除了跨编译单元的静态对象的构造顺序不确定问题。

一个例子

// 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!!!

ID产生器问题的解决

// Name        : NovelBookIdGenerator.cpp
#include "IdGenerator.h"
namespace {
    const unsigned int NovelBookStartId = 1;
    const unsigned int NovelBookEndId = 500;
    IdGenerator &getIdGenerator() {
        static IdGenerator generator( NovelBookStartId
                                    , NovelBookEndId);
        return generator;
    }
}
int getNovelBookId() {
    return getIdGenerator().generate();
}

// Name : ProgrammingBookIdGenerator.cpp
#include "IdGenerator.h"
namespace { 
    const unsigned int ProgrammingBookStartId = 501; 
    const unsigned int ProgrammingBookEndId = 1000; 
    IdGenerator &getIdGenerator() { 
        static IdGenerator generator( ProgrammingBookStartId
                                                   , ProgrammingBookEndId); 
        return generator;
     }
}
int getProgrammingBookId() {
    return getIdGenerator().generate();
}