设计模式1——Abstract Factory模式（C++实现）

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;
}