常用设计模式之抽象工厂模式

抽象工厂模式：
抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。
应用场景：
当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。

实现代码：

//Product.h#ifndef PRODUCT_H#define PRODUCT_Hclass AbstractProductA{public:    virtual ~AbstractProductA();protected:    AbstractProductA();private:};class AbstractProductB{public:    virtual ~AbstractProductB();protected:    AbstractProductB();private:};class ProductA1:public AbstractProductA{public:    ProductA1();    ~ProductA1();};class ProductA2:public AbstractProductA{public:    ProductA2();    ~ProductA2();};class ProductB1:public AbstractProductB{public:    ProductB1();    ~ProductB1();};class ProductB2:public AbstractProductB{public:    ProductB2();    ~ProductB2();};#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_Hclass AbstractProductA;class AbstractProductB;class AbstractFactory{public:    virtual ~AbstractFactory();    virtual AbstractProductA* CreateProductA()=0;    virtual AbstractProductB* CreateProductB()=0;protected:    AbstractFactory();};class ConcreteFactory1:public AbstractFactory{public:    ConcreteFactory1();    ~ConcreteFactory1();    AbstractProductA* CreateProductA();    AbstractProductB* CreateProductB();};class ConcreteFactory2:public AbstractFactory{public:    ConcreteFactory2();    ~ConcreteFactory2();    AbstractProductA* CreateProductA();    AbstractProductB* CreateProductB();};#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();    system("pause");    return 0;}