最简单的抽象工厂模式

建议：先看工厂方法模式
价值：有一系列工厂方法可以加工不同的商品。
具体解释：在某个类(AbstractFactory)有一系列工厂方法（CreateProductA/CreateProductB）。
该系列函数有如下2个要点：
1.该函数可多态（即：包含该函数的类是多态的）
2.该函数的返回值是多态的（Product）
如下c++代码实现
#include
using namespace std;

//抽象层
class AbstractProduct{
public:
virtual void function(){}
};
class AbstractProductA: public AbstractProduct
{
public:
virtual void function(){}
};
class AbstractProductB: public AbstractProduct
{
public:
virtual void function(){}
};
class AbstractFactory
{
public:
void AnOperation()
{
//其他逻辑。。。
AbstractProductA* pa = CreateProductA();
pa->function();
AbstractProductB* pb = CreateProductB();
pb->function();
//其他逻辑
}
virtual AbstractProductA* CreateProductA(){return 0;}
virtual AbstractProductB* CreateProductB(){return 0;}
};
//具体层
class ProductA1: public AbstractProductA
{
public:
virtual void function(){
cout<<“ProductA1:机能运行”<<"\n";
}
};
class ProductA2: public AbstractProductA
{
public:
virtual void function(){
cout<<“ProductA2:机能运行”<<"\n";
}
};
class ProductB1:public AbstractProductB
{
public:
virtual void function(){
cout<<“ProductB1:机能运行”<<"\n";
}
};
class ProductB2:public AbstractProductB
{
public:
virtual void function(){
cout<<“ProductB2:机能运行”<<"\n";
}
};
class ConcreteFactory1: public AbstractFactory
{
public:
AbstractProductA* CreateProductA()
{
return new ProductA1();
}
AbstractProductB* CreateProductB()
{
return new ProductB1();;
}
};
class ConcreteFactory2: public AbstractFactory
{
public:
AbstractProductA* CreateProductA()
{
return new ProductA2();
}
AbstractProductB* CreateProductB()
{
return new ProductB2();;
}
};

//客户端调用
int main()
{
ConcreteFactory1* f1 = new ConcreteFactory1();
f1->AnOperation();
ConcreteFactory2* f2 = new ConcreteFactory2();
f2->AnOperation();

//看代码不用考虑以下内容
int cin_a;
cin>>cin_a;
return 0;

}