背景：
实际项目中，我们往往将一个系统分解成一个个功能模块，这些功能模块以动态库加载的方式由主程序加载使用。
- 需求1： 主程序定义好功能类的接口，每个功能模块继承这些功能类（基类），然后实现其中的接口函数。
- 需求2：主程序以动态库的方式加载这些功能模块，实例化功能模块对象，调用对应的接口函数。
- 需求3：主程序以模块名称的方式加载各功能模块，能够从名称创建一个功能模块对象。
方案：
image.png
- 主程序需要定义功能基类。
- 需要在主程序中定义一个全局的模块注册表，每个模块在动态加载时自动的将模块注册到该表中。
- 需要提供一种方便快捷的模块注册机制。
实现示例代码：
总体的代码结构如下：
.
├── main
├── main.cpp
├── ModuleA
│ ├── build.sh
│ ├── libma.so
│ ├── ModuleA.cpp
│ └── ModuleA.h
├── ModuleB
│ ├── build.sh
│ ├── libmb.so
│ ├── ModuleB.cpp
│ └── ModuleB.h
├── Module.cpp
└── Module.h
- 模块基类定义+注册宏（Module.h）
#pragma once
#include <map>
#include <functional>
#include <memory>
class Module {
public:
Module() {}
virtual ~Module() {}
virtual void Process() = 0;
};
#define REGISTER_MODULE(MODULE_NAME) \
extern std::map<std::string, std::function<Module*()>> allModules_; \
static int fuse_ = ([]()->int { \
allModules_[#MODULE_NAME] = []()->Module* { \
return new MODULE_NAME(); \
}; \
return 0;\
})()
extern std::shared_ptr<Module> GetModule(const std::string& moduleName);
说明：
（1）定义了一个模块接口类，并定义了纯虚函数，每个功能模块需要实现这个纯虚函数。
（2）提供了一个模块注册宏，每个模块可以引用该宏进行注册。
（3）在注册宏中引用了一个全局map表，这个表即是模块注册表，它的key是模块名称，value是一个创建功能模块实例的函数对象（std::function）。
（4）定义了一个static int变量（fuse_），这个变量唯一的目的是在加载动态库时触发注册的过程，在这里将注册的过程实现为一个Lambda函数，在此Lambda函数往全局map表中注册一个KV对。
（5）全局map需要在主程序的代码中定义，此时，核心问题是如何将主程序中定义的全局变量在动态模块中得以使用，这里使用了gcc编译器的"-Wl, --export-dynamic"链接选项，后面会提到。
（6）提供一个从动态模块名称获取动态模块实例的接口函数。
- 全局表的定义以及接口函数实现（Module.cpp）:
#include "Module.h"
std::map<std::string, std::function<Module*()>> allModules_;
std::shared_ptr<Module> GetModule(const std::string& moduleName)
{
if (allModules_.find(moduleName) == allModules_.end()) {
return nullptr;
}
return std::shared_ptr<Module>(allModules_[moduleName]());
}
可以看到全局map是在这里给出定义的。
- 模块A的实现：
- ModuleA.h
#pragma once
#include "../Module.h"
class ModuleA : public Module {
public:
virtual void Process() override;
};
- ModuleA.cpp
#include <iostream>
#include "ModuleA.h"
void ModuleA::Process()
{
std::cout << ">>Entering ModuleA::Process" << std::endl;
}
REGISTER_MODULE(ModuleA);
可以看到在实现文件的最后调用了注册宏完成注册。
- 模块B的实现：
- ModuleB.h
#pragma once
#include "../Module.h"
class ModuleB : public Module {
public:
virtual void Process() override;
};
- ModuleB.cpp
#include <iostream>
#include "ModuleB.h"
void ModuleB::Process()
{
std::cout << ">>Entering ModuleB::Process" << std::endl;
}
REGISTER_MODULE(ModuleB);
- 分别编译模块A和模块B，使其变成两个动态库：
# g++ -std=c++11 -fPIC -shared -o libma.so ModuleA.cpp
# g++ -std=c++11 -fPIC -shared -o libmb.so ModuleB.cpp
- 主程序代码：
#include <dlfcn.h>
#include "Module.h"
int main()
{
void* ha = dlopen("./ModuleA/libma.so", RTLD_LAZY);
void* hb = dlopen("./ModuleB/libmb.so", RTLD_LAZY);
std::shared_ptr<Module> ma = GetModule("ModuleA");
std::shared_ptr<Module> mb = GetModule("ModuleB");
ma->Process();
mb->Process();
return 0;
}
- 测试运行
链接时需要加上“-Wl, --export-dynamic”选项，这是关键：
g++ -std=c++11 -O2 -Wl,--export-dynamic -o main main.cpp Module.cpp -ldl
运行程序：
# ./main
>>Entering ModuleA::Process
>>Entering ModuleB::Process
