C++设计模式----抽象工厂

抽象工厂是基于简单工厂的基础之上。因为在简单工厂：http://blog.csdn.net/zhangyulin54321/article/details/7970740

中可以了解到，它局限于为一类对象的创建，他们有共同的基类product。而抽象工厂可以为一组类对象的创建，可以为不同类提供对象创建的接口，就是为了解决创建一组相关或相互依赖的对象。

//product.h

#ifndef _PRODUCT_H_

#define _PRODUCT_H_

class ProductA

{

public:

virtual ~ProductA()=0;

protected:

ProductA();

private:

};

class ConcreteProductA1:public ProductA

{

public:

ConcreteProductA1();

~ConcreteProductA1();

protected:

private:

};

class ConcreteProductA2:public ProductA

{

public:

ConcreteProductA2();

~ConcreteProductA2();

protected:

private:

};

class ProductB

{

public:

virtual ~ProductB()=0;

protected:

ProductB();

private:

};

class ConcreteProductB1:public ProductB

{

public:

ConcreteProductB1();

~ConcreteProductB1();

protected:

private:

};

class ConcreteProductB2:public ProductB

{

public:

ConcreteProductB2();

~ConcreteProductB2();

protected:

private:

};

#endif

//product.cpp

#include"product.h"

#include<iostream>

using namespace std;

ProductA::ProductA()

{

cout<<"ProductA()"<<endl;

}

ProductA::~ProductA()

{

cout<<"~ProductA()"<<endl;

}

ConcreteProductA1::ConcreteProductA1()

{

cout<<"ConcreteProductA1()"<<endl;

}

ConcreteProductA1::~ConcreteProductA1()

{

cout<<"~ConcreteProductA1()"<<endl;

}

ConcreteProductA2::ConcreteProductA2()

{

cout<<"ConcreteProductA2()"<<endl;

}

ConcreteProductA2::~ConcreteProductA2()

{

cout<<"~ConcreteProductA2()"<<endl;

}

//////////////

ProductB::ProductB()

{

cout<<"ProductB()"<<endl;

}

ProductB::~ProductB()

{

cout<<"~ProductB()"<<endl;

}

ConcreteProductB1::ConcreteProductB1()

{

cout<<"ConcreteProductB1()"<<endl;

}

ConcreteProductB1::~ConcreteProductB1()

{

cout<<"~ConcreteProductB1()"<<endl;

}

ConcreteProductB2::ConcreteProductB2()

{

cout<<"ConcreteProductB2()"<<endl;

}

ConcreteProductB2::~ConcreteProductB2()

{

cout<<"~ConcreteProductB2()"<<endl;

}

//AbstratorFactory.h

#ifndef _FACTORY_H

#define _FACTORY_H

class ProductA;

class ProductB;

class AbstractFactory

{

public:

virtual~ AbstractFactory()=0;

virtual ProductA* createProductA()=0;

virtual ProductB* createProductB()=0;

protected:

AbstractFactory();

private:

};

class ConcreteFactory1:public AbstractFactory

{

public:

ConcreteFactory1();

virtual~ ConcreteFactory1();

ProductA* createProductA();

ProductB* createProductB();

protected:

private:

};

class ConcreteFactory2:public AbstractFactory

{

public:

ConcreteFactory2();

virtual~ ConcreteFactory2();

ProductA* createProductA();

ProductB* createProductB();

protected:

private:

};

#endif

//AbstratorFactory.cpp

#include"Factory.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;

}

ProductA* ConcreteFactory1::createProductA()

{

return new ConcreteProductA1();

}

ProductB* ConcreteFactory1::createProductB()

{

return new ConcreteProductB1();

}

//////////////////

ConcreteFactory2::ConcreteFactory2()

{

cout<<"ConcreteFactory2()"<<endl;

}

ConcreteFactory2::~ConcreteFactory2()

{

cout<<"~ConcreteFactory2()"<<endl;

}

ProductA* ConcreteFactory2::createProductA()

{

return new ConcreteProductA2();

}

ProductB* ConcreteFactory2::createProductB()

{

return new ConcreteProductB2();

}

//main.cpp

#include<iostream>

#include"AbstratorFactory.h"

#include"product.h"

using namespace std;

void main()

{

AbstractFactory *af1=new ConcreteFactory1();

ProductA *pa=af1->createProductA();

ProductB *pb=af1->createProductB();

delete pa;

delete pb;

delete af1;

AbstractFactory *af2=new ConcreteFactory2();

ProductA *pa2=af2->createProductA();

ProductB *pb2=af2->createProductB();

delete pa2;

delete pb2;

delete af2;

}

可以看到与简单工厂相比，当我们创建一组对象（product1和product2）时候，我们只要维护一个创建对象（concreteFactory1），这样就简化了维护的成本和代价