背景

常用单例之间操作相互依赖或者对同一份资源进行操作。进行对象或资源释放时候，很容易重复，导致程序异常。

依赖顺序

// a.cpp
static A a;  // 第1个构造 → 最后释放
static LateDestructor late;  // 依赖a，会后析构

// b.cpp
static B b;  // 构造顺序依赖链接顺序 → 释放顺序不确定

// main.cpp
void foo() {
    static C c;  // 在foo()首次调用时构造 → 在main.cpp其他静态变量之后释放
}

int main() {
    foo();
    static D d;  // 构造顺序较晚 → 释放顺序较早
    return 0;
}
释放顺序：d → c → a → b（b的顺序不确定）

aexit

#include <cstdlib>
#include <iostream>

void func1() { std::cout < "First\n"; }
void func2() { std::cout < "Second\n"; }
void func3() { std::cout < "Third\n"; }

int main() {
    atexit(func1);  // 第一个注册
    atexit(func2);  // 第二个注册
    atexit(func3);  // 第三个注册
    return 0;       // 执行顺序: func3 → func2 → func1
}

晚释放单例类

//C++单例延后释放类 解决单例相互依赖问题，将当前单例留到最后释放。
class FTLibraryInstance
{
public:
    static std::string getVersion();
    static FT_Library &library();
    static void        release();
};

// 自定义删除器
struct FTLibraryDeleter
{
    void operator()(FT_Library *lib)
    {
        if (lib)
            FT_Done_FreeType(*lib);
    }
};

static std::unique_ptr<FT_Library, FTLibraryDeleter> kFTLibrary;

FT_Library &FTLibraryInstance::library()
{
    if (!kFTLibrary) {
        auto lib = new FT_Library;
        kFTLibrary.reset(lib);
        FT_New_Library(&gFTMemory, lib);
        FT_Add_Default_Modules(*lib);
        FT_Set_Default_Properties(*lib);
    }
    return *kFTLibrary;
}

std::string FTLibraryInstance::getVersion()
{
    auto lib = library();
    if (!lib)
        return "";
    FT_Int major, minor, patch;
    FT_Library_Version(lib, &major, &minor, &patch);
    std::string freetypeVersion = std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
    return freetypeVersion;
}

void FTLibraryInstance::release()
{
    kFTLibrary.reset();
}

创作不易，小小的支持一下吧！