C++高手进阶：Windows 模块加载的艺术与策略

前文我们讲到了怎么不依赖第三库，搭建自己的测试框架
没有看的读者可以通过这个链接自行阅读：
👉👉👉 自力更生：0依赖三方库，手把手教你打造专属C++测试框架
作为项目开发来说，我们通常会将不同的功能、数据进行分层或分块，这其实就涉及到不同模块之间的相互调用。选择什么样的策略来实现模块间能力的交互，其实是非常重要的。
本文中，我们就来抽象业务逻辑，看下模块间的加载是如何实现的。

模块间的加载方式

通常而言，模块间的加载方式可以分为两类：

• 动态加载
• 静态加载

什么是动态加载呢？简单而言就是模块间遵循动态加载协议，平台层模块或业务层模块主动的调用 LoadLibrary() 和 GetProcAddress接口来加载其他模块。

什么是静态加载呢？简单而言就是模块间遵循静态加载协议，平台层模块或业务层模块在编译时就将其他模块的依赖关系链接进来（通常建议在编写平台层 CMakeLists.txt 时，将依赖的库或模块列入链接库的列表，并设置链接类型为静态库）。

笔者在撰写此文时特地查了相关资料，对它们的特点做下介绍（PS: 文中有些地方可能有误，如有疑问，欢迎指正）：

动态加载（Dynamic Loading）

动态加载指的是在程序运行时，根据需要加载和卸载库或模块。这种方式有以下几个特点：

1. 运行时链接：库的代码在程序运行时才被加载，通常是通过动态链接库（Dynamic Link Library，DLL）在Windows上或共享库（Shared Object，SO）在Unix-like系统上实现。
2. 灵活性：可以在不重启程序的情况下加载或卸载模块，提供更高的灵活性。
3. 内存使用：只需要加载正在使用的库，节省内存。
4. 更新和维护：可以独立更新库而不需要重新编译整个程序。
5. 依赖管理：需要更复杂的依赖管理，因为库在运行时才被加载。

静态加载（Static Loading）

静态加载指的是在程序编译时，库或模块已经被链接到程序中。这种方式有以下几个特点：

1. 编译时链接：库的代码在编译期间被链接到最终的可执行文件中。
2. 加载时间：因为库的代码已经是程序的一部分，所以不需要在程序运行时加载。
3. 内存使用：静态加载的库会占用更多的内存，因为所有库的代码都会被包含在最终的可执行文件中。
4. 更新和维护：更新静态加载的库可能需要重新编译整个程序。
5. 依赖管理：静态加载简化了依赖管理，因为所有依赖都包含在程序中。

什么时候用什么方式

也许读者在其他地方看到过它的使用建议，比如说根据加载的时间、内存的使用、模块间交互的频繁性，模块间的依赖关系复杂度、模块的更新频率等方面进行选择。

笔者就不在从这些维度进行阐述了。

笔者从工程实践的角度出发，讲讲两种使用的场景：

1. 当主模块没有代码逻辑依赖该模块暴露的API接口时，该模块的能力仅仅是主模块能力的增强，就可以采用动态加载方式。
2. 当主模块有代码逻辑依赖该模块暴露的API接口时，该模块的能力是主模块的核心功能，就可以采用静态加载方式。

怎么用

动态加载示例介绍

场景： 假设有主模块A，在其上开发了模块B，以进行能力增强。

那么对于模块 A 来说，得做如下事情：

1. 定义模块间交互的协议类 TestModuleBase，用于模块 B 来派生，自定义自己的加载、卸载业务逻辑。

// xx.h
class TestModuleBase
{
public:
    TestModuleBase();
    virtual ~TestModuleBase();

    virtual SystemStatus initialize();
    virtual SystemStatus uninitialize();

private:
    TestModuleBase(const TestModuleBase&) = delete;
    TestModuleBase& operator=(const TestModuleBase&) = delete;
};

typedef TestModuleBase* (__cdecl* RxProlModule)();


// xx.cpp
TestModuleBase::TestModuleBase()
{

}

TestModuleBase::~TestModuleBase()
{

}

SystemStatus TestModuleBase::initialize()
{
    return SystemStatus::e_Ok;
}

SystemStatus TestModuleBase::uninitialize()
{
    return SystemStatus::e_Ok;
}

2. 定义一个模块加载器 TestModuleLoader 类，用来管理模块的加载和卸载。

// xx.h
class DEMO_TEST_STATIC_EXPORT TestModuleLoader
{
public:
    TestModuleLoader() = delete;

    static SystemStatus loadModule(const wchar_t* pPath);

    static SystemStatus unloadModule(const wchar_t* pPath);

private:
    TestModuleLoader(const TestModuleLoader&) = delete;
    TestModuleLoader& operator=(const TestModuleLoader&) = delete;
};


// xx.cpp
SystemStatus TestModuleLoader::loadModule(const wchar_t* pPath)
{
    HMODULE pHandleModule = LoadLibrary(pPath);
    if (!pHandleModule == NULL) {
        return SystemStatus::e_Fail;
    }

    RxProlModule rxProlModule = (RxProlModule)(GetProcAddress(pHandleModule, "rxProtocalModule"));
    if (rxProlModule == NULL) {
        FreeLibrary(pHandleModule);
        return SystemStatus::e_Fail;
    }

    TestModuleBase* pModule = rxProlModule();
    if (pModule == NULL) {
        FreeLibrary(pHandleModule);
        return SystemStatus::e_Fail;
    }

    return pModule->initialize();
}

SystemStatus TestModuleLoader::unloadModule(const wchar_t* pPath)
{
    if (pPath == NULL) {
        return SystemStatus::e_Fail;
    }

    HMODULE pHandleModule = GetModuleHandle(pPath);
    if (pHandleModule == NULL) {
        return SystemStatus::e_Fail;
    }

    RxProlModule rxProlModule = (RxProlModule)(GetProcAddress(pHandleModule, "rxProtocalModule"));
    if (rxProlModule == NULL) {
        FreeLibrary(pHandleModule);
        return SystemStatus::e_Fail;
    }

    TestModuleBase* pModule = rxProlModule();
    if (pModule == NULL) {
        FreeLibrary(pHandleModule);
        return SystemStatus::e_Fail;
    }

    SystemStatus uninitResult = pModule->uninitialize();
    if (uninitResult != SystemStatus::e_Ok) {
        return uninitResult;
    }

    FreeLibrary(pHandleModule);

    return SystemStatus::e_Ok;
}

3. 在适当的时机，比如说模块A初始化和反初始化的时候，对模块B进行主动的加载和卸载。

SystemStatus PlatformModule::initialize()
{
    ...
    auto ss = TestModuleLoader::loadModule("DemoModule1.dll")
    if (ss != SystenStatus::e_Ok) {
        return ss;
    }
    ...
}

SystemStatus PlatformModule::uninitialize()
{
    ...
    auto ss = TestModuleLoader::unloadModule("DemoModule1.dll")
    if (ss != SystenStatus::e_Ok) {
        return ss;
    }
    ...
}

那么对于模块 B 来说，得做如下事情：

1. 派生协议类 TestModuleBase，实现自己的加载、卸载业务逻辑。

// xx.h
class DemoTestModule :public TestModuleBase
{
public:
    DemoTestModule();
    ~DemoTestModule();

    SystemStatus initialize() override;
    SystemStatus uninitialize() override;

private:
    DemoTestModule(const DemoTestModule&) = delete;
    DemoTestModule& operator=(const DemoTestModule&) = delete;

    bool m_initialized = false;
};

DEMO_TEST_C_EXPORT TestModuleBase* rxProtocalModule();


// xx.cpp
DEMO_TEST_C_EXPORT TestModuleBase* rxProtocalModule()
{
    static DemoTestModule module;
    return &module;
}

DemoTestModule::DemoTestModule()
{

}

DemoTestModule::~DemoTestModule()
{

}

SystemStatus DemoTestModule::initialize()
{
    if (m_initialized) {
        return SystemStatus::e_NotSpecified;
    }

    m_initialized = true;

    // do something for init

    return SystemStatus::e_Ok;
}

SystemStatus DemoTestModule::uninitialize()
{
    if (m_initialized) {
        // do uninit thing

        m_initialized = false;
    }

    return SystemStatus::e_Ok;
}

静态加载示例介绍

场景： 假设有主模块A，在其上开发了模块B，以实现核心功能。

1. 对于模块B 来说，需定义一个模块初始化的类，实现该模块中对象的初始化和反初始化。同时给该类设置一个静态对象。

class DemoModuleInit
{
public:
    DemoModuleInit()
    {
        // do init thing
    }

    ~DemoModuleInit()
    {
        // do uninit thing
    }
};

static DemoModuleInit g_demoModuleInit;

2. 在模块 A 的CMakeLists.txt中，将模块B的静态库或模块链接进来。

link_directories("${PROJECT_SOURCE_DIR}/lib")
...
link_libraries(DemoModule1)

总结

以上就是模块间加载的两种方式，动态加载和静态加载，以及它们的使用场景和示例。希望能对读者有所帮助。

如果读者有不理解的地方，欢迎私信交流。