简略工厂模式VS工厂模式，想问问工厂模式有啥用

简单工厂模式VS工厂模式，想问问工厂模式有啥用？
最近在看设计模式。
前提：
class A
{
};
class B : public A
{
};
class C : public A
{
};
int main()
{
   A* b = new B();
   A* c = new C();
   return 0;
}

简单工厂：
class Factory
{
   A* a;
   A* function(std::string key)
   {
      switch(key)
      {
        case "b":
             a = new b();
             break;
        case "c":
             a = new c();
             break;
      }
      return a;
   }
};
简单工厂模式，会有一个方法，通过传进来的参数判断new哪一个子类对象，然后返回给使用者，那么【这个动态生成对象的判断就在工厂类中处理，使用者不需要做逻辑处理，只需传进参数即可获得对应的对象】

工厂模式：
class Bfactory : public B
{
    A* b;
    A* function()
    {
       b = new B();
       return b;
    }
};
class Cfactory : public C
{
};
结果是对应每个子类，都有一个对应的工厂类【里面有一个方法产生其对象】。
问题就在于这里了，工厂模式最终还是交给使用者进行逻辑判断，究竟使用那个工厂类。那么不就没有了简单工厂模式的优势了？？再者一个子类对应一个工厂类，由工厂类产生子类对象。还不如直接用子类产生对象就行了，工厂类还有何用？
PS:
1普通生成子类：     A* b = new B();
2工厂模式生成子类： Bfactory* pFactory = new Bfactory();  A* b = pFactory->function();
既然都是由使用者做逻辑判断产生哪个子类，由何须工厂模式再弄多一个工厂类出来呢？

希望各位大虾指导一下，刚看设计模式。。。。
------解决方案--------------------
有的东西是文字无法表达的，扩展性是什么？重用性是什么？易于修改到底是什么意思，这些你可以想想，似乎懂了，似乎不懂，其实有的东西当你亲身去体会你才知道他们真正的含义。建议楼主搜一下面向接口编程
------解决方案--------------------
你说的工厂模式应该是一种”工厂方法“模式。工厂方法提供了所谓的“虚构造函数”功能，c++的ctor是不能为virtual的，但在某些场合下，开发者却需要这样的多态性。“工厂方法”就是解决这个问题的，你在你的开发中肯定没有遇到过这样的需求，因此你就不会有这样的考虑。一个工厂方法具有这样的形式：

class A
{
public:
virtual ~A() {}
};
class AFactory
{
public:
virtual A* create() { return new A; }
};

这个具体建立对象的方法一定是virtual的。Factory就充当了一个虚构造函数的功能。假设我有一个应用基类，它需要构建一个A的子类来完成某些事情：

class App
{
public:
  App( AFactory& f ) { a = f.create(); }
protected:
  A* a;
};

我会这么使用它们：
AFactory f;
App app( &f );

但是我现在需要扩展App以及A的功能：

class A2 : public A {}
class App2 : public App
{
public:
  App( AFactory& f ) { a = f.create(); }
}

我的App2在App的基础上增加了一些新的内部操作，并且在App2中使用的是A2——A的子类，因为在内部都是基于接口进行开发的，因此一切都靠多态性保持兼容。在App2我需要构造A2，而不是A，我还要保持接口一致，怎么做呢？这就是工厂方法的威力所在，我子类化AFactory：

class A2Factory : public AFactory
{
public:
  virtual A* create() { return new A2; }
};

然后，我这样使用它们：

A2Factory f;

简略工厂模式VS工厂模式，想问问工厂模式有啥用

相关推荐