AbstractFactory Pattern

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

AbstractFactory Pattern结构图

实现：

 #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

 #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()
 {

 }

Product.cpp

 #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

 #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();
 }

AbstractFactory.cpp