AbstactFactory模式

AbstractFactory模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

　　AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中，

维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。

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_

Product.cpp

 #include "Product.h"
 #include <iostream>
 using namespace std;
 AbstractProductA::AbstractProductA() {
 }
 AbstractProductA::~AbstractProductA() {
 }
 AbstractProductB::AbstractProductB() {
 }
 AbstractProductB::~AbstractProductB() {
 }
 ProductA1::ProductA1() {
     cout<<"ProductA1..."<<endl; }
 ProductA1::~ProductA1() {
 }
 ProductA2::ProductA2() {
     cout<<"ProductA2..."<<endl; }
 ProductA2::~ProductA2() {
 }
 ProductB1::ProductB1(){
     cout<<"ProductB1..."<<endl; }
 ProductB1::~ProductB1() {
 }
 ProductB2::ProductB2() {
     cout<<"ProductB2..."<<endl; }
 ProductB2::~ProductB2() {
 }

AbstractFactory.h

 #ifndef _ABSTRACTFACTORY_H_
 #define _ABSTRACTFACTORY_H_

 class AbstractProductA;
 class AbstractProductB;

 class AbstractFactory {
 public:
     virtual ~AbstractFactory();
     virtual AbstractProductA* CreateProductA() = ;
     virtual AbstractProductB* CreateProductB() = ;
 protected:
     AbstractFactory();
 private:
 };
 class ConcreteFactory1:public AbstractFactory {
 public:
     ConcreteFactory1();
     ~ConcreteFactory1();
     AbstractProductA* CreateProductA();
     AbstractProductB* CreateProductB();
 protected:
 private:
 };
 class ConcreteFactory2:public AbstractFactory {
 public:
     ConcreteFactory2();
     ~ConcreteFactory2();
     AbstractProductA* CreateProductA();
     AbstractProductB* CreateProductB();
 protected:
 private:
 };
 #endif //~_ABSTRACTFACTORY_H_

AbstractFactory.cpp

 #include "AbstractFactory.h"
 #include "Product.h"
 #include <iostream>
 using namespace std;
 AbstractFactory::AbstractFactory() {
 }
 AbstractFactory::~AbstractFactory()
     {
 }
 ConcreteFactory1::ConcreteFactory1() {
 }
 ConcreteFactory1::~ConcreteFactory1() {
 }
 AbstractProductA* ConcreteFactory1::CreateProductA() { return new ProductA1(); }
 AbstractProductB* ConcreteFactory1::CreateProductB() { return new ProductB1(); }
 ConcreteFactory2::ConcreteFactory2() {
 }
 ConcreteFactory2::~ConcreteFactory2() {
 }
 AbstractProductA* ConcreteFactory2::CreateProductA() { return new ProductA2(); }
 AbstractProductB* ConcreteFactory2::CreateProductB() { return new ProductB2(); }

main.cpp

 #include "AbstractFactory.h"
 #include <iostream>
 using namespace std;
 int main(int argc,char* argv[]) {
     AbstractFactory* cf1 = new ConcreteFactory1();
     cf1->CreateProductA();
     cf1->CreateProductB();
     AbstractFactory* cf2 = new ConcreteFactory2();
     cf2->CreateProductA();
     cf2->CreateProductB();
     return ;
 }

　　AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。