C++/CMake : Making a plugin system for many 'source plugins'

Question

我正在开发一个由许多插件组成的 C++ 库，这些插件可以相互独立地包含在内。插件集仅取决于用户在编译时的要求。 这些插件只是源代码，它们不是独立的二进制文件。 为此，主要的(也是唯一的)库的 CMakeLists.txt 有一个预定义的插件列表，并且在 plugins 目录中找到的每个插件都被添加到二进制目标. 此外，还设置了一个带有插件名称的预处理器 #define:

set (plugins
    plugin1
    plugin2
    plugin3
     ...)

#optional plugins 
foreach(library ${plugins})
    file(TO_CMAKE_PATH "plugins/${library}" librarypath)
    get_filename_component(librarypath ${librarypath} ABSOLUTE) 
    if(EXISTS ${librarypath})
        message("--> found ${library}")
        include_directories(${librarypath}/include)
        file(GLOB libsources "${librarypath}/src/*.cpp" "${librarypath}/src/*.f90")
        set(sources ${sources} ${libsources})
        string(TOUPPER ${library} LIBRARY)
        add_definitions(-D${LIBRARY})
    endif()
endforeach(library)

现在在我的主库中，我基本上做的是:

#ifdef PLUGIN1
#    include "plugin1.h"
#endif
#ifdef PLUGIN2
#    include "plugin2.h"
#endif
#ifdef PLUGIN3
#    include "plugin3.h"
#endif

...

// each plugin has a unique id:
enum PluginID : int {
    Plugin1                          = 1,
    Plugin2                          = 2,
    Plugin3                          = 3,
};

// the name of each plugin is associated with its ID, 

PluginID getPluginIDFromName( const std::string& PluginName )
{
    static std::map<std::string, PluginID> PluginIDMap = {
        {"PLUGIN1", Plugin1},
        {"PLUGIN2", Plugin2},
        {"PLUGIN3", Plugin3},
    };

    return PluginIDMap[PluginName];
}

// Load a plugin by its ID
PluginBaseClass* pluginFactory( PluginID  pluginID)
{
    switch ( pluginID ) {
        #ifdef PLUGIN1 
        case Plugin1: { return new class Plugin1();}
        #endif
       #ifdef PLUGIN2 
        case Plugin2: { return new class Plugin2();}
        #endif
       #ifdef PLUGIN3 
        case Plugin3: { return new class Plugin3();}
       #endif
}}

所以结果是在主源中我可以通过以下方式加载插件:

PluginBaseClass* thePlugin1 = pluginFactory ( getPluginIDFromName ("PLUGIN1") );

一切都按预期工作，但我觉得我所做的是某种滥用 cmake 和预处理器宏。有没有更好的方法来实现我的目标？ 此外，为每个可能的插件手动更新 map 和 switch 相当麻烦。 我的要求是用户不需要手动修改 CMakeLists.txt。提前致谢!

编辑:我想通过它们的 ID 或它们的名称使插件可用，因此有两个功能。另外，首选静态链接；我认为没有理由进行动态加载。

Answer 1

您可以使用所谓的“自注册”并让编译器为您完成大部分工作，而不是手动创建从 id 到插件名称和工厂函数的映射。

静态插件工厂

首先，我们需要一个工厂类，各个插件可以在其中进行 self 注册。声明可能看起来像这样:

class PluginFactory
{
public:
  using PluginCreationFunctionT = PluginBaseClass(*)();

  PluginFactory() = delete;

  static bool Register(std::string_view plugin name,
                       PluginID id,
                       PluginCreationFunctionT creation_function);

  static PluginBaseClass* Create(std::string_view name);
  static PluginBaseClass* Create(PluginID id);

private:
  static std::map<std::string_view, PluginCreationFunctionT> s_CreationFunctionByName;
  static std::map<PluginID, PluginCreationFunctionT> s_CreationFunctionById;
};

对应的源文件则包含

std::map<std::string_view, PluginFactory::PluginCreationFunctionT>
PluginFactory::s_CreationFunctionByName;

std::map<PluginID, PluginFactory::PluginCreationFunctionT>
PluginFactory::s_CreationFunctionById;

bool PluginFactory::Register(std::string_view const plugin name,
                             PluginId const id,
                             PluginCreationFunctionT const creation_function)
{
  // assert that no two plugins accidentally try to register
  // with the same name or id
  assert(s_CreationFunctionByName.find(name) == s_CreationFunctionByName.end());
  assert(s_CreationFunctionById.find(id) == s_CreationFunctionById.end());

  s_CreateFunctionByName.insert(name, creation_function);
  s_CreateFunctionById.insert(id, creation_function);

  return true;
}

PluginBaseClass* PluginFactory::Create(std::string_view const name)
{
  auto const it = s_CreationFunctionByName.find(name);
  return it != s_CreationFunctionByName.end() ? it->second() : nullptr;
}

PluginBaseClass* PluginFactory::Create(std::string_view const id)
{
  auto const it = s_CreationFunctionById.find(name);
  return it != s_CreationFunctionById.end() ? it->second() : nullptr;
}

请注意，Register 始终返回 true - 我们需要它返回一个值，以便将 Register 函数用作初始值设定项对于一个全局变量。作为全局变量的初始值设定项会导致编译器在程序启动期间发出代码以调用 Register 函数。

在您的主要功能中，您现在可以通过

获取特定插件的实例

PluginBaseClass* thePlugin1 = PluginFactory::Create("PLUGIN1");

或通过

PluginBaseClass* thePlugin1 = PluginFactory::Create(PluginID::Plugin1);

修改插件

现在需要修改插件本身，以便它们自行注册。理论上任何全局变量都可以，但是为了避免不同插件之间的名称冲突，最简单的方法是向每个插件类添加一个静态数据成员，例如

class Plugin1 : public PluginBaseClass {
public:
  ...

private:
  static bool s_IsRegistered;
};

然后将以下内容添加到插件的源文件中:

namespace {
  PluginBaseClass* create_plugin1()
  {
    return new Plugin1{};
  }
}

bool Plugin1::s_IsRegistered 
  = PluginFactory::Register("PLUGIN1", PluginID::Plugin1, create_plugin1);

简化CMake代码

既然编译器生成了映射，您就不再需要预处理器定义了。您的 CMake 代码现在需要做的就是添加正确的包含目录和源代码。但这不需要成为主 CMake 文件的一部分。相反，您可以将 CMakeLists.txt 放入每个插件文件夹，然后通过 add_subdirectory 或 include 将它们包含到主 CMakefile 中:

foreach(library ${plugins})
    if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/plugins/${library}/CMakeLists.txt)
      message(STATUS "--> found ${library}"
      include(${CMAKE_CURRENT_LIST_DIR}/plugins/${library}/CMakeLists.txt)
    else()
      message(FATAL "Unknown plugin ${library} requested!")
    endif()
endforeach()

plugins/plugin1 文件夹中 plugin1 的 CMakeLists.txt 只包含

include_directories(${CMAKE_CURRENT_LIST_DIR}/include)
file(GLOB sources_plugin1 "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp" "${CMAKE_CURRENT_LIST_DIR}/src/*.f90")
list(APPEND sources ${sources_plugin1})

在这种特殊情况下看起来可能没有太大改进，但现在拥有这些单独的 CMakeLists.txt 文件也允许有条件地添加依赖项。

例如，假设 Plugin2 是唯一使用 boost 的插件。使用单独的 CMakeLists.txt，您可以将查找和使用 boost 所需的所有内容添加到 Plugin2 的 CMakeLists.txt 而不会污染主 CMakeLists.txt 文件。