工厂模式，实现动态工厂列表

Question

我正在实现一个抽象工厂模式（用c++），但是有一个小问题。

我想避免创建一个必须在编译时知道存在哪些工厂的地方。

通常在示例中我会看到类似的内容。

Factory * getFactory()
{
    if(/*we should make factoryA*/)
    {
        return FactoryA::instance();
    }
    else if(/*we should return FactoryB*/)
    {
        return FactoryB::instance();
    }
    else
    {
        return NULL;
    }
}

我可以做这样的事情，但我想要更好！

我的想法是，工厂基类将有一个工厂列表，从Factory继承的每个类都会创建一个静态实例，并通过<中的受保护类函数将该实例添加到列表中em>工厂。

但是，如果不玩带有静态对象初始化的俄罗斯轮盘赌，我无法找到一种方法来做到这一点。

Answer 1

为了避免静态初始化顺序出现问题，您可以将该列表设为函数 getFactoryList() 的静态成员。当受保护的构造函数需要将工厂添加到列表时，这将确保列表存在。

然后，您需要向 Factory 添加一个虚拟方法来确定是否应使用给定的工厂。希望一次只有一个工厂可以使用，这样工厂创建的顺序就不会改变返回哪个工厂。

Answer 2

事情很简单：

class BaseFactory
{
    public:
        BaseFactory()
        {
           std::list<BaseFactory*>&  fList = getFactoryList();
           fList.push_back(this);

           // If you are feeling brave.
           // Write the destructor to remove the object from the list.
           //
           // Note C++ guarantees the list will live longer than any of the factories
           // Because the list will always be completely constructed before any
           // of the factory objects (because we get the list in the constructor).
        }

        static BaseFactory& getFactory()  // Don't return a pointer (use a reference)
        {
           std::list<BaseFactory*>&  fList = getFactoryList();
           std::list<BaseFactory*>::iterator i = selectFactory(fList);

           if (i == fList.end()
           {
               static FakeFactory  fakeFactory; // Having a fake factory that
                                                // that returns fake object
                                                // is usually a lot easier than checking for
                                                // NULL factory objects everywhere in the code
                                                //
                                                // Alternatively throw an exception.
               return fakeFactory;
           }

           return *(*i); // return reference
        }
    private:
        static std::list<BaseFactory*>& getFactoryList()
        {
            static std::list<BaseFactory*>  factoryList; // Notice the static
            return factoryList;
        }
};

Answer 3

这样的设计会给您带来什么好处？我的意思是，即使您有该列表，您也必须根据某些标准以某种方式选择该工厂。

尝试使用控制反转模式。

如果 A 类需要创建一个对象，请将工厂传递给该类。

class A {
    Factory *f;
 public:
    A(Factory *f)
       : f(f)
    {  }

    void doSomething()
    {
       Object o = f->produce();
        ...
    }
}

然后您将决定在“更高级别”使用哪个工厂。工厂可能来自源代码、表单插件等。

Answer 4

我使用一种模式来收集子类的实例。这是它以工厂的形式表达的基本内容：

class Factory {
    public:
      virtual Foo* makeFoo()=0;
      ...
    protected:
      Factory(){
          getFactoryList().push_back(this);
      }
    private:
      FactoryList& getFactoryList();  // Returns static list
};

class FactoryA: public Factory{
      Foo* makeFoo();  // I make a Foo my way
} FACTORYINSTANCE;

您仍然需要一种方法来搜索列表以找到要使用的正确工厂，而我的宏 FACTORYINSTANCE 只是计算一个唯一的名称，以便调用它自己的构造函数。