8

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

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

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

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

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

4

3 回答 3

3

这看起来非常类似于插件架构。我建议从（非正式的）数据流程图开始，以识别：

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

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

过度简化的大纲如下所示：

struct Processor
{
    void doSomething(Data);
};

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

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

  • 工厂函数：从模块中获取对象
  • 复合&&装饰器：形成加工链
于 2010-05-28T07:51:31.260 回答
2

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

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

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

于 2010-05-28T07:39:25.287 回答
2

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

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

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

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

  • Exemplar：获取此类模块的唯一示例并执行。
  • 工厂：您创建一个请求类型的模块，执行它并将其丢弃。

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

那你怎么……？

让我们从工厂开始。

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));
  }
};

从主要：

#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;
}
于 2010-05-28T09:42:03.357 回答