C++ 插件系统设计：基于动态库的模块化扩展

好的，各位观众老爷，欢迎来到今天的C++插件系统设计讲座！今天咱们要聊的是如何用动态库搞出一个模块化的C++程序，让你的代码像乐高积木一样，想拼啥就拼啥，灵活得像个自由的胖子！

开场白：为什么要搞插件系统？

想象一下，你开发了一个超级牛逼的图像处理软件。一开始，它只有几个基本功能，比如缩放、旋转。但是用户总是贪得无厌的，他们想要各种奇奇怪怪的滤镜，想要支持各种稀奇古怪的图片格式。如果你每次都修改核心代码，那简直就是一场灾难！代码会越来越臃肿，维护起来比登天还难。

这时候，插件系统就闪亮登场了！它可以让你把这些额外的功能做成一个个独立的模块（也就是动态库），需要的时候加载进来，不需要的时候就卸载掉。核心代码保持干净整洁，扩展性就像开了挂一样！

第一部分：动态库的基础知识

要搞插件系统，首先得搞懂动态库是怎么回事。简单来说，动态库就是一段编译好的代码，可以被多个程序共享使用。它的后缀名在Windows上是.dll，在Linux上是.so，在macOS上是.dylib。

1. 编译动态库

咱们先来写一个简单的动态库，里面只有一个函数，用来打印一句问候语。

// myplugin.h
#ifndef MYPLUGIN_H
#define MYPLUGIN_H

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

extern "C" {
  PLUGIN_API void greet(const char* name);
}

#endif

// myplugin.cpp
#include <iostream>
#include "myplugin.h"

void greet(const char* name) {
  std::cout << "Hello, " << name << "! This is from my plugin." << std::endl;
}

编译命令（以g++为例）：

• Windows: g++ -shared -o myplugin.dll myplugin.cpp
• Linux: g++ -fPIC -shared -o myplugin.so myplugin.cpp
• macOS: g++ -dynamiclib -o myplugin.dylib myplugin.cpp

解释一下：

• -shared 或 -fPIC -shared 或 -dynamiclib：告诉编译器我们要编译的是一个动态库。
• -o myplugin.dll/so/dylib：指定输出的文件名。
• PLUGIN_API：这是一个宏，用来在Windows上导出函数（__declspec(dllexport)）。在Linux和macOS上，不需要显式导出，所以它为空。
• extern "C"：这个非常重要！它告诉编译器，使用C语言的调用约定。因为C++的name mangling机制会导致函数名变得乱七八糟，动态库加载的时候就找不到函数了。

2. 加载动态库

有了动态库，接下来就要把它加载到我们的主程序里。

// main.cpp
#include <iostream>
#include <dlfcn.h> // Linux
//#include <Windows.h> // Windows

typedef void (*GreetFunc)(const char*);

int main() {
  void* handle;
  GreetFunc greetFunc;

  #ifdef _WIN32
    handle = LoadLibrary("myplugin.dll");
    if (!handle) {
      std::cerr << "Failed to load plugin: " << GetLastError() << std::endl;
      return 1;
    }
    greetFunc = (GreetFunc)GetProcAddress((HMODULE)handle, "greet");
  #else
    handle = dlopen("./myplugin.so", RTLD_LAZY); // or "./myplugin.dylib" on macOS
    if (!handle) {
      std::cerr << "Failed to load plugin: " << dlerror() << std::endl;
      return 1;
    }
    greetFunc = (GreetFunc)dlsym(handle, "greet");
  #endif

  if (!greetFunc) {
    std::cerr << "Failed to find function 'greet'" << std::endl;
    #ifdef _WIN32
      FreeLibrary((HMODULE)handle);
    #else
      dlclose(handle);
    #endif
    return 1;
  }

  greetFunc("World");

  #ifdef _WIN32
    FreeLibrary((HMODULE)handle);
  #else
    dlclose(handle);
  #endif

  return 0;
}

编译命令：

• Windows: g++ main.cpp -o main
• Linux: g++ main.cpp -o main -ldl
• macOS: g++ main.cpp -o main -ldl

解释一下：

• dlfcn.h (Linux) 和 Windows.h (Windows)：包含了加载和卸载动态库的函数。
• dlopen (Linux) 和 LoadLibrary (Windows)：加载动态库。
• dlsym (Linux) 和 GetProcAddress (Windows)：获取动态库中的函数地址。
• dlclose (Linux) 和 FreeLibrary (Windows)：卸载动态库。
• RTLD_LAZY (Linux)：延迟加载，只有在用到函数的时候才加载。
• 类型转换 (GreetFunc)：把函数地址转换成我们定义的函数指针类型。

运行一下，如果一切顺利，你就能看到控制台输出了 "Hello, World! This is from my plugin."

第二部分：插件接口的设计

光能加载动态库还不够，我们还需要定义一套统一的接口，让所有的插件都遵循这个接口。这样，主程序才能知道如何使用插件提供的功能。

1. 定义抽象基类

我们定义一个抽象基类 IPlugin，所有的插件都必须继承这个类。

// iplugin.h
#ifndef IPLUGIN_H
#define IPLUGIN_H

#include <string>

class IPlugin {
public:
  virtual ~IPlugin() {}
  virtual std::string getName() const = 0;
  virtual void execute() = 0;
};

#endif

解释一下：

• IPlugin：抽象基类，定义了插件的基本接口。
• ~IPlugin()：虚析构函数。如果插件使用了动态分配的内存，我们需要确保在卸载插件的时候能够正确释放内存。
• getName()：返回插件的名字。
• execute()：执行插件的功能。

2. 插件的实现

现在，我们来实现一个具体的插件。

// myplugin.h
#ifndef MYPLUGIN_H
#define MYPLUGIN_H

#include "iplugin.h"
#include <string>

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

class MyPlugin : public IPlugin {
public:
  MyPlugin(const std::string& name);
  virtual ~MyPlugin() {}
  virtual std::string getName() const override;
  virtual void execute() override;

private:
  std::string m_name;
};

extern "C" {
  PLUGIN_API IPlugin* createPlugin(const std::string& name);
  PLUGIN_API void destroyPlugin(IPlugin* plugin);
}

#endif

// myplugin.cpp
#include "myplugin.h"
#include <iostream>

MyPlugin::MyPlugin(const std::string& name) : m_name(name) {}

std::string MyPlugin::getName() const {
  return m_name;
}

void MyPlugin::execute() {
  std::cout << "Executing plugin: " << m_name << std::endl;
}

extern "C" IPlugin* createPlugin(const std::string& name) {
  return new MyPlugin(name);
}

extern "C" void destroyPlugin(IPlugin* plugin) {
  delete plugin;
}

解释一下：

• MyPlugin：继承自 IPlugin，实现了 getName() 和 execute() 方法。
• createPlugin() 和 destroyPlugin()：这两个函数是关键！它们是用来创建和销毁插件对象的。主程序通过这两个函数来管理插件的生命周期。注意，这两个函数必须使用 extern "C" 修饰。

编译命令和前面一样。

3. 主程序的修改

现在，我们需要修改主程序，让它能够加载插件，并使用插件提供的功能。

// main.cpp
#include <iostream>
#include <dlfcn.h> // Linux
//#include <Windows.h> // Windows
#include "iplugin.h"

typedef IPlugin* (*CreatePluginFunc)(const std::string&);
typedef void (*DestroyPluginFunc)(IPlugin*);

int main() {
  void* handle;
  CreatePluginFunc createPluginFunc;
  DestroyPluginFunc destroyPluginFunc;
  IPlugin* plugin = nullptr;

  #ifdef _WIN32
    handle = LoadLibrary("myplugin.dll");
    if (!handle) {
      std::cerr << "Failed to load plugin: " << GetLastError() << std::endl;
      return 1;
    }
    createPluginFunc = (CreatePluginFunc)GetProcAddress((HMODULE)handle, "createPlugin");
    destroyPluginFunc = (DestroyPluginFunc)GetProcAddress((HMODULE)handle, "destroyPlugin");
  #else
    handle = dlopen("./myplugin.so", RTLD_LAZY); // or "./myplugin.dylib" on macOS
    if (!handle) {
      std::cerr << "Failed to load plugin: " << dlerror() << std::endl;
      return 1;
    }
    createPluginFunc = (CreatePluginFunc)dlsym(handle, "createPlugin");
    destroyPluginFunc = (DestroyPluginFunc)dlsym(handle, "destroyPlugin");
  #endif

  if (!createPluginFunc || !destroyPluginFunc) {
    std::cerr << "Failed to find function 'createPlugin' or 'destroyPlugin'" << std::endl;
    #ifdef _WIN32
      FreeLibrary((HMODULE)handle);
    #else
      dlclose(handle);
    #endif
    return 1;
  }

  plugin = createPluginFunc("My Awesome Plugin");
  std::cout << "Plugin name: " << plugin->getName() << std::endl;
  plugin->execute();
  destroyPluginFunc(plugin);

  #ifdef _WIN32
    FreeLibrary((HMODULE)handle);
  #else
    dlclose(handle);
  #endif

  return 0;
}

编译命令和前面一样。

运行一下，如果一切顺利，你就能看到控制台输出了插件的名字和执行结果。

第三部分：插件的管理与发现

现在，我们可以加载单个插件了。但是，如果有很多插件，我们该如何管理它们呢？如何自动发现插件呢？

1. 插件目录扫描

我们可以扫描一个指定的目录，找到所有的插件文件。

#include <iostream>
#include <vector>
#include <string>
#include <filesystem> // C++17
#include <dlfcn.h> // Linux
//#include <Windows.h> // Windows
#include "iplugin.h"

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

typedef IPlugin* (*CreatePluginFunc)(const std::string&);
typedef void (*DestroyPluginFunc)(IPlugin*);

std::vector<std::string> findPlugins(const std::string& pluginDir) {
  std::vector<std::string> pluginPaths;

  #ifdef _WIN32
  WIN32_FIND_DATA findData;
  HANDLE hFind = FindFirstFile((pluginDir + "\*.dll").c_str(), &findData);

  if (hFind != INVALID_HANDLE_VALUE) {
    do {
      pluginPaths.push_back(pluginDir + "\" + findData.cFileName);
    } while (FindNextFile(hFind, &findData) != 0);

    FindClose(hFind);
  }
  #else
  DIR* dir;
  struct dirent* ent;
  if ((dir = opendir(pluginDir.c_str())) != NULL) {
    while ((ent = readdir(dir)) != NULL) {
      std::string filename = ent->d_name;
      if (filename.rfind(".so") != std::string::npos || filename.rfind(".dylib") != std::string::npos) {
        pluginPaths.push_back(pluginDir + "/" + filename);
      }
    }
    closedir(dir);
  }
  #endif

  return pluginPaths;
}

int main() {
  std::string pluginDir = "./plugins"; // 插件目录
  std::vector<std::string> pluginPaths = findPlugins(pluginDir);

  for (const auto& pluginPath : pluginPaths) {
    void* handle;
    CreatePluginFunc createPluginFunc;
    DestroyPluginFunc destroyPluginFunc;
    IPlugin* plugin = nullptr;

    #ifdef _WIN32
      handle = LoadLibrary(pluginPath.c_str());
      if (!handle) {
        std::cerr << "Failed to load plugin: " << GetLastError() << std::endl;
        continue; // 加载失败，继续下一个插件
      }
      createPluginFunc = (CreatePluginFunc)GetProcAddress((HMODULE)handle, "createPlugin");
      destroyPluginFunc = (DestroyPluginFunc)GetProcAddress((HMODULE)handle, "destroyPlugin");
    #else
      handle = dlopen(pluginPath.c_str(), RTLD_LAZY);
      if (!handle) {
        std::cerr << "Failed to load plugin: " << dlerror() << std::endl;
        continue; // 加载失败，继续下一个插件
      }
      createPluginFunc = (CreatePluginFunc)dlsym(handle, "createPlugin");
      destroyPluginFunc = (DestroyPluginFunc)dlsym(handle, "destroyPlugin");
    #endif

    if (!createPluginFunc || !destroyPluginFunc) {
      std::cerr << "Failed to find function 'createPlugin' or 'destroyPlugin' in " << pluginPath << std::endl;
      #ifdef _WIN32
        FreeLibrary((HMODULE)handle);
      #else
        dlclose(handle);
      #endif
      continue; // 找不到函数，继续下一个插件
    }

    plugin = createPluginFunc("Plugin from " + pluginPath);
    std::cout << "Plugin name: " << plugin->getName() << std::endl;
    plugin->execute();
    destroyPluginFunc(plugin);

    #ifdef _WIN32
      FreeLibrary((HMODULE)handle);
    #else
      dlclose(handle);
    #endif
  }

  return 0;
}

解释一下：

• findPlugins()：扫描指定目录，找到所有的.dll, .so 或 .dylib文件。
• 主程序遍历所有的插件文件，加载它们，并调用 createPlugin() 和 destroyPlugin() 来管理插件的生命周期。
• std::filesystem 需要 C++17 支持。

2. 插件信息配置文件

除了直接扫描目录，我们还可以使用配置文件来描述插件的信息。比如，我们可以创建一个plugins.json文件，里面包含了插件的名字、描述、依赖关系等等。

[
  {
    "name": "My Awesome Plugin",
    "description": "This is a cool plugin.",
    "path": "myplugin.dll"
  },
  {
    "name": "Another Plugin",
    "description": "This is another plugin.",
    "path": "anotherplugin.dll"
  }
]

主程序可以读取这个配置文件，然后根据配置文件中的信息来加载插件。 这样，我们就可以更加灵活地管理插件。

第四部分：插件间的通信

有时候，插件之间需要互相通信，共享数据。这该怎么办呢？

1. 使用全局变量（不推荐）

最简单的方法就是使用全局变量。但是，这种方法非常不安全，容易导致冲突和错误。所以，不推荐使用。

2. 使用消息传递机制

我们可以定义一套消息传递机制，让插件之间通过发送和接收消息来进行通信。

// imessage.h
#ifndef IMESSAGE_H
#define IMESSAGE_H

#include <string>

class IMessage {
public:
  virtual ~IMessage() {}
  virtual std::string getType() const = 0;
  virtual void* getData() = 0;
};

#endif

// plugin_manager.h
#ifndef PLUGIN_MANAGER_H
#define PLUGIN_MANAGER_H

#include <vector>
#include <string>
#include "iplugin.h"
#include "imessage.h"

class PluginManager {
public:
  static PluginManager& getInstance();
  void registerPlugin(IPlugin* plugin);
  void unregisterPlugin(IPlugin* plugin);
  void sendMessage(IMessage* message);
  void addMessageHandler(const std::string& messageType, void (*handler)(IMessage*));

private:
  PluginManager() {}
  ~PluginManager() {}
  PluginManager(const PluginManager&) = delete;
  PluginManager& operator=(const PluginManager&) = delete;

  std::vector<IPlugin*> m_plugins;
  std::map<std::string, std::vector<void (*)(IMessage*)>> m_messageHandlers;
};

#endif

// plugin_manager.cpp
#include "plugin_manager.h"
#include <iostream>

PluginManager& PluginManager::getInstance() {
  static PluginManager instance;
  return instance;
}

void PluginManager::registerPlugin(IPlugin* plugin) {
  m_plugins.push_back(plugin);
}

void PluginManager::unregisterPlugin(IPlugin* plugin) {
  // TODO: Remove plugin from m_plugins
}

void PluginManager::sendMessage(IMessage* message) {
  std::string messageType = message->getType();
  if (m_messageHandlers.count(messageType) > 0) {
    for (auto handler : m_messageHandlers[messageType]) {
      handler(message);
    }
  }
}

void PluginManager::addMessageHandler(const std::string& messageType, void (*handler)(IMessage*)) {
  m_messageHandlers[messageType].push_back(handler);
}

解释一下：

• IMessage：消息的抽象基类。
• PluginManager：单例模式，负责管理所有的插件，并提供消息传递的功能。
• sendMessage()：发送消息。
• addMessageHandler()：注册消息处理函数。

插件可以注册自己感兴趣的消息类型，当收到消息的时候，就会调用相应的处理函数。

3. 使用共享内存

如果需要传输大量的数据，可以使用共享内存。共享内存允许多个进程（包括主程序和插件）访问同一块内存区域。

第五部分：总结与注意事项

好了，讲了这么多，咱们来总结一下C++插件系统设计的关键点：

• 动态库： 插件的基础，把功能模块化。
• 接口： 定义统一的接口，让主程序能够使用插件提供的功能。
• 管理： 插件目录扫描、配置文件，方便管理大量的插件。
• 通信： 消息传递、共享内存，实现插件间的通信。

注意事项：

• 版本兼容性： 插件和主程序需要使用相同的编译器和运行时库。否则，可能会出现各种奇怪的问题。
• 安全性： 插件的安全性非常重要。如果插件存在漏洞，可能会导致整个系统崩溃。
• 内存管理： 插件的内存管理需要特别小心。如果插件分配了内存，但是没有释放，可能会导致内存泄漏。

福利时间：

为了方便大家学习，我把今天讲的代码整理了一下，放到了GitHub上：[这里放你的GitHub链接]

大家可以去下载学习，如果觉得有用，别忘了点个Star哦！

好了，今天的讲座就到这里。谢谢大家的观看！下次再见！