观察者模�?设计模式

厚积薄发 — Fri, 29 Apr 2011 08:59:00 GMT

转自http://www.shnenglu.com/unixfy/archive/2011/04/26/145077.html

Part of the red marker to add by YeHao�Q�Order oneself to better understand.

观察者模�?设计模式

来自于《大话设计模式�?br>观察者模式：定义了一�U�一对多的依赖关�p�，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生时�Q�会通知所有观察者对象，使他们自动更新自己�?br>
行�ؓ型模式�?br>
UML �c�d��Q?br>
代码实现 C++�Q?br>

  1 #include <iostream>
  2 #include <string>
  3 #include <list>
  4 #include <algorithm>
  5 using namespace std;
  6
  7 class Subject;
  8
  9 class Observer   //观察�?/span>
10 {
11 protected:
12     string name;
13     Subject* sub;
14 public:
15     Observer(const string& n, Subject* s) : name(n), sub(s) {}
16     virtual void Update() = 0;
17 };
18
19 class Subject   //被观察�?br> 20 {
21 protected:
22     list<Observer*> observers;
23     string action;
24 public:
25     virtual void Attach(Observer* ob) = 0;   //增加观察者对�?br> 26     virtual void Detach(Observer* ob) = 0;   //�U�除观察者对�?br> 27     virtual void Notify() = 0;
28     virtual void setAction(const string& s) = 0;
29     virtual string getAction() = 0;
30 };
31
32 class StockObserver : public Observer
33 {
34 public:
35     StockObserver(const string& name, Subject* s) : Observer(name, s) {}
36     virtual void Update()
37     {
38         cout << sub->getAction() << '\t' << name << " 关闭股票行情�Q��l�工作！" << endl;
39     }
40 };
41
42 class NBAObserver : public Observer
43 {
44 public:
45     NBAObserver(const string& name, Subject* s) : Observer(name, s) {}
46     virtual void Update()
47     {
48         cout << sub->getAction() << '\t' << name << " 关闭 NBA�Q��l�工作！" << endl;
49     }
50 };
51
52 class Boss : public Subject
53 {
54 //private:
55 //    list observers;
56 //    string action;
57 public:
58     virtual void Attach(Observer* ob)
59     {
60         observers.push_back(ob);
61     }
62     virtual void Detach(Observer* ob)
63     {
64         list<Observer*>::iterator iter= find(observers.begin(), observers.end(), ob);
65         if (iter != observers.end())
66         {
67             observers.erase(iter);
68         }
69     }
70     virtual void Notify()
71     {
72         for (list<Observer*>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
73         {
74             (*iter)->Update();
75         }
76     }
77     virtual void setAction(const string& s)
78     {
79         action = s;
80     }
81     virtual string getAction()
82     {
83         return action;
84     }
85 };
86
87 class Secretary : public Subject
88 {
89 //private:
90 //    list observers;
91 //    string action;
92 public:
93     virtual void Attach(Observer* ob)
94     {
95         observers.push_back(ob);
96     }
97     virtual void Detach(Observer* ob)
98     {
99         list<Observer*>::iterator iter = find(observers.begin(), observers.end(), ob);
100         if (iter != observers.end())
101         {
102             observers.erase(iter);
103         }
104     }
105     virtual void Notify()
106     {
107         for (list<Observer*>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
108         {
109             (*iter)->Update();
110         }
111     }
112     virtual void setAction(const string& s)
113     {
114         action = s;
115     }
116     virtual string getAction()
117     {
118         return action;
119     }
120 };
121
122
123
124 int main()
125 {
126     Boss* huhansan = new Boss;
127     StockObserver* so = new StockObserver("abc", huhansan);
128     NBAObserver*   no = new NBAObserver("xyz", huhansan);
129
130     huhansan->Attach(so);
131     huhansan->Attach(no);
132     huhansan->setAction("我胡汉三又回来了�Q?/span>");
133     huhansan->Notify();
134
135     huhansan->Detach(no);
136     huhansan->setAction("开会！");
137     huhansan->Notify();
138
139     delete huhansan;
140
141     Secretary* s = new Secretary;
142     s->Attach(no);
143     s->Attach(so);
144     s->setAction("老板来了�Q?/span>");
145     cout << s->getAction() << endl;
146     s->Notify();
147
148     delete so;
149     delete no;
150     delete s;
151
152     return 0;
153 }

厚积薄发 2011-04-29 16:59 发表评论

C++设计模式(转蝲)

厚积薄发 — Wed, 13 Apr 2011 09:47:00 GMT

本文来自CSDN博客�Q��{载请标明出处�Q?/span>http://blog.csdn.net/i_like_cpp/archive/2004/11/29/197760.aspx

一、功�?/strong>

　　��一个类的接口�{换成客户希望的另外一个接口，解决两个已有接口之间不匹配的问题。Adapter模式使得原本�׃��接口不兼容而不能一起工作的那些�c�d��以一起工作�?

　　二、结构图

　　(1)class adapter

　　(2)object adapter

三、实�?/p>
　　和其他很多模式一��P��学习设计模式的重�Ҏ��学习每种模式的思想�Q�而不应拘泥于它的某种具体�l�构囑֒�实现。因为模式是灉|��的，其实现可以是千变万化的，只是所谓万变不��d��宗�?在STL中大量运用了Adapter模式�Q�象function adapter、iterator adpter�Q�它们与�q�里说的adapter�l�构�q�不一��P��但思想是一��L��。具体的介绍可到侯捷�|�站上找相关文章�Q�他讲得非常好�?
　　四、示例代�?/p>
　　(1)class adapter

namespace DesignPattern_Adapter
{
// class Adaptee
class Adaptee
{
public:
void SpecialRequest() {}
} ;

// class Target
class Target
{
public:
virtual void Request() = 0 ;
} ;

// class Adapter
class Adapter : public Target, private Adaptee
{
public:
virtual void Request() { SpecialRequest() ; }
} ;
}

客户端代码：
{
using namespace DesignPattern_Adapter ;
Target *p = new Adapter() ;
p->Request() ; //实际上调用的是Adaptee::SpecialRequest()
}

(2)object adapter namespace DesignPattern_Adapter

{
// class Adaptee
class Adaptee
{
public:
void SpecialRequest() {}
} ;

// class Target
class Target
{
public:
virtual void Request() = 0 ;
} ;

// class Adapter
class Adapter : public Target
{
public:
virtual void Request() { _adaptee.SpecialRequest() ; }
private:
Adaptee _adaptee ;
} ;
}

客户端代码：
{
using namespace DesignPattern_Adapter ;
Target *p = new Adapter() ;
p->Request() ; //实际上调用的是Adaptee::SpecialRequest()
}

　　六、实�?/p>
　　(1)STL中的Class Adapter

　　STL中的Adapter Class包括�Q�a.stack(对应的adaptee是deque)。b.queue(对应的adaptee是deque)。c.priority_queue(对应的adaptee是vector)�?下面是从VC中的< stack >拷出的stack的类定义�Q?

templateclass _Container = deque<_Ty> >
class stack
{ // LIFO queue implemented with a container
public:
typedef _Container container_type;
typedef typename _Container::value_type value_type;
typedef typename _Container::size_type size_type;

stack()
: c()
{ // construct with empty container
}

explicit stack(const _Container& _Cont)
: c(_Cont)
{ // construct by copying specified container
}

bool empty() const
{ // test if stack is empty
return (c.empty());
}

size_type size() const
{ // test length of stack
return (c.size());
}

value_type& top()
{ // return last element of mutable stack
return (c.back());
}

const value_type& top() const
{ // return last element of nonmutable stack
return (c.back());
}

void push(const value_type& _Val)
{ // insert element at end
c.push_back(_Val);
}

void pop()
{ // erase last element
c.pop_back();
}

bool _Eq(const stack<_Ty, _Container>& _Right) const
{ // test for stack equality
return (c == _Right.c);
}

bool _Lt(const stack<_Ty, _Container>& _Right) const
{ // test if this < _Right for stacks
return (c < _Right.c);
}

protected:
_Container c; // the underlying container
};

　　关键之处在于_Container c�Q�stack所有的操作都�{交给c��d��理了�?�q�实际上��是前面所说的"object adapter"�Q�注意STL中的class adapter与上面所说的class adapter概念不完全一�?
stack的��用方法很��单，如下�Q?

{
int ia[] = { 1,3,2,4 };
deque id(ia, ia+4);
stack is(id);
}

　　(2)�q�日看了一��文�?#8220;Generic< Programming >�Q�简化异常安全代�?#8221;�Q�原文出�?a C++ View�W?�?�?文章�l�对一��，作者给出的代码中也使用了Adaptor模式�Q�也有一定代表性。我��其问题一般化�Q�概括出以下�C�Z��Q?

　　问题�Q�假设有几个已有�c�，他们有某些共同的行�ؓ�Q�但它们彼此间是独立�?没有共同的基�c?。如�Q?

class T1
{
public:
void Proc() {}
} ;

class T2
{
public:
void Proc() {}
} ;

// ...

　　如何以统一的方式去调用�q�些行�ؓ呢？

　　解决�Ҏ��1�Q�很自然的会惛_��用模板，如：

template
void Test(T t)
{
t.Proc() ;
}

　　的确不错�Q�但�q�只适用于简单的情况�Q�有时情冉|��很复杂的�Q�比如我们无法把�c�d��攑ֈ�模板参数中！

　　解决�Ҏ��2�Q�困难来自于�q�些�c�L��有共同的基类�Q�所以我们就创造一个基�c�，然后再Adapt�?

// class IAdaptor�Q�抽象基�c?br>class IAdaptor
{
public:
virtual void Proc() = 0 ;
} ;
// class Adaptor
template
class Adaptor : public IAdaptor, private T //实现�l�承
{
public:
virtual void Proc() { T::Proc() ; }
} ;
// 以统一方式调用函数Proc�Q�而不兛_��是T1、T2或其他什么类
void Test(const std::auto_ptr& sp)
{
sp->Proc() ;
}
客户端代码：
Test(std::auto_ptr(new Adaptor)) ;
Test(std::auto_ptr(new Adaptor)) ;

　　上例很简单，用方法一中的模板函数��可以很好地解决了。下面是一个略微复杂一点的例子�Q�根据参数类型来创徏适当的对象：

class T1
{
public:
T1(int) { /*...*/ }
void Proc() { /*...*/ }
} ;

class T2
{
public:
T2(char) { /*...*/ }
void Proc() { /*...*/ }
} ;

// class IAdaptor�Q�抽象基�c?br>class IAdaptor
{
public:
virtual void Proc() = 0 ;
} ;

// class Adaptor
template
class Adaptor : public IAdaptor, private T //实现�l�承
{
public:
Adaptor(int n) : T(n) {}
Adaptor(char c) : T(c) {}
virtual void Proc() { T::Proc() ; }
} ;

class Test
{
public:
Test(int n) : sp(new Adaptor(n)) {}
Test(char c) : sp(new Adaptor(c)) {}

void Proc() { sp->Proc() ; }
private:
std::auto_ptr sp ;
} ;

客户端代码：
Test t1(10) ;
t1.Proc() ;

Test t2('c') ;
t2.Proc() ;

　　上面是示例而非实例�Q�你也许更愿意看看它实际的运用。去下蝲作者所写的代码�Q�好好欣赏一下吧�?br>

C++设计模式之Abstract Factory

2002-07-23· · ··COM集中�?br>

　　一、功�?/strong>
　　提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无需指定它们具体的类�?
　　二、结构图
　　�c�d��最基本的结构示意图如下�Q?

　　在实际应用中�Q�类厂模式可以扩充到很复杂的情况�Q�如下图所�C�：

三、优�~�点

　　优点�Q?1)��装创徏�q�程。客户不用知道类厂是如何创徏�c�d��例的�Q�类厂封闭了所有创建的�l�节。这样可选择不同的创建方法，增加了灵�z�L��?(2)��客户与具体�c�隔��，提高了各自的可重用性�?
　　�~�点�Q�Factory�c�d��ơ与具体�c�d��ơ通常是��^行的(即一一对应�?。增加一个具体类�Q�一般也要相应地增加一个factory�c�，增加了系�l�复杂度�?

　　四、实�?/p>
　　(1)Abstract Factory�c�M��通常是一�l�Factory Method的集合。个��Z��Factory Method模式没有本质区别�?

　　(2)通常可以把工厂作为单件�?
　　五、示例代�?/p>
namespace DesignPattern_AbstractFactory

{

　　class AbstractProductA {}; // Product A

　　class ProductA1 : public AbstractProductA {};

　　class ProductA2 : public AbstractProductA {};

　　class AbstractProductB {}; // Product B
　　class ProductB1 : public AbstractProductB {};
　　class ProductB2 : public AbstractProductB {};
　　class AbstractFactory
　　{
　　public:
　　　　virtual AbstractProductA* CreateProductA() = 0 ;// 创徏ProductA
　　　　virtual AbstractProductB* CreateProductB() = 0 ;// 创徏ProductB
} ;
　　class ConcreteFactory1 : public AbstractFactory
　　{
　　public:
　　　　virtual AbstractProductA* CreateProductA() { return new ProductA1() ; }
　　　　virtual AbstractProductB* CreateProductB() { return new ProductB1() ; }
　　　　static ConcreteFactory1* Instance() { static ConcreteFactory1 instance ; return &instance ; } 　　
protected:
　　　　ConcreteFactory1() {}
　　private:
　　　　ConcreteFactory1(const ConcreteFactory1&) ;
　　　　ConcreteFactory1& operator=(const ConcreteFactory1&) ;
　　} ;
　　class ConcreteFactory2 : public AbstractFactory
　　{
　　public:
　　　　virtual AbstractProductA* CreateProductA() { return new ProductA2() ; }
　　　　virtual AbstractProductB* CreateProductB() { return new ProductB2() ; }
　　　　static ConcreteFactory2* Instance() { static ConcreteFactory2 instance ; return &instance ; }
　　protected:
　　　　ConcreteFactory2() {}
　　private:
　　　　ConcreteFactory2(const ConcreteFactory2&) ;
　　　　ConcreteFactory2& operator=(const ConcreteFactory2&) ;
　　} ;
}

客户端代码：

{
　　using namespace DesignPattern_AbstractFactory ;
　　// �W�一�U�创建方�?/p>
　　AbstractFactory *pFactory = ConcreteFactory1::Instance() ;
　　AbstractProductA *pProductA = pFactory->CreateProductA() ;
　　AbstractProductB *pProductB = pFactory->CreateProductB() ;

　　// �W�二�U�创建方�?br>　　pFactory = ConcreteFactory2::Instance() ;
　　pProductA = pFactory->CreateProductA() ;
　　pProductB = pFactory->CreateProductB() ;
}

　　六、实�?/p>
　　最早知道类厂的概念是在COM中，但当时也没想到这是如此重要的一�U�模式，在许多其他模式中都可以用到类厂模式�?COM中不能直接创建组�Ӟ��q�也是由COM的一个特性决定的�Q�即客户不知道要创徏的组件的�c�d��?/p>

C++设计模式之Singleton

2002-07-26· · ··COM集中�?

　　一、功�?
　　保证一个类仅有一个实例�?

　　二、结构图

三、优�~�点

　　Singleton模式是做�?全局变量"的替代品出现的。所以它��h��全局变量的特点：全局可见、诏�I�应用程序的整个生命期，它也��h��全局变量不具备的性质�Q�同�c�d��的对象实例只可能有一个�?

　　四、实�?/p>
　　教科书上的Singleton定义如下�Q?

class Singleton
{
public:
static Singleton* Instance() ;
protected:
Singleton() {}
private:
static Singleton *_instance ;
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;

Singleton* Singleton::_instance = NULL ;

Singleton* Singleton::Instance()
{
(_instance == NULL) ? _instance = new Singleton() : 0 ; //lazy initialization
return _instance ;
}

　　(1)因�ؓ�q�回的是指针�Q��ؓ防止用户调用delete函数�Q�可把static Singleton *_instance�Q�改为在Instance()中定义static Singleton _instance。这��h��然更安全�Q�同时也��h��lazy initialization的特�?即第一�ơ访问时才创�?�?

　　(2)假设需要从Singleton�z��子类�Q�而子�c�M��需要有同样的性质�Q�既只能创徏一个实例。我觉得�Q�这很难办。根本原因在于Instance()函数不是虚函敎ͼ�不具有多态的性质。一�U�常用方法是把Instance()函数�U�d��子类中，�q�时��只能用static Singleton *_instance�Q�而不能用static Singleton _instance了，除非把_instance也要�U�d��子类�Q�无论怎么做都不优雅。另一�U�方法是用模�ѝ��具体用什么方法，只能�Ҏ��实际情况权衡�?

　　五、示例代�?/p>
　　(1)没子�cȝ��情况

namespace DesignPattern_Singleton
{

class Singleton
{
public:
static Singleton* Instance() { static Singleton _instance ; return &_instance ; }
protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
}

客户端代码：
{
using namespace DesignPattern_Singleton ;
Singleton *p = Singleton::Instance() ;
......
}

　　(2)有子�cȝ��情况

�Ҏ��一�Q?br>namespace DesignPattern_Singleton
{
// class Singleton
class Singleton
{
protected:
Singleton() {}
static Singleton *_instance ;
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
Singleton* Singleton::_instance = NULL ;

// class ConcreteSingleton
class ConcreteSingleton : public Singleton
{
public:
static Singleton* Instance() ;
protected:
ConcreteSingleton() {}
} ;

Singleton* ConcreteSingleton::Instance()
{
(_instance == NULL) ? _instance = new ConcreteSingleton() : 0 ;
return _instance ;
}
}

客户端代码：
{
using namespace DesignPattern_Singleton ;
Singleton *p = ConcreteSingleton::Instance() ;
}

�Ҏ��二：
namespace DesignPattern_Singleton
{
// class Singleton
class Singleton
{
protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;

// class ConcreteSingleton
class ConcreteSingleton : public Singleton
{
public:
static Singleton* Instance() { static ConcreteSingleton _instance ; return &_instance ; }
protected:
ConcreteSingleton() {}
} ;
}

客户端代码：
{
using namespace DesignPattern_Singleton ;
Singleton *p = ConcreteSingleton::Instance() ;
}

�Ҏ��三：
namespace DesignPattern_Singleton
{
template < class T >
class Singleton
{
public:
static T* Instance() { static T _instance ; return &_instance ; }
protected:
Singleton() {}
private:
Singleton(const Singleton &) ;
Singleton& operator=(const Singleton&) ;
} ;

class ConcreteSingleton : public Singleton< ConcreteSingleton > {} ;
}

客户端代�?br>{
using namespace DesignPattern_Singleton ;

ConcreteSingleton *p = ConcreteSingleton::Instance() ;
}

C++模式开发之Bridge

2002-07-29· · ··COM集中�?

　　一、功�?/strong>
　　��抽象部分与它的实现部分分离�Q��它们都可以独立地变化�?
　　二、结构图

三、示例代�?
namespace DesignPattern_Bridge
{
// class Implementor
class Implementor
{
public:
virtual void OperationImp() = 0 ;
} ;

// class ConcreteImplementorA
class ConcreteImplementorA : public Implementor
{
public:
virtual void OperationImp() {}
} ;

// class ConcreteImplementorB
class ConcreteImplementorB : public Implementor
{
public:
virtual void OperationImp() {}
} ;

// class Abstraction
class Abstraction
{
public:
void Operation(Implementor* imp) { assert(imp) ; imp->OperationImp() ; }
} ;
}

客户端代码：
{
using namespace DesignPattern_Bridge ;

Abstraction obj ;
Implementor *impa = new ConcreteImplementorA() ;
Implementor *impb = new ConcreteImplementorB() ;
obj.Operation(impa) ; //�W�一�U�实现方�?br>obj.Operation(impb) ; //�W�二�U�实现方�?br>}

　　四、实�?/p>
　　(1)创徏可以在X Window System和IBM的Presentation Manager�pȝ��中都可以使用的窗口�?书上的例�?

Bridge的魅力在于抽象和实现之间是松散的关系�Q�它们之间可以进行随意组合。如上图中，��有IconWindow+XWindowImp、TransientWindow+XWindowImp、IconWindow+PMWindowImp、TransientWindow+PMWindowImp四种�l�合�?br>

C++模式设计之Builder

2002-07-30· · ··COM集中�?

　　一、功�?/strong>

　　��一个复杂对象的构徏与它的表�C�分��，使得同样的构��E�可�?strong>创徏不同的表�C?/strong>�?

　　二、结构图

各类之间的交互关�p�d��下图所�C�：

三、示例代�?

namespace DesignPattern_Builder
{
class Product1 { /*...*/ } ;
class Product2 { /*...*/ } ;

// class Builder
class Builder //抽象基类
{
public:
virtual void BuilderPartA() {} //提供�~�省实现
virtual void BuilderPartB() {}
virtual void BuilderPartC() {}
protected:
Builder() {}
} ;

// class ConcreteBuilder1
class ConcreteBuilder1 : public Builder //创徏Product1
{
public:
ConcreteBuilder1() : _product(NULL) {}

virtual void BuilderPartA() { /*...*/ }
virtual void BuilderPartB() { /*...*/ }
virtual void BuilderPartC() { /*...*/ }

virtual Product1* GetProduct1() { return _product ; } //�q�回创徏的Product1对象
private:
Product1 *_product ;
} ;

// class ConcreteBuilder2
class ConcreteBuilder2 : public Builder //创徏Product2
{
public:
ConcreteBuilder2() : _product(NULL) {}

virtual void BuilderPartA() { /*...*/ }
virtual void BuilderPartB() { /*...*/ }
virtual void BuilderPartC() { /*...*/ }

virtual Product2* GetProduct2() { return _product ; } //�q�回创徏的Product2对象
private:
Product2 *_product ;
} ;

// class Director
class Director
{
public:
//创徏对象(Director�q�不知道具体创徏出来的对象是什么样的，只有调用该函数的client知道)
void Construct(Builder *builder)
{
builder->BuilderPartA() ;
builder->BuilderPartB() ;
builder->BuilderPartC() ;
}
} ;
}

客户端代码：
{
using namespace DesignPattern_Builder ;

Director director ;

// 创徏�W�一�U�对�?br>ConcreteBuilder1 *pBuilder1 = new ConcreteBuilder1() ;
director.Construct(pBuilder1) ;
Product1 *product1 = pBuilder1->GetProduct1() ;

// 创徏�W�二�U�对�?br>ConcreteBuilder2 *pBuilder2 = new ConcreteBuilder2() ;
director.Construct(pBuilder2) ;
Product2 *product2 = pBuilder2->GetProduct2() ;
}

　　四、实�?/p>
　　(1)例子一。如下图所�C�：

上图的功能是是把一个RTF文�g转换为多�U�正文格式。RTFReader�q�行语法分析�Q�然后将所有的token串逐一转换。可见builder��是一步步地把各个部分�l�装��Z��个整体。它��闭了组装的�Ҏ��Q�组装出来的对象也大相径庭�?br>

C++设计模式之Prototype

2002-08-01· · ··COM集中�?

　　一、功�?/strong>

　　用原型实例指定创建对象的�U�类�Q��ƈ且通过拯���q�些原型创徏新的对象�?

　　二、结构图

三、优�~�点

　　优点�Q�复制自�w�。客户不知道需要对象的实际�c�d��Q�只需知道它的抽象基类卛_��?��x��l�承树的情况)

　　�~�点�Q�必��d��有一个对象实�?卛_��?才能clone�?

　　四、示例代�?/p>
namespace DesignPattern_Prototype
{
// class Prototype
class Prototype //抽象基类
{
public:
virtual Prototype* Clone() = 0 ;
} ;

// class ConcretePrototype1
class ConcretePrototype1 : public Prototype
{
public:
virtual Prototype* Clone()
{
ConcretePrototype1 *p = new ConcretePrototype1() ;
*p = *this ; //复制对象
return p ;
}
} ;

// class ConcretePrototype2
class ConcretePrototype2 : public Prototype
{
public:
virtual Prototype* Clone()
{
ConcretePrototype2 *p = new ConcretePrototype2() ;
*p = *this ; //复制对象
return p ;
}
} ;
}

客户端代码：
{
using namespace DesignPattern_Prototype ;

ConcretePrototype1 *obj1 = new ConcretePrototype1() ;//原型对象1
ConcretePrototype2 *obj2 = new ConcretePrototype2() ;//原型对象2

Prototype *newobj1 = obj1->Clone() ;//克隆对象1
Prototype *newobj2 = obj2->Clone() ;//克隆对象2

//使用复制出的对象newobj1和newobj2
}

　　五、实�?/p>
　在一个图形编辑器中，每一个图形元素，如线、圆、文字等都应该支持拷贝操作，即点中图形，按下Ctrl+C�Q�再按下Ctrl+V后就会复制一个新的图形。显然这是一�U�clone操作。所以在每个从Graphic�z��出的囑�Ş子类都应�q�用Prototype模式�Q�加上Clone操作�?br>

C++设计模式之Factory Method

2002-08-05· · ··COM集中�?

　　一、功�?/strong>

　　定义一个用于创建对象的接口�Q�让子类军_��实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类�?

　　二、结构图

三、实�?/p>
(1)在某些情况下�Q�比如仅仅�ؓ了创建适当的Product对象而派生新的Creator子类�Q��ƈ且创��Z��同Product的方法一致时�Q�可以考虑用模板代替��ѝ��如�Q?

class Creator
{
public:
virtual Product* CreateProduct() = 0 ;
};

template < class ConcreteProduct >
class ConcreteCreator: public Creator
{
public:
virtual Product* CreateProduct() { return new ConcreteProduct() ; }
};

　　模板与��承的本质区别之一是：模板�Q�行��Z��依赖于类型。��承：行�ؓ依赖于类型�?Effective C++ Item 41) 事实上，在很多模式中都存在着可以用模板代替��承的情况�Q�其�Ҏ��原因��在于子�cȝ��行�ؓ是一致的�?

　　四、示例代�?/p>
namespace DesignPattern_FactoryMethod
{
class Product { /*...*/ } ;
class ConcreteProduct : public Product { /*...*/ } ;

// class Creator
class Creator
{
public:
virtual Product* CreateProduct() = 0 ;
void Operate() ;
} ;

void Creator::Operate()
{
// ...
Product *p = CreateProduct() ;
// ...
}

// class ConcreteCreator
class ConcreteCreator : public Creator
{
public:
virtual Product* CreateProduct() { return new ConcreteProduct() ; }
} ;
}

客户端代码：
{
using namespace DesignPattern_FactoryMethod ;
ConcreteCreator p ;
p.Operate() ;
}

　　�q�里的CreateProduct其实也是一个Template Method�?

　　五、实�?/p>
　　Factory Method的运用太�q�泛了，它经常运用在其它模式中，其实例�D不胜数�?
(1)

MFC中的CDocument�c�d��包含了类��g��上图CApplication中的三个函数。这里的CreateDocument��是一个factory method�Q�因为它负责创徏一个文档对象�?

　　(2)

当一个类��它的一些职责委托给一个独立的�c�L��Q�就产生�?strong>�q��c�d��?/strong>。上图中Figure和Manipulator��是�q��c�d��ơ，Figure代表一些图形元素，如线、文字等�Q�Manipulator表示作用于这些图形元素的操作�Q�如拖拉、移动、选中�{�。如果这些操作所需要的状态信息�ƈ不需要保存在Figure中，那么把Figure和Manipulator分成两个�c�d��ơ是个好��L��。这里的CreateManipulator��是一个factory method�?br>

C++设计模式之Composite

2002-08-06· · ··COM集中�?

　　一、功�?/strong>
　　表示“部分-整体”关系�Q��ƈ使用户以一致的方式使用单个对象和组合对象�?
　　二、结构图

上图中，也可以做些扩展，�Ҏ��需要可以将Leaf和Composite做�ؓ抽象基类�Q�从中派生出子类来�?

　　三、优�~�点

　　优点�Q�对于Composite模式�Q�也�思h们一开始的注意力会集中在它是如何实现组合对象的。但Composite最重要之处在于用户�q�不兛_��是组合对象还是单个对象，用户��以�l�一的方式进行处理，所以基�c�d��是从单个对象和组合对象中提出的公共接口�?
　　�~�点�Q�Composite最大的问题在于不容易限制组合中的组件�?

　　四、实�?/p>
　　有时需要限制组合中的组�Ӟ��卛_��望一个Composite只能有某些特定的Leaf。这个问题我是用多��承和动态类型�{换来解决的。假如组合对象Composite1只能包含单个对象ConcreteLeaf1�Q�Composite2可以包含单个对象ConcreteLeaf1和ConcreteLeaf2。如下图所�C�：

上图中的�c�d��ơ比较多�Q��用了AbstractLeaf1和AbstractLeaf2�Q�但没��用AbstractComposite1和AbstractComposite2�Q�这个�ƈ不重要，也可以把AbstractLeaf1和AbstractLeaf2��L��Q�这个�ƈ不重要，可以�Ҏ��具体情况军_��要不要�?
��单的代码实现如下�Q?

namespace DesignPattern_Composite
{
class Component
{
public:
virtual void operation() = 0 ;
virtual void Add(Component*) {}
} ;

class AbstractComponent1 : virtual public Component {} ;

class AbstractLeaf1 : virtual public AbstractComponent1 {} ;

class Composite1 : public AbstractComponent1
{
public:
virtual void operation() { /* do operation */ }
virtual void Add(Component*) ;
} ;
void Composite1::Add(Component *p)
{
AbstractComponent1 *pc1 = dynamic_cast�Q�ABSTRACTCOMPONENT1*�Q?p) ;
if (pc1 == NULL) return ;
// do add operation
}

class AbstractComponent2 : virtual public Component {} ;

class AbstractLeaf2 : virtual public AbstractComponent2 {} ;

class Composite2 : public AbstractComponent2
{
public:
virtual void operation() { /* do operation */ }
virtual void Add(Component*) ;
} ;
void Composite2::Add(Component *p)
{
AbstractComponent2 *pc2 = dynamic_cast�Q�ABSTRACTCOMPONENT2*>(p) ;
if (pc2 == NULL) return ;
// do add operation
}

class ConcreteLeaf1 : public AbstractLeaf1
{
public:
virtual void operation() { /* do operation */ }
} ;

class ConcreteLeaf2 : public AbstractLeaf1, public AbstractLeaf2
{
public:
virtual void operation() { /* do operation */ }
} ;
}

客户端代码：
�?br>using namespace DesignPattern_Composite ;

Component *pc1 = new ConcreteLeaf1() ;
Component *pc2 = new ConcreteLeaf2() ;
Component *pc3 = new Composite1() ;
Component *pc4 = new Composite2() ;
pc3->Add(pc1) ; // ok
pc3->Add(pc2) ; // ok
pc3->Add(pc3) ; // ok
pc3->Add(pc4) ; // fail
pc4->Add(pc1) ; // fail
pc4->Add(pc2) ; // ok
pc4->Add(pc3) ; // fail
pc4->Add(pc4) ; // ok
}

　　有两炚w��要注意，一是因为用了多�l�承�Q�所以需要��用virtual inheritance。二是要用dynamic_cast来判断是否允许组合该�l��g�?/p>
　　五、示例代�?/p>
namespace DesignPattern_Composite
{
// class Component
class Component
{
public:
virtual void Operation() = 0 ;
virtual void Add(Component*) {}
} ;

// class Leaf
class Leaf : public Component
{
public:
virtual void Operation() {}
} ;

// class Composite
class Composite : public Component
{
public:
virtual void Add(Component *p) { _list.push_back(p) ; }
virtual void Operation()
{
vector< Component* >::const_iterator it ;
for (it = _list.begin(); it != _list.end(); it++)
(*it)->Operation() ;
}
private:
vector< Component* > _list ;
} ;
}

　　六、实�?/p>
　　(1)JUnit中就用的是Composite模式�?

厚积薄发 2011-04-13 17:47 发表评论

国产精品久久久久9999,久久久久久久女国产乱让韩 ,久久久久久久综合日本

观察者模�?设计模式

C++设计模式(转蝲)