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），这样就简化了维护的成本和代价