20. 静态对象的构造与析构：静态局部对象、静态全局对象、静态对象的初始化顺序问题

静态对象这个话题，说实话，很多C++开发者写了三五年代码都不一定完全搞明白。我记得刚入行那会儿，遇到一个诡异的崩溃问题，查了两天才发现是静态对象初始化顺序惹的祸。从那以后，我对这块就格外上心。

今天咱们就把静态对象的构造与析构彻底聊透。你想想看，静态对象和普通对象最大的区别是什么？——生命周期。普通对象在栈上或堆上，生灭由你控制；静态对象呢，程序启动时就存在，程序结束时才销毁。这个「存在感」贯穿了整个进程的生命周期。

20.1 静态对象的三种形态

静态对象按作用域可以分为三类，我习惯用一张图来理解它们的关系：

20.2 静态全局对象：程序启动的「先遣队」

静态全局对象在 main() 函数执行之前就完成了构造。说白了，你的程序还没开始跑业务逻辑，这些对象就已经活蹦乱跳了。

// file1.cpp
#include <iostream>
class GlobalObj {
public:
    GlobalObj() { std::cout << "GlobalObj constructed\n"; }
    ~GlobalObj() { std::cout << "GlobalObj destroyed\n"; }
};

static GlobalObj g_obj;  // 静态全局对象
// 或者：GlobalObj g_obj;  // 不加 static 也是全局对象，但外部可见

嗯，这里要注意：不加 static 的全局变量具有外部链接性，其他翻译单元可以通过 extern 访问到它。加了 static 则限定在当前文件内部。我个人习惯在不需要外部访问的全局对象前加 static，这样能避免不少链接冲突。

20.3 静态局部对象：懒加载的「老油条」

静态局部对象就很有意思了。它只在函数内部可见，但生命周期贯穿整个程序。最关键的是——它只在第一次调用到该函数时才构造。

class Logger {
public:
    Logger() { std::cout << "Logger created\n"; }
    ~Logger() { std::cout << "Logger destroyed\n"; }
    void log(const std::string& msg) { std::cout << msg << "\n"; }
};

void useLogger() {
    static Logger logger;  // 第一次调用时构造
    logger.log("Hello from static local");
}

int main() {
    std::cout << "main() starts\n";
    useLogger();  // 这里才构造 Logger
    useLogger();  // 第二次调用，不再构造
    std::cout << "main() ends\n";
    // 程序结束时 Logger 析构
}

输出结果：

main() starts
Logger created
Hello from static local
Hello from static local
main() ends
Logger destroyed

20.4 静态对象的初始化顺序问题

这是个大坑。我曾经在一个项目中，两个静态全局对象互相依赖，结果程序一启动就崩溃。查了半天，发现是初始化顺序不确定导致的。

先看一个经典的反面教材：

// a.h
struct A {
    A() { std::cout << "A constructed\n"; }
    void doSomething() {}
};

// a.cpp
#include "a.h"
A g_a;  // 静态全局对象 A

// b.cpp
#include "a.h"
struct B {
    B() { 
        std::cout << "B constructed\n";
        g_a.doSomething();  // 危险！g_a 可能还没构造
    }
};
B g_b;  // 静态全局对象 B

问题出在哪？g_a 和 g_b 的构造顺序由链接器决定，不同编译器、不同编译选项都可能产生不同顺序。如果 g_b 先构造，它调用 g_a.doSomething() 时 g_a 还没构造——未定义行为。

20.5 解决方案：Nifty Counter 与 Construct On First Use

解决静态初始化顺序问题的标准手法有两个：

方案一：Construct On First Use（首次使用时构造）

// 把全局对象改成函数内的静态局部对象
A& getA() {
    static A instance;  // 首次调用时构造
    return instance;
}

B& getB() {
    static B instance;
    return instance;
}

// 使用时通过函数获取
void someFunc() {
    getA().doSomething();
    getB().doSomething();
}

这个方案简单有效。函数内部的 static 变量在第一次调用时初始化，而且 C++11 保证线程安全。说白了，这就是「懒加载」的思想——不到用的时候不构造。

方案二：Nifty Counter（灵巧计数器）

这个手法在标准库实现中很常见，比如 std::cout、std::cin 等全局流对象就是用这个方式初始化的。

// 头文件 nifty.h
#pragma once
struct NiftyCounter {
    NiftyCounter();
    ~NiftyCounter();
    static int counter_;
};

extern NiftyCounter nifty_counter_;
extern std::ostream& my_cout;  // 全局引用

// 实现文件 nifty.cpp
#include "nifty.h"
#include <iostream>

int NiftyCounter::counter_ = 0;
std::ostream* my_cout_ptr = nullptr;

NiftyCounter::NiftyCounter() {
    if (counter_++ == 0) {
        my_cout_ptr = new std::ostream(std::cout.rdbuf());
    }
}

NiftyCounter::~NiftyCounter() {
    if (--counter_ == 0) {
        delete my_cout_ptr;
        my_cout_ptr = nullptr;
    }
}

NiftyCounter nifty_counter_;  // 每个包含头文件的翻译单元都有一个
std::ostream& my_cout = *my_cout_ptr;

原理很简单：每个包含头文件的 .cpp 文件都会生成一个 NiftyCounter 静态对象。第一个构造的负责初始化全局资源，最后一个析构的负责清理。这样就保证了全局对象在任何使用它的翻译单元之前完成构造。

20.6 析构顺序：后构造的先析构

静态对象的析构顺序与构造顺序完全相反。这个规则和栈上对象的析构规则一致——后进先出。

struct Obj {
    const char* name_;
    Obj(const char* name) : name_(name) {
        std::cout << name_ << " constructed\n";
    }
    ~Obj() {
        std::cout << name_ << " destroyed\n";
    }
};

Obj g_a("Global A");
Obj g_b("Global B");

void func() {
    static Obj local("Static Local");
}

int main() {
    func();
    return 0;
}

输出：

Global A constructed
Global B constructed
Static Local constructed
Static Local destroyed
Global B destroyed
Global A destroyed

看到没？Global A 先构造，最后析构；Static Local 最后构造，最先析构。这个顺序是确定的，但前提是——你得知道构造顺序是什么。

20.7 实战中的注意事项

场景	风险	建议
静态全局对象互相依赖	初始化顺序未定义	改用 Construct On First Use
静态对象析构时访问其他静态对象	对方可能已析构	避免在析构函数中访问外部静态对象
多线程首次访问静态局部对象	C++11 已保证线程安全	放心使用，但注意析构时的竞态
静态对象抛出异常	程序直接终止	确保静态对象的构造/析构不抛异常

好了，静态对象的构造与析构就聊到这里。记住，静态对象虽然方便，但用不好就是定时炸弹。下次遇到程序启动就崩溃的 bug，不妨先检查一下静态对象的初始化顺序——说不定就是它搞的鬼。

---

公众号:蓝海资料掘金营，微信deep3321