设计模式之AbstractFactory模式【C++】

AbstractFactory模式结构图如下：

代码实现：

//ProductA.h
#ifndef _PRODUCTA_H_
#define _PRODUCTA_H_

class ProductAAbs
{
public:
    virtual ~ProductAAbs();

    virtual void OperateA()=0;

protected:
    ProductAAbs();

private:

};

class ProductAImpl1:public ProductAAbs
{
public:
    ProductAImpl1();
    ~ProductAImpl1();

    void OperateA();

protected:
private:

};

class ProductAImpl2:public ProductAAbs
{
public:
    ProductAImpl2();
    ~ProductAImpl2();

    void OperateA();

protected:
private:

};

#endif

//ProductA.cpp
#include "ProductA.h"
#include<iostream>
using namespace std;

//class ProductAAbs
ProductAAbs::ProductAAbs()
{

}

ProductAAbs::~ProductAAbs()
{

}

//class ProductAImpl1
ProductAImpl1::ProductAImpl1()
{
    cout<<"Construct of ProductAImpl1."<<endl;
}

ProductAImpl1::~ProductAImpl1()
{
    cout<<"Destruct of ProductAImpl1."<<endl;
}

void ProductAImpl1::OperateA()
{
    cout<<"OperateA of ProductAImpl1."<<endl;
}

//class ProductAImpl2
ProductAImpl2::ProductAImpl2()
{
    cout<<"Construct of ProductAImpl2."<<endl;
}

ProductAImpl2::~ProductAImpl2()
{
    cout<<"Destruct of ProductAImpl2."<<endl;
}

void ProductAImpl2::OperateA()
{
    cout<<"OperateA of ProductAImpl2."<<endl;
}

//ProductB.h
#ifndef _PRODUCTB_H_
#define _PRODUCTB_H_

class ProductBAbs
{
public:
    virtual ~ProductBAbs();

    virtual void OperateB()=0;

protected:
    ProductBAbs();

private:

};

class ProductBImpl1:public ProductBAbs
{
public:
    ProductBImpl1();
    ~ProductBImpl1();

    void OperateB();

protected:
private:

};

class ProductBImpl2:public ProductBAbs
{
public:
    ProductBImpl2();
    ~ProductBImpl2();

    void OperateB();

protected:
private:

};

#endif

//ProductB.cpp
#include "ProductB.h"
#include<iostream>
using namespace std;

//class ProductBAbs
ProductBAbs::ProductBAbs()
{

}

ProductBAbs::~ProductBAbs()
{

}

//class ProductBImpl1
ProductBImpl1::ProductBImpl1()
{
    cout<<"Construct of ProductBImpl1."<<endl;
}

ProductBImpl1::~ProductBImpl1()
{
    cout<<"Destruct of ProductBImpl1."<<endl;
}

void ProductBImpl1::OperateB()
{
    cout<<"OperateB of ProductBImpl1."<<endl;
}

//class ProductBImpl2
ProductBImpl2::ProductBImpl2()
{
    cout<<"Construct of ProductBImpl2."<<endl;
}

ProductBImpl2::~ProductBImpl2()
{
    cout<<"Destruct of ProductBImpl2."<<endl;
}

void ProductBImpl2::OperateB()
{
    cout<<"OperateB of ProductBImpl2."<<endl;
}

//AbstractFactory.h
#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_

enum ID_PRODUCTIMPL
{
ID_PRODUCTIMPL_1,
ID_PRODUCTIMPL_2
};

class ProductAAbs;
class ProductBAbs;

class AbstractFactoryAbs
{
public:
    virtual ~AbstractFactoryAbs();
    virtual ProductAAbs * CreateProductA(ID_PRODUCTIMPL id)=0;
    virtual ProductBAbs * CreateProductB(ID_PRODUCTIMPL id)=0;

protected:
    AbstractFactoryAbs();

private:

};

class AbstractFactoryImpl:public AbstractFactoryAbs
{
public:
    AbstractFactoryImpl();
    ~AbstractFactoryImpl();
    ProductAAbs * CreateProductA(ID_PRODUCTIMPL id);
    ProductBAbs * CreateProductB(ID_PRODUCTIMPL id);

protected:
private:

};

#endif

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

//class AbstractFactoryAbs
AbstractFactoryAbs::AbstractFactoryAbs()
{

}

AbstractFactoryAbs::~AbstractFactoryAbs()
{

}

//class AbstractFactoryImpl
AbstractFactoryImpl::AbstractFactoryImpl()
{

}

AbstractFactoryImpl::~AbstractFactoryImpl()
{

}

ProductAAbs * AbstractFactoryImpl::CreateProductA(ID_PRODUCTIMPL id)
{
    switch(id)
    {
    case ID_PRODUCTIMPL_1:
        return new ProductAImpl1();
    case ID_PRODUCTIMPL_2:
        return new ProductAImpl2();
    default:
        return 0;
    }
}

ProductBAbs * AbstractFactoryImpl::CreateProductB(ID_PRODUCTIMPL id)
{
    switch(id)
    {
    case ID_PRODUCTIMPL_1:
        return new ProductBImpl1();
    case ID_PRODUCTIMPL_2:
        return new ProductBImpl2();
    default:
        return 0;
    }
}

//Test.cpp
#include "ProductA.h"
#include "ProductB.h"
#include "AbstractFactory.h"

#include<iostream>
using namespace std;

void main()
{
    AbstractFactoryAbs * factory=new AbstractFactoryImpl();
    ProductAAbs * productA=NULL;
    ProductBAbs * productB=NULL;

    if(productA!=NULL)
    {
        delete productA;
        productA=NULL;
    }
    productA=factory->CreateProductA(ID_PRODUCTIMPL_1);
    productA->OperateA();

    if(productB!=NULL)
    {
        delete productB;
        productB=NULL;
    }
    productB=factory->CreateProductB(ID_PRODUCTIMPL_1);
    productB->OperateB();

    if(productA!=NULL)
    {
        delete productA;
        productA=NULL;
    }
    productA=factory->CreateProductA(ID_PRODUCTIMPL_2);
    productA->OperateA();

    if(productB!=NULL)
    {
        delete productB;
        productB=NULL;
    }
    productB=factory->CreateProductB(ID_PRODUCTIMPL_2);
    productB->OperateB();

    if(productA!=NULL)
    {
        delete productA;
        productA=NULL;
    }
    if(productB!=NULL)
    {
        delete productB;
        productB=NULL;
    }
    if(factory!=NULL)
    {
        delete factory;
        factory=NULL;
    }
}