C++设计模式核心板Word文档格式.docx
《C++设计模式核心板Word文档格式.docx》由会员分享，可在线阅读，更多相关《C++设计模式核心板Word文档格式.docx（20页珍藏版）》请在冰豆网上搜索。
客户端代码：
usingnamespaceDesignPattern_Adapter;
Target*p=newAdapter（）;
p->
Request（）;
//实际上调用的是Adaptee:
:
SpecialRequest（）
}
（2）objectadapternamespaceDesignPattern_Adapter
publicTarget
virtualvoidRequest（）{_adaptee.SpecialRequest（）;
private:
Adaptee_adaptee;
六、实例
（1）STL中的ClassAdapter
STL中的AdapterClass包括：
a.stack（对应的adaptee是deque）。
b.queue（对应的adaptee是deque）。
c.priority_queue（对应的adaptee是vector）。
下面是从VC中的<
stack>
拷出的stack的类定义：
templateclass_Container=deque<
_Ty>
>
classstack
{//LIFOqueueimplementedwithacontainer
typedef_Containercontainer_type;
typedeftypename_Container:
value_typevalue_type;
size_typesize_type;
stack（）
c（）
{//constructwithemptycontainer
explicitstack（const_Container&
_Cont）
c（_Cont）
{//constructbycopyingspecifiedcontainer
boolempty（）const
{//testifstackisempty
return（c.empty（））;
size_typesize（）const
{//testlengthofstack
return（c.size（））;
value_type&
top（）
{//returnlastelementofmutablestack
return（c.back（））;
constvalue_type&
top（）const
{//returnlastelementofnonmutablestack
voidpush（constvalue_type&
_Val）
{//insertelementatend
c.push_back（_Val）;
voidpop（）
{//eraselastelement
c.pop_back（）;
bool_Eq（conststack<
_Ty,_Container>
&
_Right）const
{//testforstackequality
return（c==_Right.c）;
bool_Lt（conststack<
{//testifthis<
_Rightforstacks
return（c<
_Right.c）;
protected:
_Containerc;
//theunderlyingcontainer
};
关键之处在于_Containerc，stack所有的操作都转交给c去处理了。
（这实际上就是前面所说的"
objectadapter"
，注意STL中的classadapter与上面所说的classadapter概念不完全一致）
stack的使用方法很简单，如下：
intia[]={1,3,2,4};
dequeid（ia,ia+4）;
stackis（id）;
（2）近日看了一篇文章“Generic<
Programming>
：
简化异常安全代码”，原文出自View第5期"
。
文章绝对一流，作者给出的代码中也使用了Adaptor模式，也有一定代表性。
我将其问题一般化，概括出以下示例：
问题：
假设有几个已有类，他们有某些共同的行为，但它们彼此间是独立的（没有共同的基类）。
如：
classT1
voidProc（）{}
classT2
//...
如何以统一的方式去调用这些行为呢？
解决方法1：
很自然的会想到用模板，如：
template<
classT>
voidTest（Tt）
t.Proc（）;
}
的确不错，但这只适用于简单的情况，有时情况是很复杂的，比如我们无法把类型放到模板参数中！
解决方法2：
困难来自于这些类没有共同的基类，所以我们就创造一个基类，然后再Adapt。
//classIAdaptor，抽象基类
classIAdaptor
virtualvoidProc（）=0;
//classAdaptor
classAdaptor:
publicIAdaptor,privateT//实现继承
virtualvoidProc（）{T:
Proc（）;
//以统一方式调用函数Proc，而不关心是T1、T2或其他什么类
voidTest（conststd:
auto_ptr&
sp）
sp->
Test（std:
auto_ptr（newAdaptor））;
上例很简单，用方法一中的模板函数就可以很好地解决了。
下面是一个略微复杂一点的例子，根据参数类型来创建适当的对象：
T1（int）{/*...*/}
voidProc（）{/*...*/}
T2（char）{/*...*/}
virtualvoidProc（）=0;
template
Adaptor（intn）:
T（n）{}
Adaptor（charc）:
T（c）{}
virtualvoidProc（）{T:
classTest
Test（intn）:
sp（newAdaptor（n））{}
Test（charc）:
sp（newAdaptor（c））{}
voidProc（）{sp->
std:
auto_ptrsp;
Testt1（10）;
t1.Proc（）;
Testt2（'
c'
）;
t2.Proc（）;
上面是示例而非实例，你也许更愿意看看它实际的运用。
去下载作者所写的代码，好好欣赏一下吧。
C++设计模式之AbstractFactory
一、功能
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
二、结构图
类厂最基本的结构示意图如下：
在实际应用中，类厂模式可以扩充到很复杂的情况，如下图所示：
三、优缺点
优点：
（1）封装创建过程。
客户不用知道类厂是如何创建类实例的，类厂封闭了所有创建的细节。
这样可选择不同的创建方法，增加了灵活性。
（2）将客户与具体类隔离，提高了各自的可重用性。
缺点：
Factory类层次与具体类层次通常是平行的（即一一对应的）。
增加一个具体类，一般也要相应地增加一个factory类，增加了系统复杂度。
四、实现
（1）AbstractFactory类中通常是一组FactoryMethod的集合。
个人认为与FactoryMethod模式没有本质区别。
（2）通常可以把工厂作为单件。
五、示例代码
namespaceDesignPattern_AbstractFactory
classAbstractProductA{};
//ProductA
classProductA1:
publicAbstractProductA{};
classProductA2:
classAbstractProductB{};
//ProductB
classProductB1:
publicAbstractProductB{};
classProductB2:
classAbstractFactory
{
public:
virtualAbstractProductA*CreateProductA（）=0;
//创建ProductA
virtualAbstractProductB*CreateProductB（）=0;
//创建ProductB
classConcreteFactory1:
publicAbstractFactory
virtualAbstractProductA*CreateProductA（）{returnnewProductA1（）;
virtualAbstractProductB*CreateProductB（）{returnnewProductB1（）;
staticConcreteFactory1*Instance（）{staticConcreteFactory1instance;
return&
instance;
}
ConcreteFactory1（）{}
private:
ConcreteFactory1（constConcreteFactory1&
ConcreteFactory1&
operator=（constConcreteFactory1&
};
classConcreteFactory2:
virtualAbstractProductA*CreateProductA（）{returnnewProductA2（）;
virtualAbstractProductB*CreateProductB（）{returnnewProductB2（）;
staticConcreteFactory2*Instance（）{staticConcreteFactory2instance;
}
protected:
ConcreteFactory2（）{}
ConcreteFactory2（constConcreteFactory2&
ConcreteFactory2&
operator=（constConcreteFactory2&
usingnamespaceDesignPattern_AbstractFactory;
//第一种创建方法
AbstractFactory*pFactory=ConcreteFactory1:
Instance（）;
AbstractProductA*pProductA=pFactory->
CreateProductA（）;
AbstractProductB*pProductB=pFactory->
CreateProductB（）;
//第二种创建方法
pFactory=ConcreteFactory2:
pProductA=pFactory->
pProductB=pFactory->
最早知道类厂的概念是在COM中，但当时也没想到这是如此重要的一种模式，在许多其他模式中都可以用到类厂模式。
COM中不能直接创建组件，这也是由COM的一个特性决定的：
即客户不知道要创建的组件的类名。
C++设计模式之Singleton
一、功能
保证一个类仅有一个实例。
Singleton模式是做为"
全局变量"
的替代品出现的。
所以它具有全局变量的特点：
全局可见、贯穿应用程序的整个生命期，它也具有全局变量不具备的性质：
同类型的对象实例只可能有一个。
教科书上的Singleton定义如下：
classSingleton
staticSingleton*Instance（）;
Singleton（）{}
staticSingleton*_instance;
Singleton（constSingleton&
Singleton&
operator=（constSingleton&
Singleton*Singleton:
_instance=NULL;
Instance（）
（_instance==NULL）?
_instance=newSingleton（）:
0;
//lazyinitialization
return_instance;
（1）因为返回的是指针，为防止用户调用delete函数，可把staticSingleton*_instance；
改为在Instance（）中定义staticSingleton_instance。
这样显然更安全，同时也具有lazyinitialization的特性（即第一次访问时才创建）。
（2）假设需要从Singleton派生子类，而子类也需要有同样的性质，既只能创建一个实例。
我觉得，这很难办。
根本原因在于Instance（）函数不是虚函数，不具有多态的性质。
一种常用方法是把Instance（）函数移到子类中，这时就只能用staticSingleton*_instance，而不能用staticSingleton_instance了，除非把_instance也要移到子类，无论怎么做都不优雅。
另一种方法是用模板。
具体用什么方法，只能根据实际情况权衡。
（1）没子类的情况
namespaceDesignPattern_Singleton
staticSingleton*Instance（）{staticSingleton_instance;
return&
_instance;
usingnamespaceDesignPattern_Singleton;
Singleton*p=Singleton:
......
（2）有子类的情况
方法一：
//classSingleton
//classConcreteSingleton
classConcreteSingleton:
publicSingleton
ConcreteSingleton（）{}
Singleton*ConcreteSingleton:
_instance=newConcreteSingleton（）:
Singleton*p=ConcreteSingleton:
方法二：
staticSingleton*Instance（）{staticConcreteSingleton_instance;
方法三：
template<
classT>
staticT*Instance（）{staticT_instance;
Singleton（constSingleton&
publicSingleton<
ConcreteSingleton>
{};
客
升级会员 