Abstract Factory模式
在设计模式中,这个模式是最基础的,而这个模式根据Eric Gamma(模式设计的提出者)的介绍的目的如下:Provide an interface for creating families of related or depandant objects without specifying their concrete classes.中文通俗的说就是:定义一个抽象基类(或者说提供一个接口),这个基类包含了很多类功能,当你需要切换场景但是所有场景都具有那些类功能的时候,你只需要生成一个抽象基类的派生类就可以了。
而在实现上,通常要在抽象类中定义并生成所有子部件(class),这样也可以防止由于子部件太多,总是要new XXX之后才可以使用的麻烦(特别是当子部件的名字越来越难记得时)。
Abstract Factory模式的结构
Abstract Factory模式的应用
这个结构的应用非常广泛,例如Eric Gamma经常举的例子(肯定是和游戏有关的,因为那四位博士大牛都喜欢设计游戏),在制作一个迷宫(Maze)游戏中,Maze就可以看作是一个Factory,而房间、墙壁、门等每个迷宫都需要的子部件就是Product了。而每一个不同的Maze就可以直接使用Factory接口就可以了。
利用上面的结构图,可以再广义的理解一下如何使用这个模式:
AstractProductA和AstractProductB可以理解为是两种子部件(如迷宫中的门和房间),而ProductA1则是大门,ProductA2是小门,同理ProductB1是大房间,ProductB2是小房间,而AbstractFactoryA则是一个有大房间和大门的迷宫,所以在createProductA的时候,返回一个ProuctA1,如此类推其他的子部件(先定义,再选择使用)。
而在main.cpp中,只需要调用createFactory函数就可以了。
具体实现见下一节的代码。
Abstract Factory的实现
定义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
定义AbstractFactory.h
#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H
#include "product.h"
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(); //在.cpp中实现:{ return new ProductA1();}
AbstractProductB* CreateProductB(); //在.cpp中实现:{ return new ProductB1();}
protected:
private:
};
class ConcreteFactory2:public AbstractFactory
{
public:
ConcreteFactory2();
~ConcreteFactory2();
AbstractProductA* CreateProductA(); //派生类实现
AbstractProductB* CreateProductB();
protected:
private:
};
#endif // ABSTRACTFACTORY_H
主程序使用main.cpp
#include "AbstractFactory.h"
#include "product.h"
using namespace std;
int main()
{
AbstractFactory *p1 = new ConcreteFactory1();
p->CreateProductA();
p->CreateProductB();
AbstractFactory *p2 = new ConcreteFactory2();
p->CreateProductA();
p->CreateProductB();
return 0;
}