设计模式中的抽象工厂模式&c++

属于创建型设计模式中的一种。

这里首先介绍简单工厂模式（Simple Factory）

概述：

该模式一上来就是一个具体的工厂类，供用户调用来创建具体的产品。产品有抽象类，从抽象类中派生出多个具体产品。然后在工厂类中根据参数动态生成具体产品类对象。
demo:（代码来源：http://www.cnblogs.com/jerry19880126/archive/2012/08/08/2628321.html

  
  
简单工厂模式
#include <iostream>
using namespace std;
// 简单工厂模式
// 抽象产品
class AbstractProduct
{
public:
    virtual void getProductsName() = 0;
};
// 具体产品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void  getProductsName()
    {
        cout << "ConcreteProduct1" << endl;
    }
};
// 具体产品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void  getProductsName()
    {
        cout << "ConcreteProduct2" << endl;
    }
};
// 具体的工厂（没有抽象工厂）
class ConcreteFactory
{
public:
    AbstractProduct* getProductObject(int flag)
    {
        if(flag == 1)
        {
            return new ConcreteProduct1();
        }
        else if(flag == 2)
        {
            return new ConcreteProduct2();
        }
        else
        {
            return 0;
        }
    }
};
int main()
{
    ConcreteFactory f;
    AbstractProduct* p1 = f.getProductObject(1);
    AbstractProduct* p2 = f.getProductObject(2);
    p1->getProductsName();
    p2->getProductsName();
    delete p1;
    delete p2;
    return 0;
}

1. （普通）工厂模式（Factory）

与简单工厂模式换汤不换药，只是把工厂也“抽象”了，UML图如下所示：

区别与简单工厂模式，普通工厂模式将工厂类也进行了抽象，提供了工厂类的抽象类。并且将简单工厂模式中由用户提供参数后台进行创建何种对象的创建的情况进行了修改。每个具体的工厂类负责创建一个现实的产品。这样，客户端就可以决定调用哪一个工厂类，然后就不用后台进行判断选择具体创建那个产品了。

这里假定有两个ConcreteFactory，一个是ConcreteFactory1，只生产ConcreteProduct1产品，另一个是ConcreteFactory2，只生产ConcreteProduct2产品。

代码如下：

 
 
普通工厂模式
#include <iostream>
using namespace std;
//普通工厂模式
//抽象产品
class AbstractProduct
{
public:
    virtual void getProductName() = 0;
};
//具体产品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void getProductName()
    {
        cout << "ConcreteProduct1" << endl;
    }
};
//具体产品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void getProductName()
    {
        cout << "ConcreteProduct2" << endl;
    }
};
//抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProduct* getProduct() = 0;
};
//具体工厂1
class ConcreteFactory1: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct1();
    }
};
//具体工厂2
class ConcreteFactory2: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct2();
    }
};
int main()
{
    AbstractFactory* f1 = new ConcreteFactory1();
    AbstractFactory* f2 = new ConcreteFactory2();
    f1->getProduct()->getProductName();
    f2->getProduct()->getProductName();
    delete f1, f2;
    return 0;
}

最后是：

抽象工厂模式（Abstract Factory）

抽象工厂模式其实是之前正常工厂模式的进化，或者说是多了些内容而已。

同样的，该模式中有一个抽象的工厂类，区别之前的是抽象工厂中生产的产品多了一个。所以嘛，如图所示，继承自他的具体类工厂也就都变成了包含两个成员函数，负责对产品的生产。

抽象产品类也是有两个A（A1,A2），B(B1,B2)，每个产品有两个不同的版本。对应的两个具体工厂类。

具体工厂类1负责生产A1,B1  .

具体工厂类2负责生产A2,B2.  

应用用例：

这样的 抽象工厂模式可以利用在这样的场景下：

比如如今流行的windows跟mac两版本电脑。我们可能在界面层会使用两套独立的界面包。这时候，我们就可以创建抽象工厂类WidgetFactory，内含按钮，滚动条，树控件等虚接口。然后派生出两套具体的工厂类winWidgetFactory,macWidgetFactory。然后正对某个控件，譬如说按钮，为其定义一个抽象类，然后同样派生出win跟mac两款具体类。滚动条也进行同样的定制。这样，就可以供两款具体工厂类进行调用了。使用时，针对某一款系列平台，使用对应的工厂类就可以正确选择匹配的各个具体产品了。

demo实例：

 
 
抽象工厂模式
#include <iostream>
using namespace std;
 
// 抽象工厂模式
 
// 抽象产品A
class AbstractProductA
{
public:
         virtual void getProductName() = 0;
};
 
// 具体产品A1
class ConcreteProductA1: public AbstractProductA
{
public:
         void getProductName()
         {
                   cout << "ConcreteProductA1" << endl;
         }
};
 
 
// 具体产品A2
class ConcreteProductA2: public AbstractProductA
{
public:
         void getProductName()
         {
                   cout << "ConcreteProductA2" << endl;
         }
};
 
 
// 抽象产品B
class AbstractProductB
{
public:
         virtual void getProductName() = 0;
};
 
// 具体产品B1
class ConcreteProductB1: public AbstractProductB
{
public:
         void getProductName()
         {
                   cout << "ConcreteProductB1" << endl;
         }
};
 
 
// 具体产品B2
class ConcreteProductB2: public AbstractProductB
{
public:
         void getProductName()
         {
                   cout << "ConcreteProductB2" << endl;
         }
};
 
 
// 抽象工厂
class AbstractFactory
{
public:
         virtual AbstractProductA* getProductA() = 0;
         virtual AbstractProductB* getProductB() = 0;
};
 
 
// 具体工厂1
class ConcreteFactory1: public AbstractFactory
{
         AbstractProductA* getProductA()
         {
                   return new ConcreteProductA1;
         }
         AbstractProductB* getProductB()
         {
                   return new ConcreteProductB1;
         }
};
 
// 具体工厂2
class ConcreteFactory2: public AbstractFactory
{
         AbstractProductA* getProductA()
         {
                   return new ConcreteProductA2;
         }
 
         AbstractProductB* getProductB()
         {
                   return new ConcreteProductB2;
         }
};
 
 
int main()
{
         AbstractFactory *f1 = new ConcreteFactory1();
         AbstractFactory *f2 = new ConcreteFactory2();
         f1->getProductA()->getProductName();
         f1->getProductB()->getProductName();
         f2->getProductA()->getProductName();
         f2->getProductB()->getProductName();
         delete f1, f2;
         return 0;
}

优点：

1.分离了具体的类。客户可以通过抽象工厂对工厂类进行访问，以及通过抽象产品接口调用具体的产品了。

2.可以很方便的切换产品系列，像上面阐述的win系列跟mac系列界面kit的切换。

3.保证使用过程中使用的是统一风格或者说同一系列的产品，不会导致混乱的调用。

缺点：

无论是扩展抽象共产还是生产新种类的产品，都需要改变所有的具体类。很是繁琐。