c++设计模式系列----factory模式

问题：

假设我们要开发一个游戏--打怪物，首先，游戏有分等级，假设有初级，中级两个个等级（就不用flappy bird模式了，那个比较特殊，对一个玩家来说是难以具有持久吸引力的！），不同的等级怪物也是不一样的，我们不妨假设初级为怪物A1, B1，中级为怪物A2，B2。如图所示：

设计：

那么根据面向对象思想，我们来考虑一下应该怎么设计程序结构，首先不同等级的怪物要由不同的对象来产生，即相当于不同等级的怪物也应该由不同类型的工厂来生产。但不同等级的怪物都是怪物，它们具有某些共同点，应该继承自同一个父怪物类。同样，不同等级的工厂也应该继承自同一个父工厂类。我们称这样的父工厂类和父怪物类为AbstractFactory和AbstractProduct。这个模式成为AbstractFactory模式。

AbstractFactory模式的典型结构图为：

其实这里我们还应该考虑的一个问题是我们为什么要增加一个AbstractFactory类，在factory模式中，是不需要AbstractFactory而是直接由factory类来生产product的，即如下的结构：

但我们从第二个图可以很容易看出，这里的factory只有一个，只能生产同一个等级的怪物。

首先，我们用factory的是为了解决两个问题：

1）、提高内聚和松耦合

2）、父类中无法知道要实例化哪个具体的子类（具体看下面）

这里引出了factory模式的两个重要功能：

1）定义创建对象的接口，封装了对象的创建；
2）使得具体化类的工作延迟到了子类中。

我们可以看出，第二个图的结构解决了第一个问题，即它使得我们能够规范的使用一个接口来初始化类，我们想象一下，为了达到多态，我们经常抽象出一个基类，然后很多不同的子类指向这个基类，这样我们在需要创建子类的对象的时候我们就必须知道具体的子类的名字，这样带来很多问题，如名称多而乱等，还有可拓展性问题。但有一个相同的接口的话，接口内部的修改不影响用户，可拓展性增强了，而且用户无需知道具体的子类的名字就可以创建对象了。

但是，第二个图的结构无法解决第二个问题。第二个图的模式只有一种基类。那么这时我们就要用到第一个图所显示的AbstractFactory 模式了。

AbstractFactory 模式通过将一组对象的额创建封装到一个用于创建对象的类（ConcreteFactory）中，这样，我们可以根据不同的ConcreteFactory类来实例化不同类型的子对象。并且，维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。

下面我们来看看具体的代码实现：

 //Product.h

 #ifndef PRODUCT_H
 #define PRODUCT_H

 class AbstractProductA{
 public:
     virtual ~AbstractProductA();
 protected:
     AbstractProductA();
 private:
 };

 class AbstractProductB
 {
 public:
     virtual ~AbstractProductB();
 protected:
     AbstractProductB();
 private:
 };

 class ProductA1: public AbstractProductA{
 public:
     ProductA1();
     ~ProductA1();
 protected:
 private:
 };

 class ProductA2:public AbstractProductA
 {
 public:
     ProductA2();
     ~ProductA2();
 protected:
 private:
 }; 

 class ProductB1: public AbstractProductB{
 public:
     ProductB1();
     ~ProductB1();
 protected:
 private:
 };

 class ProductB2: public AbstractProductB{
 public:
     ProductB2();
     ~ProductB2();
 protected:
 private:
 };

 #endif

 //Product.cpp

 #include "Product.h"
 #include <iostream>

 using namespace std;

 AbstractProductA::AbstractProductA() {
     cout << "AbstractProductA..." << endl;
 }

 AbstractProductA::~AbstractProductA() {
     cout << "~AbstractProductA..." << endl;
 }

 AbstractProductB::AbstractProductB() {
     cout << "AbstractProductB..." << endl;
 }

 AbstractProductB::~AbstractProductB() {
     cout << "~AbstractProductB..." << endl;
 }

 ProductA1::ProductA1() {
     cout << "ProductA1..." << endl;
 }
 ProductA1::~ProductA1() {
     cout << "~ProductA1..." << endl;
 }

 ProductA2::ProductA2() {
     cout << "ProductA2..." << endl;
 }
 ProductA2::~ProductA2() {
     cout << "~ProductA2..." << endl;
 }

 ProductB1::ProductB1() {
     cout << "ProductB1..." << endl;
 }
 ProductB1::~ProductB1() {
     cout << "~ProductB1..." << endl;
 }

 ProductB2::ProductB2() {
     cout << "ProductB2..." << endl;
 }
 ProductB2::~ProductB2() {
     cout << "~ProductB2..." << endl;
 }

 //AbstractFactory.h

 #ifndef ABSTRACTFACTORY_H
 #define ABSTRACTFACTORY_H

 class AbstractProductA;
 class AbstractProductB;

 class AbstractFactory{
 public:
     virtual ~AbstractFactory();
     virtual AbstractProductA* CreateProductA() = ;
     virtual AbstractProductB* CreateProductB() = ;
 protected:
     AbstractFactory();
 private:
 };

 class ConcreteFactory1: public AbstractFactory{
 public:
     ConcreteFactory1();
     ~ConcreteFactory1();
     AbstractProductA* CreateProductA();
     AbstractProductB* CreateProductB();
 protected:
 private:
 };

 class ConcreteFactory2: public AbstractFactory{
 public:
     ConcreteFactory2();
     ~ConcreteFactory2();
     AbstractProductA* CreateProductA();
     AbstractProductB* CreateProductB();
 protected:
 private:
 };

 #endif

 //AbstractFactory.cpp

 #include "AbstractFactory.h"
 #include "Product.h"
 #include <iostream>

 using namespace std;

 AbstractFactory::AbstractFactory() {
     cout << "AbstractFactory..." << endl;
 }

 AbstractFactory::~AbstractFactory() {
     cout << "~AbstractFactory..." << endl;
 }

 ConcreteFactory1::ConcreteFactory1() {
     cout << "ConcreteFactory1..." << endl;
 }

 ConcreteFactory1::~ConcreteFactory1() {
     cout << "~ConcreteFactory1..." << endl;
 }

 AbstractProductA* ConcreteFactory1::CreateProductA() {
     return new ProductA1();
 }
 AbstractProductB* ConcreteFactory1::CreateProductB() {
     return new ProductB1();
 }

 ConcreteFactory2::ConcreteFactory2() {
     cout << "ConcreteFactory2..." << endl;
 }

 ConcreteFactory2::~ConcreteFactory2() {
     cout << "~ConcreteFactory2..." << endl;
 }

 AbstractProductA* ConcreteFactory2::CreateProductA() {
     return new ProductA2();
 }
 AbstractProductB* ConcreteFactory2::CreateProductB() {
     return new ProductB2();
 }

 //main.cpp

 #include"AbstractFactory.h"
 #include<iostream>

 using namespace std;

 int main(int argc,char*argv[])
 {
     AbstractFactory* concretefactory1  = new ConcreteFactory1();
     concretefactory1->CreateProductA();
     concretefactory1->CreateProductB(); 

     AbstractFactory* concretefactory2  = new ConcreteFactory2();
     concretefactory2->CreateProductA();
     concretefactory2->CreateProductB();
     return ;
 } 

运行结果：

AbstractFactory...
ConcreteFactory1...
AbstractProductA...
ProductA1...
AbstractProductB...
ProductB1...
AbstractFactory...
ConcreteFactory2...
AbstractProductA...
ProductA2...
AbstractProductB...
ProductB2...
请按任意键继续. . .