Question

我正在编写一个可以启动新流程的应用程序。我已经确定了这些过程＆＃39;从根本上说会有两种不同的方式，它们可以独立运行，也可以依赖现有流程来运行。因此，我创建了两个抽象类，继承自基本抽象类。

我正在尝试研究如何编写工厂或其他设计模式，这将返回我需要的类，具体取决于我给出的文件扩展字符串，这将在运行时发生。然而，我并不认为工厂模式是一个良好的，合理的契合，因为这些基本差异会导致不同的构造者。我可以自己编写一个巨大的开关或嵌套if语句，但是对于这个项目我真的想提高我的c ++知识（这是我第一次真正使用继承）。

说我有我的抽象基类：

localStorage.setItem('someData', '<?= $someJsonData; ?>');

然后还有两个继承自此的抽象类，首先是一个独立的类，它启动/停止并写入自己的进程：

class launchable {
protected:
    std::string              name;
    std::string              directory;
    std::string              path;
    std::string              fileType;
    std::vector<std::string> launchArgs;
    bool                     hasLaunched;
    launchable(std::string _name, std::string _directory,std::string _fileType,std::vector<std::string> _args);
public:
    virtual void             start() = 0;
    virtual void             stop()  = 0;
    virtual void             writeMessage(std::string theMessage) = 0;
    virtual boost::optional<std::string> readMessage()            = 0;
};

和必须通过独立进程启动/停止/读/写的依赖类：

class standalone : public launchable{
protected:
    processManager *manager;
    std::shared_ptr<processManager::launchableProcess> process;
    virtual std::string formatWriteMessage(std::string theMessage) = 0;
    standalone(std::string _name, std::string _directory,std::string _fileType,std::vector<std::string> _args,processManager *_manager);
public:
    virtual void start() = 0;
    virtual void stop()  = 0;
    void writeMessage(std::string theMessage);
    boost::optional<std::string> readMessage();
};

在命令行上运行的示例具体独立* nix可执行文件：

class dependent : public launchable{
protected:
    standalone *dependency;
    dependent(std::string _name, std::string _directory,std::string _type,std::vector<std::string> _args,standalone *_dependency);
public:
    virtual void start() = 0;
    virtual void stop()  = 0;
    void writeMessage(std::string theMessage);
    boost::optional<std::string> readMessage();
};

示例具体可靠，必须通过* nix命令行解释器运行的supercollider补丁：

class executable  : public standalone {
private:
    std::string formatWriteMessage(std::string theMessage);
public:
    using standalone::standalone;
    void start();
    void stop();
};

理想情况下，我想要的是（伪代码）：

class supercolliderPatch : public dependent {
public:
    using dependent::dependent;
    void start();
    void stop();
};

这些可启动的*实例将存储在std :: vector中。

基本上我的问题是：我是在傻瓜差事试图把这两个独立/依赖的概念混为一体，还是工厂模式可以为我工作？

Answer 1

抽象工厂让你做到这一点：构建一些具体的实例并将其作为它的抽象接口对待。如果您无法找到适用于这两个课程的通用界面，那么您可能需要重新考虑您的设计，因为在您的情况下，这似乎不是一个问题。

Answer 2

你可以试试这个，一些函数式编程，但它可能会产生一些最小的性能负面影响。它还需要C ++ 11或更高版本

std::function<shared_ptr<Base>()> funcs[] = { [](){ return shared_ptr<Base>(new A()); }, [](){ return shared_ptr<Base>(new B()); } };

然后致电：

funcs[i]();

为了安全起见，您可以使用类似array的内容。

std::array<std::function<shared_ptr<Base>()>, 2> funcs[] =
    { [](){ return shared_ptr<Base>(new A()); }, [](){ return shared_ptr<Base>(new B()); } };

(funcs->at(i)();

这个＆＃34;函数数组＆＃34;类似于抽象工厂，它返回基类的共享指针。

工厂的设计模式替代方案：具有不同构造函数的类

2 个答案: