《设计模式》实验指导书.doc

1、哈尔滨理工大学计算机学院实验教学中心设计模式实验 实验指导书3实验一 Factory模式与Abstract Factory模式3实验二 Adapter模式9实验三 Observer模式12实验四 Interpreter模式16实验指导书实验一 Factory模式与Abstract Factory模式实验目的1掌握Factory模式与Abstract Factory模式的意图及其代码实现。2了解两种模式的区别。实验内容用C+语言实现Factory模式与Abstract Factory模式。实验要点及说明1、Factory模式Factory模式的作用：定义一个用于创建对象的接口，让子类决定实例化哪

2、一个类。Factory Method使一个类的实例化延迟到其子类。UML 结构图：抽象基类：1)Product：创建出来的对象的抽象基类。2)Factory：创建对象的工厂方法的抽象基类。接口函数：1)Creator:FactoryMethod:纯虚函数,由派生类实现，创建出对应的Product。解析：在这个模式中,有两个抽象基类，一个是Product为创建出来的对象的抽象基类，一个是Factory是工厂的抽象基类，在互相协作的时候都是由相应的Factory派生类来生成Product的派生类，也就是说如果要新增一种Product那么也要对应的新增一个Factory，创建的过程委托给了这个Fac

3、tory，也就是说一个Factory和一个Product是一一对应的关系。备注：设计模式的演示图上把Factory类命名为Creator，下面的实现沿用了这个命名。演示实现：1)Factory.h#ifndef FACTORY_H#define FACTORY_Hclass Productpublic: Product()virtual Product();class ConcreateProduct : public Productpublic: ConcreateProduct();virtual ConcreateProduct();class Creatorpublic: Creato

4、r()virtual Creator()void AnOperation();protected:virtual Product* FactoryMethod() = 0;class ConcreateCreator : public Creatorpublic: ConcreateCreator();virtual ConcreateCreator();protected:virtual Product* FactoryMethod();#endif2)Factory.cpp#include Factory.h#include using namespace std;ConcreatePro

5、duct:ConcreateProduct() std:cout construction of ConcreateProductn;ConcreateProduct:ConcreateProduct() std:cout destruction of ConcreateProductn;void Creator:AnOperation() Product* p = FactoryMethod(); std:cout an operation of productn;ConcreateCreator:ConcreateCreator() std:cout construction of Con

6、createCreatorn;ConcreateCreator:ConcreateCreator() std:cout destruction of ConcreateCreatorn;Product* ConcreateCreator:FactoryMethod()return new ConcreateProduct();3)Main.cpp(测试代码)#include Factory.h#include int main(int argc,char* argv) Creator *p = new ConcreateCreator(); p-AnOperation(); delete p;

7、 system(pause);return 0;2、Abstract Factory模式作用：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。UML结构图：抽象基类：1) ProductA，ProductB：分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现。2) AbstractFactory：生产这一系列产品的一个抽象工厂，它的派生类是不同的实现。接口函数：AbstractFactory:CreateProductA和AbstractFactory:CreateProductB：分别是生产不同产品的不同的实现，由各个派生出来的抽象工厂实现之。解析：Abstra

8、ct Factory 模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂等等。抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现。显而易见的，如果有n种产品同时有m中不同的实现，那么根据乘法原理可知有n*m个Factory模式的使用。实现:1)AbstractFactory.h#ifndef ABSTRACTFACTORY_H#define ABSTRACTFACTORY_H/ 抽象基类 AbstractProductA,代表产品 A

9、的抽象class AbstractProductApublic: AbstractProductA() virtual AbstractProductA();/ 派生类 ConcreateProductA1,继承自 AbstractProductA,代表产品 A 的第一种实现class ConcreateProductA1 : public AbstractProductApublic: ConcreateProductA1();virtual ConcreateProductA1();/ 派生类 ConcreateProductA2,继承自 AbstractProductA,代表产品 A 的

10、第二种实现class ConcreateProductA2 : public AbstractProductApublic: ConcreateProductA2();virtual ConcreateProductA2();/ 抽象基类 AbstractProductB,代表产品 B 的抽象class AbstractProductBpublic: AbstractProductB() virtual AbstractProductB();/ 派生类 ConcreateProductB1,继承自 AbstractProductB,代表产品 B 的第一种实现class ConcreatePro

11、ductB1 : public AbstractProductBpublic: ConcreateProductB1();virtual ConcreateProductB1();/ 派生类 ConcreateProductB2,继承自 AbstractProductB,代表产品 B 的第二种实现class ConcreateProductB2 : public AbstractProductBpublic: ConcreateProductB2();virtual ConcreateProductB2();/ 抽象基类 AbstractFactory,工厂的抽象类,生产产品 A 和产品 Bc

12、lass AbstractFactorypublic: AbstractFactory()virtual AbstractFactory()virtual AbstractProductA* CreateProductA() = 0;virtual AbstractProductB* CreateProductB() = 0;/ 派生类 ConcreateFactory1,继承自 AbstractFactory/ 生产产品 A 和产品 B 的第一种实现class ConcreateFactory1 : public AbstractFactorypublic: ConcreateFactory

13、1();virtual ConcreateFactory1();virtual AbstractProductA* CreateProductA();virtual AbstractProductB* CreateProductB();/ 派生类 ConcreateFactory2,继承自 AbstractFactory/ 生产产品 A 和产品 B 的第二种实现class ConcreateFactory2 : public AbstractFactorypublic: ConcreateFactory2();virtual ConcreateFactory2();virtual Abstra

14、ctProductA* CreateProductA();virtual AbstractProductB* CreateProductB();#endif2)AbstractFactory.cpp#include #include AbstractFactory.hConcreateProductA1:ConcreateProductA1() std:cout construction of ConcreateProductA1n;ConcreateProductA1:ConcreateProductA1() std:cout destruction of ConcreateProductA

15、1n;ConcreateProductA2:ConcreateProductA2() std:cout construction of ConcreateProductA2n;ConcreateProductA2:ConcreateProductA2() std:cout destruction of ConcreateProductA2n;ConcreateProductB1:ConcreateProductB1() std:cout construction of ConcreateProductB1n;ConcreateProductB1:ConcreateProductB1() std

16、:cout destruction of ConcreateProductB1n;ConcreateProductB2:ConcreateProductB2() std:cout construction of ConcreateProductB2n;ConcreateProductB2:ConcreateProductB2() std:cout destruction of ConcreateProductB2n;ConcreateFactory1:ConcreateFactory1() std:cout construction of ConcreateFactory1n;Concreat

17、eFactory1:ConcreateFactory1() std:cout destruction of ConcreateFactory1n;AbstractProductA* ConcreateFactory1:CreateProductA()return new ConcreateProductA1();AbstractProductB* ConcreateFactory1:CreateProductB()return new ConcreateProductB1();ConcreateFactory2:ConcreateFactory2() std:cout construction

18、 of ConcreateFactory2n;ConcreateFactory2:ConcreateFactory2() std:cout destruction of ConcreateFactory2n;AbstractProductA* ConcreateFactory2:CreateProductA()return new ConcreateProductA2();AbstractProductB* ConcreateFactory2:CreateProductB()return new ConcreateProductB2();3)Main.cpp(测试代码)#include Abs

19、tractFactory.h#include int main()/ 生产产品 A 的第一种实现 ConcreateFactory1 *pFactory1 = new ConcreateFactory1; AbstractProductA *pProductA = pFactory1-CreateProductA();/ 生产产品 B 的第二种实现 ConcreateFactory2 *pFactory2 = new ConcreateFactory2; AbstractProductB *pProductB = pFactory2-CreateProductB(); delete pFact

20、ory1; delete pProductA; delete pFactory2; delete pProductB; system(pause);return 0;讨论AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory 模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现。实验二 Adapter模式实验目的掌握

21、Adapter模式的意图及其代码实现。实验内容用C+语言实现Adapter模式。实验要点及说明Adapter模式的作用：将一个类的接口转换成客户希望的另外一个接口。Adapt模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。UML示意图1)采用继承原有接口类的方式2)采用组合原有接口类的方式解析：Adapt 模式其实就是把完成同样的一个功能但是接口不能兼容的类桥接在一起使之可以在一起工作，这个模式使得复用旧的接口成为可能。实现：Adapt 模式有两种实现办法，一种是采用继承原有接口类的方法，一种是采用组合原有接口类的方法，这里采用的是第二种实现方法。1)Adapt.h#ifndef

22、 ADAPTER_H#define ADAPTER_H/ 需要被 Adapt 的类class Targetpublic: Target()virtual Target() virtual void Request() = 0;/ 与被 Adapt 对象提供不兼容接口的类class Adapteepublic: Adaptee() Adaptee()void SpecialRequest();/ 进行 Adapt 的类,采用聚合原有接口类的方式class Adapter : public Targetpublic: Adapter(Adaptee* pAdaptee);virtual Adapt

23、er();virtual void Request();private: Adaptee* m_pAdptee;#endif2)Adapt.cpp#include Adapter.h#include void Adaptee:SpecialRequest() std:cout SpecialRequest of Adapteen;Adapter:Adapter(Adaptee* pAdaptee) : m_pAdptee(pAdaptee)Adapter:Adapter() delete m_pAdptee; m_pAdptee = NULL;void Adapter:Request() st

24、d:cout SpecialRequest();3)Main.cpp#include Adapter.h#include int main() Adaptee *pAdaptee = new Adaptee; Target *pTarget = new Adapter(pAdaptee); pTarget-Request(); delete pTarget; system(pause);return 0;实验三 Observer模式实验目的掌握Observer模式的意图及其代码实现。实验内容用C+语言实现Observer模式。实验要点及说明Observer模式的作用：定义对象间的一种一对多的依

25、赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。UML 结构图：解析：Observer模式定义的是一种一对多的关系，这里的一就是图中的Subject类，而多则是Observer类。当Subject类的状态发生变化的时候通知与之对应的Observer类也去相应的更新状态，同时支持动态的添加和删除Observer对象的功能。Observer模式的实现要点是：第一，一般subject类都是采用链表等容器来存放Observer对象；第二抽取出Observer对象的一些公共的属性形成Observer基类，而Subject中保存的则是Observer类对象的指针，这样就使Su

26、bject和具体的Observer实现了解耦，也就是Subject不需要去关心到底是哪个Observer对放进了自己的容器中。生活中有很多例子可以看作是Observer模式的运用，比方说，一个班有一个班主任(Subject)，他管理手下的一帮学生(Observer)，当班里有一些事情发生需要通知学生的时候，班主任要做的不是逐个学生挨个的通知，而是把学生召集起来一起通知，实现了班主任和具体学生的关系解耦。实现：1)Observer.h#ifndef OBSERVER_H#define OBSERVER_H#include typedef int STATE;class Observer;/ Su

27、bject 抽象基类,只需要知道 Observer 基类的声明就可以了class Subjectpublic: Subject() : m_nSubjectState(-1)virtual Subject();void Notify(); / 通知对象改变状态void Attach(Observer *pObserver); / 新增对象void Detach(Observer *pObserver); / 删除对象 / 虚函数,提供默认的实现,派生类可以自己实现来覆盖基类的实现virtual void SetState(STATE nState); / 设置状态virtual STATE G

28、etState(); / 得到状态protected: STATE m_nSubjectState; / 模拟保存 Subject 状态的变量 std:list m_ListObserver; / 保存 Observer 指针的链表;/ Observer 抽象基类class Observerpublic: Observer() : m_nObserverState(-1)virtual Observer()/ 纯虚函数,各个派生类可能有不同的实现 / 通知 Observer 状态发生了变化virtual void Update(Subject* pSubject) = 0;protected:

29、 STATE m_nObserverState; / 模拟保存 Observer 状态的变量;/ ConcreateSubject 类,派生在 Subject 类class ConcreateSubject : public Subjectpublic: ConcreateSubject() : Subject()virtual ConcreateSubject()/ 派生类自己实现来覆盖基类的实现virtual void SetState(STATE nState); / 设置状态virtual STATE GetState(); / 得到状态;/ ConcreateObserver 类派生

30、自 Observerclass ConcreateObserver : public Observerpublic: ConcreateObserver() : Observer()virtual ConcreateObserver()/ 虚函数,实现基类提供的接口virtual void Update(Subject* pSubject);#endif2)Observer.cpp#include Observer.h#include #include / Subject 类成员函数的实现void Subject:Attach(Observer *pObserver) std:cout Att

31、ach an Observern; m_ListObserver.push_back(pObserver);void Subject:Detach(Observer *pObserver) std:list:iterator iter; iter = std:find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);if (m_ListObserver.end() != iter) m_ListObserver.erase(iter); std:cout Detach an Observern;void Subject:Noti

32、fy() std:cout Notify Observerss Staten; std:list:iterator iter1, iter2;for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end(); iter1 != iter2; +iter1) (*iter1)-Update(this); void Subject:SetState(STATE nState) std:cout SetState By Subjectn; m_nSubjectState = nState;STATE Subject:GetState(

33、) std:cout GetState By Subjectn;return m_nSubjectState;Subject:Subject() std:list:iterator iter1, iter2, temp;for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end(); iter1 != iter2; ) temp = iter1; +iter1; delete (*temp); m_ListObserver.clear();/ ConcreateSubject 类成员函数的实现void ConcreateSub

34、ject:SetState(STATE nState) std:cout SetState By ConcreateSubjectn; m_nSubjectState = nState;STATE ConcreateSubject:GetState() std:cout GetState(); std:cout The ObeserverState is m_nObserverState std:endl;3)Main.cpp#include Observer.h#include int main() Observer *p1 = new ConcreateObserver; Observer

35、 *p2 = new ConcreateObserver; Subject* p = new ConcreateSubject; p-Attach(p1); p-Attach(p2); p-SetState(4); p-Notify(); p-Detach(p1); p-SetState(10); p-Notify(); delete p; system(pause);return 0;实验四 Interpreter模式实验目的掌握Interpreter模式的意图及其代码实现。实验内容用C+语言实现Interpreter模式。实验要点及说明Interpreter模式的作用：给定一个语言，定义它

36、的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。Interpreter模式典型的结构图为：解析：Interpreter 模式中，提供了Terminal Expression和Nonterminal Expression两种表达式的解释方式，Context类用于为解释过程提供一些附加的信息（例如全局的信息）。实现：代码片断1：Context.h/Context.h#ifndef _CONTEXT_H_#define _CONTEXT_H_class Contextpublic: Context(); Context();protected:private:;#endi

37、f /_CONTEXT_H_代码片断2：Context.cpp/Context.cpp#include Context.hContext:Context()Context:Context() 代码片断3：Interpret.h/Interpret.h#ifndef _INTERPRET_H_#define _INTERPRET_H_#include Context.h#include using namespace std;class AbstractExpressionpublic: virtual AbstractExpression(); virtual void Interpret(c

38、onst Context& c);protected: AbstractExpression();private:;class TerminalExpression:public AbstractExpression public: TerminalExpression(const string& statement); TerminalExpression(); void Interpret(const Context& c);protected:private: string _statement;class NonterminalExpression:public AbstractExp

39、ressionpublic: NonterminalExpression(AbstractExpression* expression,int times); NonterminalExpression(); void Interpret(const Context& c);protected:private: AbstractExpression* _expression; int _times;#endif /_INTERPRET_H_代码片断4：Interpret.cpp/interpret.cpp#include Interpret.h#include using namespace std;AbstractExpression:AbstractExpression()