如何编写灵活的模块化程序，模块之间具有良好的交互可能性？

Question

我在这里浏览了类似主题的答案，但找不到令人满意的答案。因为我知道这是一个相当大的主题，所以我会尝试更具体。

我想编写一个处理文件的程序。处理过程并不简单，因此最好的方法是将不同的阶段分成独立的模块，然后根据需要使用这些模块（因为有时我只对模块 A 的输出感兴趣，有时我需要其他五个模块的输出等） ）。问题是，我需要模块进行合作，因为一个模块的输出可能是另一个模块的输入。我需要它很快。此外，我想避免多次执行某些处理（如果模块 A 创建了一些数据，然后需要由模块 B 和 C 处理，我不想运行模块 A 两次来为模块 B,C 创建输入） 。

模块需要共享的信息主要是二进制数据块和/或已处理文件的偏移量。主程序的任务非常简单 - 只需解析参数，运行所需的模块（也许会给出一些输出，或者这应该是模块的任务？）。

我不需要在运行时加载模块。拥有带有 .h 文件的库并在每次有新模块或更新某些模块时重新编译程序是完全可以的。模块的想法在这里主要是因为代码的可读性、可维护性以及能够让更多的人在不同的模块上工作，而不需要一些预定义的接口或其他什么（另一方面，一些关于如何编写模块的“指南”）可能需要模块，我知道）。我们可以假设文件处理是只读操作，原始文件没有改变。

有人能给我指出如何在 C++ 中做到这一点的好方向吗？欢迎任何建议（链接、教程、pdf 书籍...）。

Answer 1

这看起来与插件架构非常相似。我建议从（非正式）数据流程图开始，以确定：

• 这些块如何处理数据
• 需要传输哪些数据
• 从一个块返回到另一个块的结果（数据/错误代码/异常）

有了这些信息，您可以开始构建通用接口，允许在运行时绑定到其他接口。然后我会向每个模块添加一个工厂函数，以从中请求真正的处理对象。我不建议直接从模块接口获取处理对象，而是返回一个工厂对象，可以在其中检索处理对象。然后，这些处理对象用于构建整个处理链。

一个过于简化的大纲看起来像这样：

struct Processor
{
    void doSomething(Data);
};

struct Module
{
    string name();
    Processor* getProcessor(WhichDoIWant);
    deleteprocessor(Processor*);
};

在我看来，这些模式可能会出现：

• 工厂函数：从模块中获取对象
• 复合 &&装饰器：形成处理链

Answer 2

我想知道 C++ 是否是为此目的考虑的正确级别。根据我的经验，在 UNIX 哲学中，将单独的程序通过管道连接在一起始终被证明是有用的。

如果你的数据不是太大，拆分有很多优点。您首先获得独立测试处理的每个阶段的能力，运行一个程序并将输出重定向到文件：您可以轻松检查结果。然后，即使每个程序都是单线程的，您也可以利用多核系统，从而更容易创建和调试。您还可以利用程序之间的管道来实现操作系统同步。也许您的某些程序也可以使用现有的实用程序来完成？

您的最终程序将创建粘合剂，将所有实用程序收集到一个程序中，将数据从一个程序传输到另一个程序（此时不再有文件），并根据所有计算的需要复制它。

Answer 3

这看起来确实很微不足道，所以我想我们错过了一些要求。

使用 Memoization 避免多次计算结果。这应该在框架中完成。

您可以使用一些流程图来确定如何使信息从一个模块传递到另一个模块......但最简单的方法是让每个模块直接调用它们所依赖的模块。通过记忆，它不会花费太多，因为如果它已经被计算过，那就没问题了。

由于您需要能够启动任何模块，因此您需要为它们提供 ID 并在某个地方注册它们，以便在运行时查找它们。有两种方法可以做到这一点。

• Exemplar：您获得此类模块的唯一示例并执行它。
• 工厂：您创建所需类型的模块，执行它并丢弃它。

Exemplar 方法的缺点是，如果您执行该模块两次，您将不会从干净的状态开始，而是从最后一次（可能失败）执行留下的状态开始。它可能被视为一个优势，但如果失败，则不会计算结果（呃），所以我建议不要这样做。

那么你如何...？

让我们从工厂开始吧。

class Module;
class Result;

class Organizer
{
public:
  void AddModule(std::string id, const Module& module);
  void RemoveModule(const std::string& id);

  const Result* GetResult(const std::string& id) const;

private:
  typedef std::map< std::string, std::shared_ptr<const Module> > ModulesType;
  typedef std::map< std::string, std::shared_ptr<const Result> > ResultsType;

  ModulesType mModules;
  mutable ResultsType mResults; // Memoization
};

这确实是一个非常基本的界面。但是，由于每次调用 Organizer 时我们都需要一个新的模块实例（以避免重入问题），因此我们需要在 Module 接口上进行操作。

class Module
{
public:
  typedef std::auto_ptr<const Result> ResultPointer;

  virtual ~Module() {}               // it's a base class
  virtual Module* Clone() const = 0; // traditional cloning concept

  virtual ResultPointer Execute(const Organizer& organizer) = 0;
}; // class Module

现在，这很简单：

// Organizer implementation
const Result* Organizer::GetResult(const std::string& id)
{
  ResultsType::const_iterator res = mResults.find(id);

  // Memoized ?
  if (res != mResults.end()) return *(it->second);

  // Need to compute it
  // Look module up
  ModulesType::const_iterator mod = mModules.find(id);
  if (mod != mModules.end()) return 0;

  // Create a throw away clone
  std::auto_ptr<Module> module(it->second->Clone());

  // Compute
  std::shared_ptr<const Result> result(module->Execute(*this).release());
  if (!result.get()) return 0;

  // Store result as part of the Memoization thingy
  mResults[id] = result;

  return result.get();
}

还有一个简单的模块/结果示例：

struct FooResult: Result { FooResult(int r): mResult(r) {} int mResult; };

struct FooModule: Module
{
  virtual FooModule* Clone() const { return new FooModule(*this); }

  virtual ResultPointer Execute(const Organizer& organizer)
  {
    // check that the file has the correct format
    if(!organizer.GetResult("CheckModule")) return ResultPointer();

    return ResultPointer(new FooResult(42));
  }
};

并且来自 main：

#include "project/organizer.h"
#include "project/foo.h"
#include "project/bar.h"


int main(int argc, char* argv[])
{
  Organizer org;

  org.AddModule("FooModule", FooModule());
  org.AddModule("BarModule", BarModule());

  for (int i = 1; i < argc; ++i)
  {
    const Result* result = org.GetResult(argv[i]);
    if (result) result->print();
    else std::cout << "Error while playing: " << argv[i] << "\n";
  }
  return 0;
}