动态链接库静态变量共享：单例类跨库访问的优化方案问询

我需要实现一个作为数据存储库的单例类ClassA，并在其cpp文件中声明run函数用于修改和打印数据。通过g++ -fPIC -shared -o lib1.so ClassA.cpp生成共享对象后，加载库并执行run函数时出现未定义符号的运行时错误。

原因是我未在单例类实现中初始化静态变量classA，而是在main.cpp中初始化——这么做是为了让单例对象存活在主进程内存中，供后续加载的动态库访问同一实例。请问有没有更优的实现方式？

当前实现代码 #

ClassA.h #

#ifndef _CLASSA_
#define _CLASSA_

class ClassA{
    private:
        int integer;
        static ClassA* classA;
        ClassA(){}

    public:
        static ClassA* getOrCreate();
        ~ClassA();
        int getInt();
        void setInt(int& a);
};

#endif // _CLASSA_

ClassA.cpp #

#include "ClassA.h"
#include <iostream>

ClassA* ClassA::getOrCreate() {
    if (classA == nullptr) {
        classA = new ClassA();
    }
    return classA;
}

ClassA::~ClassA() {
    delete classA;
}

int ClassA::getInt() {
    return integer;
}

void ClassA::setInt(int& a) {
    integer = a;
}

extern "C" void run() {
    int intin = 42;
    ClassA::getOrCreate()->setInt(intin);
    std::cout << "Value set: " << ClassA::getOrCreate()->getInt() << std::endl;
}

main.cpp #

#include <iostream>
#include <dlfcn.h>
#include "ClassA.h"

ClassA* ClassA::classA = nullptr;
int main() {
    void* handle = dlopen("./lib1.so", RTLD_LAZY);
    if (!handle) {
        std::cerr << "Cannot open library: " << dlerror() << std::endl;
        return 1;
    }
    typedef void (*run_func)();
    dlerror();
    run_func run = (run_func) dlsym(handle, "run");
    char* error = dlerror();
    if (error != NULL) {
        fprintf(stderr, "%s\n", error);
        dlclose(handle);
        exit(EXIT_FAILURE);
    }

    run();
    dlclose(handle);
    return 0;
}

更优实现方案 #

方案1：局部静态变量实现线程安全单例（推荐） #

用局部静态变量替代全局静态指针，C++11及以后标准保证局部静态变量的初始化是线程安全的，且无需外部初始化静态成员。这种方式下，单例实例的存储由编译器管理，动态库和主进程会自动访问到同一个实例（只要符号可见），同时解决了原代码中析构函数的递归问题。

修改后的核心代码：

ClassA.h（仅调整成员和接口）

#ifndef _CLASSA_
#define _CLASSA_

class ClassA{
    private:
        int integer;
        ClassA(){} // 移除全局静态指针成员

    public:
        static ClassA& getOrCreate(); // 返回引用而非指针，避免空指针风险
        ~ClassA() = default; // 默认析构，删除原递归逻辑
        int getInt();
        void setInt(int a); // 按值传递即可，无需引用
};

#endif // _CLASSA_

ClassA.cpp

#include "ClassA.h"
#include <iostream>

ClassA& ClassA::getOrCreate() {
    static ClassA instance; // 局部静态变量，仅初始化一次
    return instance;
}

int ClassA::getInt() {
    return integer;
}

void ClassA::setInt(int a) {
    integer = a;
}

extern "C" void run() {
    int intin = 42;
    ClassA::getOrCreate().setInt(intin);
    std::cout << "Value set: " << ClassA::getOrCreate().getInt() << std::endl;
}

main.cpp（移除静态成员初始化）

#include <iostream>
#include <dlfcn.h>
#include "ClassA.h"

int main() {
    void* handle = dlopen("./lib1.so", RTLD_LAZY);
    if (!handle) {
        std::cerr << "Cannot open library: " << dlerror() << std::endl;
        return 1;
    }
    typedef void (*run_func)();
    dlerror();
    run_func run = (run_func) dlsym(handle, "run");
    char* error = dlerror();
    if (error != NULL) {
        fprintf(stderr, "%s\n", error);
        dlclose(handle);
        exit(EXIT_FAILURE);
    }

    run();
    dlclose(handle);
    return 0;
}

编译命令保持不变：

g++ -fPIC -shared -o lib1.so ClassA.cpp
g++ main.cpp -o main -ldl

方案2：显式导出主进程符号（兼容旧需求） #

如果必须保留全局静态指针的设计，需要确保主进程的ClassA::classA符号能被动态库访问到。编译主程序时添加-rdynamic选项，让主程序的全局符号对动态库可见：

编译命令：

# 编译动态库
g++ -fPIC -shared -o lib1.so ClassA.cpp
# 编译主程序，链接ClassA实现并导出符号
g++ main.cpp ClassA.cpp -o main -ldl -rdynamic

同时必须删除原析构函数中的delete classA;代码，避免无限递归调用。

内容的提问来源于stack exchange，提问作者Tejas Sharma