抽象工厂模式

一、图例

 

二、代码片段（以下都是产品类）

代码片断1：Product.h //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_H_

 

代码片断2：Product.cpp

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

using namespace std;
AbstractProductA::AbstractProductA() {
}
AbstractProductA::~AbstractProductA() {
}
AbstractProductB::AbstractProductB() {
}
AbstractProductB::~AbstractProductB() {
}

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

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

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

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

 

代码片断3：AbstractFactory.h （以下是抽象工厂类）

//AbstractFactory.h
#ifndef _ABSTRACTFACTORY_H_

#define _ABSTRACTFACTORY_H_

class AbstractProductA;

class AbstractProductB;

class AbstractFactory

 {

 public:

            virtual ~AbstractFactory();
            virtual AbstractProductA* CreateProductA() = 0;
            virtual AbstractProductB* CreateProductB() = 0;
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_H_

代码片断4：AbstractFactory.cpp

//AbstractFactory.cpp
#include "AbstractFactory.h"

 #include "Product.h"
#include <iostream> using namespace std;
AbstractFactory::AbstractFactory() {
}
AbstractFactory::~AbstractFactory()

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

 

代码片断5：main.cpp

//main.cpp

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

using namespace std;
int main(int argc,char* argv[])

 {

              AbstractFactory* cf1 = new ConcreteFactory1();
              cf1->CreateProductA();

              cf1->CreateProductB();

             AbstractFactory* cf2 = new ConcreteFactory2();

             cf2->CreateProductA();

             cf2->CreateProductB();
             return 0;

}

 

三、总结

3.1 AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。

3.2 为了更好的理解这个模式，现在举个例子如：

为游戏设立等级，初级、中级、高级甚至有BT级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建BT级的怪物。

在上面的代码例子中，每个产品就相当于一个等级关卡，比如说AbstractProductA可以是初级关卡，  然后每个关卡里面有同一等级但不同类型的怪物，比如ProductA1,ProductA2表示两种同级中不同类型的怪物。然后针对N种关卡可以创建N个工厂，每个工厂负责产生不同关卡但同一类型或者等级的怪物