[Boolan] C++第十二周 C++设计模式（二）

设计模式

对象创建

1. AbstractFactory -

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

就上面的图而言，存在一系列一览关系的是ProductA1-ProductB1， ProductA2和ProductB2，视频中讲的这种关系是创建数据库和连接数据库的关系。

#include <iostream> using namespace std; //--------------产品类型的抽象基类 class AbstractProductA { public: virtual ~AbstractProductA(){ } protected: AbstractProductA(){} }; class AbstractProductB{ public: virtual ~AbstractProductB(){} protected: AbstractProductB(){} }; //--------------产品的实例类 class ProductA1 : public AbstractProductA { public: ProductA1(){ cout << "ProductA1()" <<endl; } ~ProductA1(){} }; class ProductA2 : public AbstractProductA { public: ProductA2(){ cout << "ProductA2()" <<endl; } ~ProductA2(){} }; class ProductB1 : public AbstractProductB { public: ProductB1(){ cout << "ProductB1()" <<endl; } ~ProductB1(){} }; class ProductB2 : public AbstractProductB { public: ProductB2(){ cout << "ProductB2()" <<endl; } ~ProductB2(){} }; //------------抽象工厂 class AbstractFactory{ public: virtual ~AbstractFactory(){} virtual AbstractProductA* CreateProductA() = 0; virtual AbstractProductB* CreateProductB() = 0; protected: AbstractFactory(){} }; class ConcreteFactory1 : public AbstractFactory { public: ConcreteFactory1(){} ~ConcreteFactory1(){} AbstractProductA * CreateProductA(){ return new ProductA1(); } AbstractProductB * CreateProductB(){ return new ProductB1(); } }; class ConcreteFactory2 : public AbstractFactory { public: ConcreteFactory2(){} ~ConcreteFactory2(){} AbstractProductA * CreateProductA(){ return new ProductA2(); } AbstractProductB * CreateProductB() { return new ProductB2(); } }; int main(int argc, char* argv[]) { AbstractFactory* cf1 = new ConcreteFactory1(); cf1->CreateProductA(); cf1->CreateProductB(); return 0; }

2. Prototype - 原型模式

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象

#include <iostream> using namespace std; class Prototype { public: virtual ~Prototype(){} virtual Prototype* Clone() const = 0; protected: Prototype(){} }; class ConcretePrototype : public Prototype { public: ConcretePrototype(){} ConcretePrototype(const ConcretePrototype &cp){ cout << "ConcretePrototype copy..." << endl; } ~ConcretePrototype(){} Prototype* Clone() const { return new ConcretePrototype(*this); } }; int main(int argc, char *argv[]) { Prototype *p = new ConcretePrototype(); Prototype* p1 = p->Clone(); return 0; }

3. Builder - 构建器

将一个复杂对象的构建与其表示相分离，使得同样的构建过 程(稳定)可以创建不同的表示(变化)。

主要思想就是使用一个构造器，创建出这个对象，并且把这个对象提前做的一些准备进行构建，然后把这个构建成功的对象返回出来 实现复杂的构想过程，和直接使用的过程分离，解耦，提高可扩展性 #include <iostream> using namespace std; class Product { public: Product(){ ProducePart(); cout << "return a product" << endl; } ~Product(){} void ProducePart(){ cout << "build part of product.." << endl; } }; class Builder { public: virtual ~Builder(){} virtual void BuildPartA(const string &buildPara) = 0; virtual void BuildPartB(const string &buildPara) = 0; virtual void BuildPartC(const string &buildPara) = 0; virtual Product * GetProduct() = 0; protected: Builder(){} }; class ConcreteBuilder : public Builder { public: ConcreteBuilder(){} ~ConcreteBuilder(){} virtual void BuildPartA(const string &buildPara) { cout << "Step1: Builder PartA..." << buildPara << endl; } virtual void BuildPartB(const string &buildPara) { cout << "Step1: Builder PartB..." << buildPara << endl; } virtual void BuildPartC(const string &buildPara) { cout << "Step1: Builder PartC..." << buildPara << endl; } virtual Product * GetProduct() { BuildPartA("pre-defined"); BuildPartB("pre-defined"); BuildPartC("pre-defined"); return new Product(); } }; class Director { public: Director(Builder *bld) :_bld(bld){ } ~Director(){} void Construct(){ _bld->BuildPartA("user-defined"); _bld->BuildPartB("user-defined"); _bld->BuildPartC("user-defined"); } private: Builder* _bld; }; int main(int argc, char *argv[]) { Builder *b = new ConcreteBuilder(); Director *d = new Director(b); d->Construct(); Product *p = b->GetProduct(); return 0; }

接口隔离

1. Facade - 门面模式

为子系统中的一组接口 供一个一致(稳定)的界面， Façade模式定义了一个高层接口，这个接口使得这一子系统 更加容易使用(复用)。

#include <iostream> using namespace std; class Subsystem1{ public: Subsystem1(){} ~Subsystem1(){} void Operation(){ cout << "Subsystem1 operation" << endl; } }; class Subsystem2{ public: Subsystem2(){} ~Subsystem2(){} void Operation(){ cout << "Subsystem2 operation" << endl; } }; class Facade { public: Facade(){ this->_sub1 = new Subsystem1(); this->_sub2 = new Subsystem2(); } ~Facade(){ delete _sub1; delete _sub2; } void OperationWrapper(){ this->_sub1->Operation(); this->_sub2->Operation(); } private: Subsystem1* _sub1; Subsystem2* _sub2; }; int main(int argc, char*argv[]) { Facade *f = new Facade(); f->OperationWrapper(); return 0; }

2. Proxy - 代理模式

至少在以下集中情况下可以用 Proxy 模式解决问题: 1)创建开销大的对象时候，比如显示一幅大的图片，我们将这个创建的过程交给代理 去完成，GoF 称之为虚代理(Virtual Proxy); 2)为网络上的对象创建一个局部的本地代理，比如要操作一个网络上的一个对象(网 络性能不好的时候，问题尤其突出)，我们将这个操纵的过程交给一个代理去完成，GoF 称 之为远程代理(Remote Proxy); 3)对对象进行控制访问的时候，比如在 Jive 论坛中不同权限的用户(如管理员a、普通 用户等)将获得不同层次的操作权限，我们将这个工作交给一个代理去完成，GoF 称之为保 护代理(Protection Proxy)。

#include <iostream> using namespace std; class Subject{ public: virtual ~Subject(){} virtual void Request() = 0; protected: Subject(){} }; class ConcreteSubject : public Subject { public: ConcreteSubject(){} ~ConcreteSubject(){} void Request(){ cout << "ConcreteSubject ...request" <<endl; } }; class Proxy { public: Proxy(Subject* sub) :_sub(sub){} ~Proxy(){} void Request(){ cout << "Proxy request..." << endl; _sub->Request(); } private: Subject *_sub; }; int main(int argc, char *argv[]) { Subject *sub = new ConcreteSubject(); Proxy* p = new Proxy(sub); p->Request(); return 0; }

3. Adapter - 适配器

将一个类的接口转换成客户希望的另一个接口。Adapter模 式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

#include <iostream> using namespace std; class Target{ public: Target(){} virtual ~Target(){} virtual void Request(){ cout << "Target::Request"<<endl; } }; class Adaptee{ public: Adaptee(){} ~Adaptee(){} void SpecificRequest(){ cout << "Adaptee::SpecificRequest" << endl; } }; class Adapter : public Target { public: Adapter(Adaptee* ade) :_ade(ade){} ~Adapter(){} void Request(){ _ade->SpecificRequest(); } private: Adaptee* _ade; }; int main(int argc ,char* argv[]) { Adaptee* ade = new Adaptee; Target* adt = new Adapter(ade); adt->Request(); return 0; }

4. Mediator - 中介者

用一个中介对象类封装(封装变化)一系列的对象交互。 中介者使各个对象不需要显式的相互引用（编译时依赖-> 运行时依赖），从而使其耦合松散，而且可以独立的改变他们之间的变化

#include <iostream> #include <string> using namespace std; class Mediator; class Colleage { public: virtual ~Colleage(){} virtual void Action() = 0; virtual void SetState(const string &std) = 0; virtual string GetState() = 0; protected: Colleage(){} Colleage(Mediator *mdt) :_mdt(mdt){} Mediator *_mdt; }; class Mediator { public: virtual ~Mediator(){} virtual void DoActionFromAtoB() = 0; virtual void DoActionFromBtoA() = 0; protected: Mediator(){} }; class ConcreteColleageA : public Colleage { public: ConcreteColleageA(){} ConcreteColleageA(Mediator* mdt) : Colleage(mdt){ } ~ConcreteColleageA(){} void Action(){ _mdt->DoActionFromAtoB(); cout << "state of ConcreteColleageA:" << this->GetState() << endl; } void SetState(const string& sdt){ _sdt = sdt; } string GetState(){ return _sdt; } private: string _sdt; }; class ConcreteColleageB : public Colleage { public: ConcreteColleageB(){} ConcreteColleageB(Mediator* mdt) : Colleage(mdt){ } ~ConcreteColleageB(){} void Action(){ _mdt->DoActionFromAtoB(); cout << "state of ConcreteColleageB:" << this->GetState() << endl; } void SetState(const string& sdt){ _sdt = sdt; } string GetState(){ return _sdt; } private: string _sdt; }; class ConcreteMediator : public Mediator { public: ConcreteMediator(){} ConcreteMediator(Colleage* clgA, Colleage*clgB) :_clgA(clgA),_clgB(clgB) {} ~ConcreteMediator(){} void SetConcreteColleageA(Colleage* clgA){ _clgA = clgA; } void SetConcreteColleageB(Colleage* clgB){ _clgB = clgB; } Colleage* GetConcreteColleageA(){ return _clgA; } Colleage* GetConcreteColleageB(){ return _clgB; } void IntroColleage(Colleage* clgA, Colleage* clgB) { this->_clgA = clgA; this->_clgB = clgB; } void DoActionFromAtoB(){ _clgB->SetState(_clgA->GetState()); } void DoActionFromBtoA(){ _clgA->SetState(_clgB->GetState()); } private: Colleage* _clgA; Colleage* _clgB; }; int main(int argc, char *argv[]) { ConcreteMediator* m = new ConcreteMediator(); ConcreteColleageA* c1 = new ConcreteColleageA(m); ConcreteColleageB* c2 = new ConcreteColleageB(m); m->IntroColleage(c1, c2); c1->SetState("old"); c2->SetState("old"); c1->Action(); c2->Action(); cout << endl; c1->SetState("new"); c1->Action(); c2->Action(); cout << endl; c2->SetState("old"); c2->Action(); c2->Action(); return 0; } Mediator 模式的实现关键就是将对象 Colleague 之间的通信封装到一个类种单独处理， 为了模拟 Mediator 模式的功能，这里给每个 Colleague 对象一个 string 型别以记录其状态， 并通过状态改变来演示对象之间的交互和通信。这里主要就 Mediator 的示例运行结果给出 分析: 1)将 ConcreteColleageA 对象设置状态“old”，ConcreteColleageB 也设置状态“old”; 2)ConcreteColleageA 对象改变状态，并在 Action 中和 ConcreteColleageB 对象进行通信，并改变 ConcreteColleageB 对象的状态为“new”; 3)ConcreteColleageB 对象改变状态，并在 Action 中和 ConcreteColleageA 对象进行通信，并改变 ConcreteColleageA 对象的状态为“new”; 注意到，两个 Colleague 对象并不知道它交互的对象，并且也不是显示地处理交互过程，这一切都是 通过 Mediator 对象完成的，示例程序运行的结果也正是证明了这一点。