设计模式之简单工厂模式与工厂模式
1.简单工厂模式：
简单工厂模式使用简单，缺点时每次工厂要生产的品种增加时，都要重改工厂类，违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。看例子分析
//抽象产品借口
IProduct
{
public:
void show(){}=0;
}
//具体产品A
AProduct:public IProduct
{
public:
void show(){
cout<<"AProduct"<<endl; }
//具体产品B
BProduct:public IProduct
{
public:
void show(){
cout<<"BProduct"<<endl; }
Factory
{
public:
IProduct *CreateProduct(int Type){
switch(Type)
{
case 1:
{ return new AProduct(); }
case 2:
{ return new BProduct(); }
}
}
}
//Client; 使用者
void main()
{
//需要产品A
Factory *pFactory=new Factory();
IProduct*pProduct=pFactory->CreateProduct(1);
pProduct->show();
//需要产品B
Factory *pFactory2=new Factory();
IProduct*pProduct2=pFactory2->CreateProduct(2);
pProduct2->show();
}//缺点： 当有一个新产品CProdcut要生产时，需要修改Factory的代码case语句要增加，客户端main不需要修改；为了解决这个问题 可以通过工厂模式解决(使一个类的实例化延迟到子类)，代码如下：
2.工厂模式//产品方面不用变化，只需增加CProduct
CProduct:public IProduct{
public:
void show(){
cout<<"AProduct"<<endl; }
}
//为了延迟实例化到子类，需要增加抽象工厂类
IFactory
{
public:
IProduct *CreateProduct()=0; }
//具体工厂类A，专门负责生产A产品
AFactory:public IFactory{
public:
IProduct *CreateProduct() {
return new AProduct() ; }
}
//具体工厂类B，专门负责生产B产品
BFactory:public IFactory {
public:
IProduct *CreateProduct() {
return new BProduct() ; }
}//Client
void main()
{
//需要生产产品A
IFactory *pFactory1=new AFactory();
IProduct *pProduct1=pFactory1->CreateProduct();
pProduct1->show();
//需要生产产品B
IFactory *pFactory2=new BFactory();
IProduct *pProduct2=pFactory2->CreateProduct();
pProduct2->show();
}//当扩大规模时，需要生产C时，代码不需要更改，只需增加相应的类就行了；
//具体工厂类C，专门负责生产C产品
CFactory:public IFactory {
public:
IProduct *CreateProduct() {
return new CProduct() ; }
}//Client
void main()
{
//需要生产产品A
IFactory *pFactory1=new AFactory();
IProduct *pProduct1=pFactory1->CreateProduct();
pProduct1->show();
//需要生产产品B
IFactory *pFactory2=new BFactory();
IProduct *pProduct2=pFactory2->CreateProduct();
pProduct2->show();
//需要生产产品C
IFactory *pFactory3=new CFactory();
IProduct *pProduct3=pFactory3->CreateProduct();
pProduct3->show();
}//可以看到，以前的代码并不需要做任何修改，只需要不断的增加相应的类就行了，而简单工厂模式就需要修改工厂代码，不利于代码的维护，但这样却增加了类的数量，各有利弊
