设计模式工厂模式和单件模式.docx
- 文档编号:5595388
- 上传时间:2023-05-08
- 格式:DOCX
- 页数:19
- 大小:90.05KB
设计模式工厂模式和单件模式.docx
《设计模式工厂模式和单件模式.docx》由会员分享,可在线阅读,更多相关《设计模式工厂模式和单件模式.docx(19页珍藏版)》请在冰点文库上搜索。
设计模式工厂模式和单件模式
工厂模式和单件模式
1.1Factory模式
(一)应用背景
我们经常抽象出一些类的公共接口以形成抽象基类或者接口,这样就可以通过声明一个指向基类的指针来指向实际的子类实现,达到了多态的目的。
(二)存在问题
N多的子类继承抽象基类,不得不在每次要用到子类的地方就编写诸如newXXX的代码,此外必须知道实际子类的名字,在复杂系统中简直不可能,维护和扩展也很困难。
另外,在父类中并不知道具体要实例化哪一个具体的子类。
(三)程序举例
#ifndef_PRODUCT_H
#define_PRODUCT_H
/************************************************************************/
/*Product*/
/************************************************************************/
classProduct
{
public:
Product();
virtual~Product();
virtualvoidoperation();
};
/************************************************************************/
/*ConcreteProductA*/
/************************************************************************/
classConcreteProductA:
publicProduct
{
public:
ConcreteProductA();
virtual~ConcreteProductA();
virtualvoidoperation();
};
/************************************************************************/
/*ConcreteProductB*/
/************************************************************************/
classConcreteProductB:
publicProduct
{
public:
ConcreteProductB();
virtual~ConcreteProductB();
virtualvoidoperation();
};
/************************************************************************/
/*ConcreteProductC*/
/************************************************************************/
classConcreteProductC:
publicProduct
{
public:
ConcreteProductC();
virtual~ConcreteProductC();
virtualvoidoperation();
};
#endif
#include"product.h"
#include"stdio.h"
/************************************************************************/
/*Product*/
/************************************************************************/
Product:
:
Product()
{
}
Product:
:
~Product()
{
}
voidProduct:
:
operation()
{
printf("Productoperation...\n");
}
/************************************************************************/
/*ConcreteProductA*/
/************************************************************************/
ConcreteProductA:
:
ConcreteProductA()
{
}
ConcreteProductA:
:
~ConcreteProductA()
{
}
voidConcreteProductA:
:
operation()
{
printf("ConcreteProductAoperation...\n");
}
/************************************************************************/
/*ConcreteProductB*/
/************************************************************************/
ConcreteProductB:
:
ConcreteProductB()
{
}
ConcreteProductB:
:
~ConcreteProductB()
{
}
voidConcreteProductB:
:
operation()
{
printf("ConcreteProductBoperation...\n");
}
/************************************************************************/
/*ConcreteProductC*/
/************************************************************************/
ConcreteProductC:
:
ConcreteProductC()
{
}
ConcreteProductC:
:
~ConcreteProductC()
{
}
voidConcreteProductC:
:
operation()
{
printf("ConcreteProductCoperation...\n");
}
#include"product.h"
#include"stdio.h"
voidmain()
{
Product*pProduct=NULL;
pProduct=newConcreteProductA();
pProduct->operation();
pProduct=newConcreteProductB();
pProduct->operation();
pProduct=newConcreteProductC();
pProduct->operation();
printf("\n");
}
程序结果:
(四)工厂模式
Factory模式结构示意图
1、封装产品的创建过程:
用工厂来创建产品
2、将创建过程放到子类中:
用具体工厂来创建产品
#ifndef_PRODUCT_H
#define_PRODUCT_H
/************************************************************************/
/*Product*/
/************************************************************************/
classProduct
{
public:
Product();
virtual~Product();
virtualvoidoperation();
};
/************************************************************************/
/*ConcreteProductA*/
/************************************************************************/
classConcreteProductA:
publicProduct
{
public:
ConcreteProductA();
virtual~ConcreteProductA();
virtualvoidoperation();
};
/************************************************************************/
/*ConcreteProductB*/
/************************************************************************/
classConcreteProductB:
publicProduct
{
public:
ConcreteProductB();
virtual~ConcreteProductB();
virtualvoidoperation();
};
/************************************************************************/
/*ConcreteProductC*/
/************************************************************************/
classConcreteProductC:
publicProduct
{
public:
ConcreteProductC();
virtual~ConcreteProductC();
virtualvoidoperation();
};
#endif
#include"product.h"
#include"stdio.h"
/************************************************************************/
/*Product*/
/************************************************************************/
Product:
:
Product()
{
}
Product:
:
~Product()
{
}
voidProduct:
:
operation()
{
printf("Productoperation...\n");
}
/************************************************************************/
/*ConcreteProductA*/
/************************************************************************/
ConcreteProductA:
:
ConcreteProductA()
{
}
ConcreteProductA:
:
~ConcreteProductA()
{
}
voidConcreteProductA:
:
operation()
{
printf("ConcreteProductAoperation...\n");
}
/************************************************************************/
/*ConcreteProductB*/
/************************************************************************/
ConcreteProductB:
:
ConcreteProductB()
{
}
ConcreteProductB:
:
~ConcreteProductB()
{
}
voidConcreteProductB:
:
operation()
{
printf("ConcreteProductBoperation...\n");
}
/************************************************************************/
/*ConcreteProductC*/
/************************************************************************/
ConcreteProductC:
:
ConcreteProductC()
{
}
ConcreteProductC:
:
~ConcreteProductC()
{
}
voidConcreteProductC:
:
operation()
{
printf("ConcreteProductCoperation...\n");
}
#ifndef_FACTORY_H
#define_FACTORY_H
classProduct;
/************************************************************************/
/*Product抽象基类有很多个子类,创建这些子类时我们很难知道子类的名字,*/
/*因此用工厂类将这些具体产品子类的创建封装起来。
但如果工厂类也是基类*/
/*那么它就不知道要封装哪个产品的创建过程了。
因此创建具体产品的过程要下*/
/*放到工厂类的子类中。
*/
/************************************************************************/
classFactory
{
public:
virtual~Factory()=0;/*基类析构函数必须为虚函数*/
virtualProduct*CreateProduct()=0;/*纯虚函数只作为接口,不能有实例*/
protected:
Factory();
};
/************************************************************************/
/*ConcreteFactoryA*/
/************************************************************************/
classConcreteFactoryA:
publicFactory
{
public:
ConcreteFactoryA();
~ConcreteFactoryA();
Product*CreateProduct();
};
/************************************************************************/
/*ConcreteFactoryB*/
/************************************************************************/
classConcreteFactoryB:
publicFactory
{
public:
ConcreteFactoryB();
~ConcreteFactoryB();
Product*CreateProduct();
};
/************************************************************************/
/*ConcreteFactoryC*/
/************************************************************************/
classConcreteFactoryC:
publicFactory
{
public:
ConcreteFactoryC();
~ConcreteFactoryC();
Product*CreateProduct();
};
#endif
#include"factory.h"
#include"product.h"
#include"stdio.h"
Factory:
:
Factory()
{
}
Factory:
:
~Factory()
{
}
/************************************************************************/
/*ConcreteFactoryA*/
/************************************************************************/
ConcreteFactoryA:
:
ConcreteFactoryA()
{
printf("ConcreteFactoryA...\n");
}
ConcreteFactoryA:
:
~ConcreteFactoryA()
{
}
Product*ConcreteFactoryA:
:
CreateProduct()
{
returnnewConcreteProductA();
}
/************************************************************************/
/*ConcreteFactoryB*/
/************************************************************************/
ConcreteFactoryB:
:
ConcreteFactoryB()
{
printf("ConcreteFactoryB...\n");
}
ConcreteFactoryB:
:
~ConcreteFactoryB()
{
}
Product*ConcreteFactoryB:
:
CreateProduct()
{
returnnewConcreteProductB();
}
/************************************************************************/
/*ConcreteFactoryC*/
/************************************************************************/
ConcreteFactoryC:
:
ConcreteFactoryC()
{
printf("ConcreteFactoryC...\n");
}
ConcreteFactoryC:
:
~ConcreteFactoryC()
{
}
Product*ConcreteFactoryC:
:
CreateProduct()
{
returnnewConcreteProductC();
}
#include"product.h"
#include"factory.h"
#include"stdio.h"
voidmain()
{
Factory*pFac=NULL;
Product*pPro=NULL;
pFac=newConcreteFactoryA();
pPro=pFac->CreateProduct();
pPro->operation();
pFac=newConcreteFactoryB();
pPro=pFac->CreateProduct();
pPro->operation();
pFac=newConcreteFactoryC();
pPro=pFac->CreateProduct();
pPro->operation();
printf("\n");
}
1.2Singleton模式
(一)应用背景
需要创建一个唯一的变量(对象)
(二)Singleton模式
Singleton结构示意图
通过维护一个static的成员变量来记录这个唯一的对象实例。
通过提供一个static的接口instance来获得这个唯一的实例。
#ifndef_SINGLETON_H_
#define_SINGLETON_H_
classSingleton
{
public:
staticSingleton*Instance();
protected:
Singleton();
private:
staticSingleton*_instance;
};
#endif
#include"singleton.h"
#include"stdio.h"
Singleton*Singleton:
:
_instance=0;
Singleton:
:
Singleton()
{
printf("Singleton...\n");
}
Singleton*Singleton:
:
Instance()
{
if(_instance==0)
{
_instance=newSingleton();
}
return_instance;
}
#include"singleton.h"
#include"stdio.h"
voidmain()
{
Singleton*pSgt=Singleton:
:
Instance();
Singleton*pSgt1=Singleton:
:
Instance();
printf("\n");
}
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 设计模式 工厂模式和单件模式 设计 模式 工厂