C-API开发中如何从动态库一次性初始化API函数指针

当前头文件中foo、baz函数指针用static修饰，该修饰符限定了变量的作用域仅为当前编译单元。每一个引入该头文件的实现文件都会生成独立的foo、baz副本，自然无法共享查找结果，需要每个单元单独执行符号查找。 #

你提到的将函数指针声明为extern、单独维护全局实例的思路是完全可行的，也是工业界常用的显式加载动态库的实现方式，以下是两种不同封装程度的实现方案：

方案1：全局导出函数指针（最贴近现有代码的修改方案） #

步骤1：修改API头文件 #

移除static修饰符，改为extern声明，同时新增加载/卸载接口：

// 原有宏定义保持不变
#ifdef __cplusplus
extern "C" {
#endif

API_DECL int ifoo(int bar);
API_DECL void ibaz(int qux);
typedef int (* PFN_FOO_PROC)(int);
typedef void (* PFN_BAZ_PROC)(int);
// 改为extern声明，不再定义变量
extern PFN_FOO_PROC foo;
extern PFN_BAZ_PROC baz;

// 新增加载卸载接口
// 返回0为加载成功，非0为失败
int load_my_lib(const char* lib_path);
void unload_my_lib(void);

#ifdef __cplusplus
}
#endif

步骤2：新增单独的加载实现文件 #

比如新建my_lib_loader.c，统一维护函数指针实例和加载逻辑，保证整个进程仅执行一次符号查找：

#include "你的API头文件名.h"
#include <dlfcn.h> // Windows下替换为<windows.h>

PFN_FOO_PROC foo = NULL;
PFN_BAZ_PROC baz = NULL;
static void* lib_handle = NULL;
static int is_initialized = 0;

// 多线程场景下建议替换为线程安全的单次初始化机制：
// Windows下用InitOnceExecuteOnce，Linux下用pthread_once，C11以上用atomic_flag
int load_my_lib(const char* lib_path) {
    if (is_initialized) return 0;
    if (lib_path == NULL) return -1;

    lib_handle = dlopen(lib_path, RTLD_LAZY);
    if (!lib_handle) return -2;

    foo = (PFN_FOO_PROC)dlsym(lib_handle, "ifoo");
    baz = (PFN_BAZ_PROC)dlsym(lib_handle, "ibaz");
    if (!foo || !baz) {
        unload_my_lib();
        return -3;
    }

    is_initialized = 1;
    return 0;
}

void unload_my_lib(void) {
    if (lib_handle) {
        dlclose(lib_handle);
        lib_handle = NULL;
    }
    foo = NULL;
    baz = NULL;
    is_initialized = 0;
}

使用时只需在进程启动时调用一次load_my_lib，所有引入头文件的单元都可以直接使用foo、baz指针。 #

方案2：封装函数指针（更安全的实现方案） #

如果不想暴露全局函数指针避免被误改，可以选择封装接口，头文件只暴露普通函数声明，把函数指针作为静态变量隐藏在实现文件中，还可以实现首次调用自动初始化：

头文件修改 #

// 原有宏定义保持不变
#ifdef __cplusplus
extern "C" {
#endif

// 直接暴露用户最终调用的接口，不暴露函数指针类型
int foo(int bar);
void baz(int qux);
int load_my_lib(const char* lib_path);
void unload_my_lib(void);

#ifdef __cplusplus
}
#endif

加载实现文件 #

#include "你的API头文件名.h"
#include <dlfcn.h>
#include <stdlib.h>

typedef int (* PFN_FOO_PROC)(int);
typedef void (* PFN_BAZ_PROC)(int);
static PFN_FOO_PROC s_foo = NULL;
static PFN_BAZ_PROC s_baz = NULL;
static void* s_lib_handle = NULL;
static int s_is_initialized = 0;

int load_my_lib(const char* lib_path) {
    // 加载逻辑和方案1完全一致，此处省略
}

void unload_my_lib(void) {
    // 卸载逻辑和方案1完全一致，此处省略
}

int foo(int bar) {
    if (!s_is_initialized) {
        // 可选：如果没有提前调用load，也可以在这里默认加载指定路径的库
        abort(); // 或者返回自定义错误码
    }
    return s_foo(bar);
}

void baz(int qux) {
    if (!s_is_initialized) abort();
    s_baz(qux);
}

如果你的项目使用C++，可以利用全局对象的构造函数在main之前执行、且全局唯一的特性，自动完成加载操作，无需手动调用初始化函数，注意做好加载失败的异常处理即可。

内容的提问来源于stack exchange，提问作者Decaf Sux