工厂模式（C++）

转载地址:http://blog.sina.com.cn/s/blog_6ce9e8870101iv79.html

在程序设计的过程中你也许会遇到这样的情况：

1、在工程中，需要创建的的对象很多（new操作），导致工程中对象数目过多同时自己不清楚创建的对象是来干啥的，以及对象的名字不太好取，对以后的代码维护增添了阻力。
2、接口与实现分离。这一系列的问题，都是普通的设计无法避免的，那么如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢（接口与实现分离）？
这就需要用到今天我们提到的工厂（Factory）模式。
对于工厂模式，为了使其能更好的解决多种情况的问题，将其分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
对于上面的三种模这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。 对于上面说的三种模式式我们会在下面一一介绍。

一、简单设计模式。
看一下其结构图：


对于简单设计模式的结构图，我们可以很清晰的看到它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。
简单设计模式存在的目的很简单：定义一个用于创建对象的接口。
对以上的结构的优缺点进行以下分析：
对于以上的结构图，我们做一个简单的比方，假设：product为车，下面的三个子类为对应的三种车，factory就是工厂，制造车的工厂。现在我们可以造三种车，但是不能满足市场，我们需要创建另外一种车，对于product至于派生一个子类就ok了，这个很符合开闭原则。对于factory来说，我们就满足不了开闭原则了，因为在factory的制造业务方法中需要添加case，以达到创建目的车的目的。从这里我们很清楚的意识到，对于新的需求，工厂类的适应能力并不强。有些资料中说factory是“上帝类”，因为其一个人就完成了对象的封装创建工作，但是毕竟一人的力量是单一的，为了能解决这一问题，工厂方法模式出现了，工厂类定义为抽象类，通过派生子类，以达到单个工厂子类对应单个的对象的创建的局面，这样的设计很容易扩展，提高了工厂类的适应能力。对于简单工厂模式的代码十分的简单，这里对代码的实现不做展示。

二、工厂方法模式。
看一下其结构图：


对于上面的结构图，我们能很容易看出工厂方法模式和简单工厂模式的区别之处。工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。
对于工厂方法模式的组成：
1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。
工厂方法模式使用继承自抽象工厂角色的多个子类来完成简单工厂模式中的“上帝类”所承担的工作。这样便分担了factory对象承受的压力，而且这样使得结构变得灵活起来——当需要新的产品产生时，只要派生一个新的产品类，然后派生一个与之对应的工厂类就可以完成新的产品的生产，而不必去修改任何已有的代码。可以看出工厂角色的结构也符合了开闭原则的！
对于工厂方法模式的出现，导致对象的数目成倍的增长。这不是我们所希望的，解决方案上面可以考虑一下简单工厂模式和工厂方法模式的结合。

有一个问题：工厂方法模式真的就做到适应能力强了吗？或者说真的避免了代码的改动了吗？回答当然是否定的。在简单工厂模式中，新产品的加入要修改工厂角色中的switch语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么将具体工厂角色写死。而且产品对象创建条件的改变必然会引起工厂角色的修改。对于以上的的问题，需要做一个反射机制。对于反射机制会在以后的学习过程中，更新出来。有兴趣的朋友，可以在网上了解一下。
在实际的应用过程中，我们会创建较为复杂的对象，然而工厂方法模式已不能满足我们的需求，这就需要用到抽象工厂模式。

三、抽象工厂模式
看一下其结构图：

对于上面的结构图，可以看出抽象工厂模式，比前两者更为的复杂和一般性，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。
抽象工厂模式：给客户端提供一个接口，可以创建多个产品族中的产品对象 ，而且使用抽象工厂模式还要满足一下条件：
1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
2)同属于同一个产品族的产品以其使用。
抽象工厂模式的组成（和工厂方法模式一样）：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。
下面先看一下工厂方法模式和抽象工厂模式的C++实现源码。
工厂方法模式源码实现（C++）：
#include <iostream>
using namespace std;
//产品
class product
{
public:
    virtual ~product()=0;
protected:
    product();
   
};
//子产品
class concreateProduct:public product
{
public:
    ~concreateProduct();
    concreateProduct();
};
//工厂
class factory{
public:
    virtual ~factory()=0;
    virtual product *ConcreateProduct()=0;
protected:
    factory();

};
//子工厂
class concreateFactory:public factory
{
    public:
        ~concreateFactory();
        concreateFactory();
        product *ConcreateProduct();
};
product::product()
{
   
}
product::~product()
{

}
concreateProduct::concreateProduct()
{
    cout<<"concreateProduct"<<endl;

}
concreateProduct::~concreateProduct()
{

}
factory::factory()
{

}
factory::~factory()
{

}
concreateFactory::concreateFactory()
{
    cout<<"concreateFactory"<<endl;

}
concreateFactory::~concreateFactory()
{

}
//对应的类创建对应的产品
product *concreateFactory::ConcreateProduct()
{
    return new concreateProduct();
}
int main()
{
    factory *fac=new concreateFactory();
    product *p=fac->ConcreateProduct();
    return 0;
}
factory模式对于对象的创建给予开发人员提供了很好的实现策略，但是factory模式仅仅局限于一类类（就是说product是一类，有一个共同的基类），如果我们要为不同类的类提供一个对象创建的接口，那就要用抽象工厂模式（AbstractFactory）了。
抽象工厂模式源码实现（C++）：
#include <iostream>
using namespace std;
//产品A
class productA
{
public:
    virtual ~productA()=0;
protected:
    productA();
   
};
//子产品
class concreateProductA1:public productA
{
public:
    ~concreateProductA1();
    concreateProductA1();
};
class concreateProductA2:public productA
{
public:
    ~concreateProductA2();
    concreateProductA2();
};
//产品B
class productB
{
public:
    virtual ~productB()=0;
protected:
    productB();
   
};
//子产品
class concreateProductB1:public productB
{
public:
    ~concreateProductB1();
    concreateProductB1();
};
class concreateProductB2:public productB
{
public:
    ~concreateProductB2();
    concreateProductB2();
};

//工厂
class factory{
public:
    virtual ~factory()=0;
    virtual productA *ConcreateProductA()=0;
    virtual productB *ConcreateProductB()=0;
protected:
    factory();

};
//子工厂
class concreateFactory1:public factory
{
public:
    ~concreateFactory1();
    concreateFactory1();
    productA *ConcreateProductA();
    productB *ConcreateProductB();
};

class concreateFactory2:public factory
{
public:
    ~concreateFactory2();
    concreateFactory2();
    productA *ConcreateProductA();
    productB *ConcreateProductB();
};
productA::productA()
{
   
}
productA::~productA()
{

}
productB::productB()
{

}
productB::~productB()
{

}
concreateProductA1::concreateProductA1()
{
    cout<<"concreateProductA1"<<endl;

}
concreateProductA1::~concreateProductA1()
{

}
concreateProductA2::concreateProductA2()
{
    cout<<"concreateProductA2"<<endl;
   
}
concreateProductA2::~concreateProductA2()
{
   
}
concreateProductB1::concreateProductB1()
{
    cout<<"concreateProductB1"<<endl;
   
}
concreateProductB1::~concreateProductB1()
{
   
}
concreateProductB2::concreateProductB2()
{
    cout<<"concreateProductB2"<<endl;
   
}
concreateProductB2::~concreateProductB2()
{
   
}

factory::factory()
{

}
factory::~factory()
{

}
concreateFactory1::concreateFactory1()
{
    cout<<"concreateFactory1"<<endl;

}
concreateFactory1::~concreateFactory1()
{

}

//对应的类创建对应的产品
productA *concreateFactory1::ConcreateProductA()
{
    return new concreateProductA1();
}
productB *concreateFactory1::ConcreateProductB()
{
    return new concreateProductB1();
}
concreateFactory2::concreateFactory2()
{
    cout<<"concreateFactory2"<<endl;
   
}
concreateFactory2::~concreateFactory2()
{
   
}   
//对应的类创建对应的产品
productA *concreateFactory2::ConcreateProductA()
{
    return new concreateProductA2();
}
productB *concreateFactory2::ConcreateProductB()
{
    return new concreateProductB2();
}
int main()
{
    factory *fac1=new concreateFactory1();
    factory *fac2=new concreateFactory2();
    fac1->ConcreateProductA();
    fac1->ConcreateProductB();
    fac2->ConcreateProductA();
    fac2->ConcreateProductB();
    return 0;
}
当我们要创建一组对象（concreateProductA1，concreateProductB1）的时候我们只用维护一个创建对象（concreteFactory1），大大简化了维护的成本和工作。实际上，抽象工厂（AbstractFactory）模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而简单工厂模式或者工厂方法模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，抽象工厂（AbstractFactory）模式通常都是使用工厂方法模式实现（concreteFactory1）。


帮助文档：C++设计模式
注：转载请标明出处。