C++ 动态库加载与卸载：`dlopen`/`LoadLibrary` 的跨平台实践

好的，各位观众老爷们，掌声在哪里！今天咱们来聊聊C++动态库加载与卸载，也就是dlopen/LoadLibrary 这对好基友的跨平台故事。

前言：动态库是个啥玩意儿？

话说，程序员的世界里，代码就像一堆乐高积木，可以拼成各种各样的城堡。但有些城堡特别复杂，一次性拼完累死个人。于是，聪明的人们发明了动态库，也就是把城堡的一部分拆出来，需要的时候再拼上去。

动态库（Dynamic Library），也叫共享库（Shared Library），就是把一些常用的函数、类啥的打包在一起，等到程序运行的时候才加载。这样有啥好处呢？

节省空间： 多个程序可以共享同一个动态库，不用每个程序都存一份，省硬盘啊！
方便更新： 动态库更新了，只需要替换一下动态库文件，不用重新编译整个程序。想想看，如果微信更新一个表情包就要你重新安装整个APP，你受得了么？
模块化： 可以把程序拆成一个个模块，每个模块对应一个动态库，方便维护和扩展。

主角登场：dlopen/LoadLibrary

现在，咱们的主角就要闪亮登场了。dlopen和LoadLibrary，它们就是负责把动态库这块乐高积木拼接到程序城堡上的工具。

dlopen： 这是Linux/Unix平台上的大哥，出自POSIX标准，由libdl库提供。
LoadLibrary： 这是Windows平台上的扛把子，属于Windows API。

虽然它们来自不同的平台，但功能差不多：加载动态库，并返回一个句柄，以后就可以通过这个句柄来访问动态库里的函数和变量了。

跨平台之路：弯弯绕绕也精彩

问题来了，咱们想写一个跨平台的程序，既能在Linux上跑，也能在Windows上飞，那咋办呢？直接用dlopen，Windows不认；直接用LoadLibrary，Linux不屌。

这时候，就需要一些技巧了，也就是所谓的“跨平台适配”。

方案一：条件编译大法好

最简单的办法就是用条件编译，根据不同的平台选择不同的函数。

#ifdef _WIN32 // Windows平台
#include <Windows.h>
#define LIB_HANDLE HMODULE
#define LOAD_LIB(lib_name) LoadLibraryA(lib_name) // LoadLibraryW for Unicode
#define GET_PROC_ADDRESS(handle, func_name) GetProcAddress(handle, func_name)
#define UNLOAD_LIB(handle) FreeLibrary(handle)
#else // Linux/Unix平台
#include <dlfcn.h>
#define LIB_HANDLE void*
#define LOAD_LIB(lib_name) dlopen(lib_name, RTLD_LAZY)
#define GET_PROC_ADDRESS(handle, func_name) dlsym(handle, func_name)
#define UNLOAD_LIB(handle) dlclose(handle)
#endif

#include <iostream>

typedef int (*MyFuncType)(int); // 函数指针类型

int main() {
  LIB_HANDLE lib_handle = LOAD_LIB("mylibrary.so"); // Linux: mylibrary.so, Windows: mylibrary.dll
  if (!lib_handle) {
    std::cerr << "Failed to load library!" << std::endl;
#ifdef _WIN32
    std::cerr << "Error code: " << GetLastError() << std::endl;
#else
    std::cerr << "Error: " << dlerror() << std::endl;
#endif
    return 1;
  }

  MyFuncType my_func = (MyFuncType)GET_PROC_ADDRESS(lib_handle, "myFunction");
  if (!my_func) {
    std::cerr << "Failed to find function!" << std::endl;
#ifdef _WIN32
    std::cerr << "Error code: " << GetLastError() << std::endl;
#else
    std::cerr << "Error: " << dlerror() << std::endl;
#endif
    UNLOAD_LIB(lib_handle);
    return 1;
  }

  int result = my_func(10);
  std::cout << "Result: " << result << std::endl;

  UNLOAD_LIB(lib_handle);
  return 0;
}

这段代码看起来有点长，但其实很简单：

用#ifdef判断当前平台是Windows还是Linux。
根据平台定义一些宏，比如LIB_HANDLE、LOAD_LIB、GET_PROC_ADDRESS和UNLOAD_LIB，把平台相关的函数封装起来。
加载动态库，获取函数指针，调用函数，卸载动态库。

这种方法简单粗暴，但是缺点也很明显：代码里到处都是#ifdef，看起来很乱，维护起来也很麻烦。

方案二：封装一层，化繁为简

为了解决条件编译带来的问题，我们可以把平台相关的代码封装到一个类里，对外提供统一的接口。

#include <iostream>

#ifdef _WIN32
#include <Windows.h>
#else
#include <dlfcn.h>
#endif

class DynamicLibrary {
public:
    DynamicLibrary(const std::string& filename) : handle_(nullptr) {
#ifdef _WIN32
        handle_ = LoadLibraryA(filename.c_str());
#else
        handle_ = dlopen(filename.c_str(), RTLD_LAZY);
#endif
        if (!handle_) {
            std::cerr << "Failed to load library: " << filename << std::endl;
#ifdef _WIN32
            std::cerr << "Error code: " << GetLastError() << std::endl;
#else
            std::cerr << "Error: " << dlerror() << std::endl;
#endif
        }
    }

    ~DynamicLibrary() {
        if (handle_) {
#ifdef _WIN32
            FreeLibrary(reinterpret_cast<HMODULE>(handle_));
#else
            dlclose(handle_);
#endif
            handle_ = nullptr;
        }
    }

    void* getSymbol(const std::string& symbol_name) {
        if (!handle_) {
            std::cerr << "Library not loaded." << std::endl;
            return nullptr;
        }
#ifdef _WIN32
        return GetProcAddress(reinterpret_cast<HMODULE>(handle_), symbol_name.c_str());
#else
        return dlsym(handle_, symbol_name.c_str());
#endif
    }

    bool isLoaded() const {
        return handle_ != nullptr;
    }

private:
#ifdef _WIN32
    HMODULE handle_;
#else
    void* handle_;
#endif
};

typedef int (*MyFuncType)(int); // 函数指针类型

int main() {
    DynamicLibrary my_lib("mylibrary.so"); // Linux: mylibrary.so, Windows: mylibrary.dll

    if (!my_lib.isLoaded()) {
        return 1;
    }

    MyFuncType my_func = (MyFuncType)my_lib.getSymbol("myFunction");
    if (!my_func) {
        std::cerr << "Failed to find function!" << std::endl;
        return 1;
    }

    int result = my_func(20);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

这个DynamicLibrary类封装了动态库的加载、卸载和获取函数指针的操作。这样，主程序里就不用再写#ifdef了，代码看起来清爽多了。

动态库的命名规则：入乡随俗

不同的平台对动态库的命名规则不一样。

平台	命名规则	例子
Linux	`lib<库名>.so.<版本号>`	`libmylibrary.so.1`
Windows	`<库名>.dll`	`mylibrary.dll`
macOS	`lib<库名>.dylib` 或 `<库名>.framework`	`libmylibrary.dylib`

所以，在跨平台的时候，要注意动态库的命名，不然程序会找不到库。

解决依赖问题：找爹之路漫漫

动态库经常会依赖其他的库，就像儿子要找爹一样。如果找不到爹，儿子就没法活下去。

Linux： Linux系统会在一些默认的目录里搜索动态库，比如/lib、/usr/lib。也可以通过设置LD_LIBRARY_PATH环境变量来告诉系统去哪里找库。
Windows： Windows系统会按照一定的顺序搜索动态库：
1. 程序所在的目录
2. 系统目录
3. PATH环境变量里指定的目录

解决依赖问题的方法有很多：

把依赖的库放到系统目录下或者PATH环境变量里。 这种方法简单粗暴，但是可能会污染系统环境。
修改程序的配置文件，指定动态库的搜索路径。 这种方法比较灵活，但是需要修改配置文件。
把依赖的库和程序打包在一起。 这种方法最简单，但是会增加程序的大小。

实战演练：一个简单的例子

咱们来写一个简单的例子，演示一下动态库的加载和卸载。

首先，创建一个动态库mylibrary.cpp：

// mylibrary.cpp
#include <iostream>

#ifdef _WIN32
#define EXPORT __declspec(dllexport)
#else
#define EXPORT
#endif

extern "C" {

EXPORT int myFunction(int x) {
    std::cout << "Hello from mylibrary!" << std::endl;
    return x * 2;
}

}

这个动态库里只有一个函数myFunction，它接受一个整数作为参数，返回它的两倍。

注意：

extern "C"是为了防止C++编译器对函数名进行修饰，保证在加载动态库的时候能找到这个函数。
__declspec(dllexport)是Windows平台上的关键字，用于声明一个函数可以被导出到动态库里。

然后，编译这个动态库：

Linux： g++ -fPIC -shared mylibrary.cpp -o libmylibrary.so
Windows： g++ -shared mylibrary.cpp -o mylibrary.dll -Wl,--output-def,mylibrary.def,--out-implib,libmylibrary.a (需要MinGW环境)

接下来，创建一个主程序main.cpp：

// main.cpp
#include <iostream>

#ifdef _WIN32
#include <Windows.h>
#else
#include <dlfcn.h>
#endif

#include <string>

class DynamicLibrary {
public:
    DynamicLibrary(const std::string& filename) : handle_(nullptr) {
#ifdef _WIN32
        handle_ = LoadLibraryA(filename.c_str());
#else
        handle_ = dlopen(filename.c_str(), RTLD_LAZY);
#endif
        if (!handle_) {
            std::cerr << "Failed to load library: " << filename << std::endl;
#ifdef _WIN32
            std::cerr << "Error code: " << GetLastError() << std::endl;
#else
            std::cerr << "Error: " << dlerror() << std::endl;
#endif
        }
    }

    ~DynamicLibrary() {
        if (handle_) {
#ifdef _WIN32
            FreeLibrary(reinterpret_cast<HMODULE>(handle_));
#else
            dlclose(handle_);
#endif
            handle_ = nullptr;
        }
    }

    void* getSymbol(const std::string& symbol_name) {
        if (!handle_) {
            std::cerr << "Library not loaded." << std::endl;
            return nullptr;
        }
#ifdef _WIN32
        return GetProcAddress(reinterpret_cast<HMODULE>(handle_), symbol_name.c_str());
#else
        return dlsym(handle_, symbol_name.c_str());
#endif
    }

    bool isLoaded() const {
        return handle_ != nullptr;
    }

private:
#ifdef _WIN32
    HMODULE handle_;
#else
    void* handle_;
#endif
};

typedef int (*MyFuncType)(int); // 函数指针类型

int main() {
    DynamicLibrary my_lib("./libmylibrary.so"); // Linux
    //DynamicLibrary my_lib("./mylibrary.dll"); // Windows

    if (!my_lib.isLoaded()) {
        return 1;
    }

    MyFuncType my_func = (MyFuncType)my_lib.getSymbol("myFunction");
    if (!my_func) {
        std::cerr << "Failed to find function!" << std::endl;
        return 1;
    }

    int result = my_func(20);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

编译主程序：

g++ main.cpp -o main

运行主程序：

./main

如果一切顺利，你就能看到控制台输出了Hello from mylibrary!和Result: 40。

注意事项：雷区遍布，小心踩坑

内存管理： 动态库和主程序之间的内存管理要小心，避免出现内存泄漏或者重复释放的问题。一般来说，最好由同一个模块负责分配和释放内存。
ABI兼容性： 不同的编译器和平台可能使用不同的ABI（Application Binary Interface），导致动态库和主程序之间不兼容。尽量使用相同的编译器和平台来编译动态库和主程序。
异常处理： 动态库里的异常可能会传播到主程序里，导致程序崩溃。最好在动态库里捕获异常，避免传播到主程序。
线程安全： 如果动态库是多线程的，要注意线程安全问题，避免出现数据竞争或者死锁。

总结：动态库，用好了是神器，用不好是坑

动态库是个好东西，用好了可以提高程序的灵活性和可维护性。但是，动态库也有一些坑，需要小心避开。

希望今天的讲座能帮助大家更好地理解C++动态库的加载和卸载，并在跨平台开发中少走弯路。

最后，别忘了点赞、收藏、转发！

补充说明：

错误处理: 上述代码中, 错误处理只是简单地输出了错误信息. 在实际应用中, 应该根据具体的错误类型进行更详细的处理, 例如记录日志, 提示用户等.
库的查找路径: 上述例子中, 直接指定了库的路径. 实际应用中, 应该考虑库的查找路径问题, 比如使用环境变量, 配置文件等.
更高级的封装: 可以使用一些库, 如Boost.DLL, 来进行更高级的封装, 简化动态库的加载和使用.
C++标准: C++11之后，提供了std::function来简化函数指针的使用。
显式链接 vs 隐式链接 上面的例子都是显式链接，需要在运行时加载动态库。隐式链接是在编译时就链接到动态库，程序启动时自动加载。隐式链接配置起来比较麻烦，跨平台性也更差，所以显式链接使用更广泛。

希望这个更全面的解释对您有所帮助！

发表回复 取消回复

发表回复取消回复