Head First 设计模式 Design Pattern 附录 Bridge, Builder, Chain, Flyweight, Interpreter

附录A: 余下的模式

1桥接 Bridge 不只改变实现, 也改变抽象

>优点 将实现解耦 让其和UI之间不再绑定; 抽象和实现可以独立扩展互不影响; 对于"具体的抽象类"所做的改变不影响客户

>用途和缺点 适合需要跨越多个平台的图形和窗口系统上; 当需要用不同的方式改变接口和实现时; 增加了复杂度;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

//***********Bridge*********** class  ITVImp { public :      virtual  void  onImp() = 0; };                                                                            class  IRemoteControl { public :      virtual  void  on() = 0;      virtual  void  SetImp(ITVImp* pImp) { mpImp = pImp; }      virtual  ITVImp* GetImp() {  return  mpImp;} private :      ITVImp* mpImp; };                                                                        class  RCAImp :  public  ITVImp { public :      virtual  void  onImp(); };                                                                        class  ConcreteRemoteControl :  public  IRemoteControl { public :      ConcreteRemoteControl();      virtual  void  on(); };

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void  RCAImp::onImp() {      cout <<  "RCAImp"  << endl; }                                                                       ConcreteRemoteControl::ConcreteRemoteControl() {      SetImp( new  RCAImp()); }                                                                       void  ConcreteRemoteControl::on() {      ((RCAImp*)GetImp())->onImp(); }                                                                                //Bridge          ConcreteRemoteControl* control =  new  ConcreteRemoteControl();          control->on();

PIMPL模式 Private Class Data Pattern 隐藏类的内部实现和数据 用户只能看到public API

2生成器 Builder 封装一个产品的构造过程 允许按步骤构造

>优点 将复杂对象的创建过程封装起来; 允许对象通过多个步骤创建 可以改变过程(工厂模式只有一个步骤); 向客户隐藏产品内部的表现; 产品的表现可替换 客户只看到抽象的接口

>用途和缺点 创建组合结构; 与工厂模式相比 采用生成器创建对象的客户需要具备更多领域知识;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

//***********Builder*********** class  Result { public :      void  show();      string sPartA;      string sPartB; };                                                    class  IBuilder { public :      virtual  void  buildA(string a) = 0;      virtual  void  buildB(string b) = 0;  //...      virtual  Result* getResult() = 0; };                                                    class  ResBuilder :  public  IBuilder { public :      ResBuilder();      virtual  void  buildA(string a);      virtual  void  buildB(string b);      virtual  Result* getResult() {  return  mpRes;}; private :      Result* mpRes; };

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

ResBuilder::ResBuilder() {      mpRes =  new  Result(); }                                                    void  ResBuilder::buildA(string a) {      mpRes->sPartA = a; }                                                    void  ResBuilder::buildB(string b) {      mpRes->sPartB = b; }                                                    void  Result::show() {      cout << sPartA + sPartB << endl; }                                                             //Builder          ResBuilder* builder =  new  ResBuilder();          builder->buildA( "Build part A" );          builder->buildB( "Build part B" );          Result* res = builder->getResult();          res->show();

3责任链 Chain of Responsibility 让一个以上的对象处理某个请求的时候

>优点 将请求的发送者和接收者解耦; 简化对象 使其不需要知道链的结构; 通过改变链内的成员或调动次序 允许动态新增或者删除责任

>用途和缺点 经常使用在窗口系统中 处理鼠标和键盘事件; 不保证请求一定会被执行; 不容易观察运行时的特征, 不易查错

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

//***********ChainOR*********** class  IHandler; typedef  vector <IHandler*> HANDLERVEC; class  IHandler { public :      IHandler( int  iType) : miType(iType) {};      virtual  void  handleRequest() = 0;      virtual  int  getType() { return  miType;} private :      int  miType; };                                        class  ConcreteHandler :  public  IHandler { public :      ConcreteHandler( int  iType);      virtual  void  handleRequest(); private :      HANDLERVEC mHandlerVec; };                                        class  HandlerLev1 :  public  IHandler { public :      HandlerLev1( int  iType) : IHandler(iType) {};      virtual  void  handleRequest() {cout <<  "Handle Level1"  << endl;}; };                                        class  HandlerLev2 :  public  IHandler { public :      HandlerLev2( int  iType) : IHandler(iType) {};      virtual  void  handleRequest() {cout <<  "Handle Level2"  << endl;}; };

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

ConcreteHandler::ConcreteHandler( int  iType) : IHandler(iType) {      HandlerLev1* lev1 =   new  HandlerLev1(1);      HandlerLev2* lev2 =   new  HandlerLev2(2);      mHandlerVec.push_back(lev1);      mHandlerVec.push_back(lev2); }                                       void  ConcreteHandler::handleRequest() {      HANDLERVEC::iterator iter = mHandlerVec.begin();      for  (; iter != mHandlerVec.end(); iter++)      {          IHandler* handler = *iter;          if  (handler != NULL && getType() == handler->getType())          {              handler->handleRequest();              return ;          }      } }          //ChainOR          ConcreteHandler* handler =  new  ConcreteHandler(1);          handler->handleRequest();

4蝇量 Flyweight 让某个类的一个实例能用来提供很多"虚拟实例" 

>优点 减少运行时对象实例的个数 节省内存; 将许多"虚拟对象"的状态集中管理

>用途和缺点 当类有许多的实例 这些实例能被同一个方法控制的时候; 单个的逻辑实例将无法拥有独立而不同的行为

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

//***********Flyweight*********** class  Tree { public :      Tree( int  i);      virtual  void  display( int  x,  int  y);      virtual  int  getAge() {  return  miAge;} private :      int  miAge; };                           struct  TreeData {      int  xCoord;      int  yCoord;      int  age; };                           typedef  map < int , Tree*> TREEMAP; class  TreeManager { public :      void  displayTrees( int  num, TreeData data[]);      Tree* getTree( int  age); private :      TREEMAP treeMap; };

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

Tree::Tree( int  i) : miAge(i) {}                          void  Tree::display( int  x,  int  y) {      cout<<  "Coord" << x <<  "," << y <<      "Age" <<miAge<<endl; }                          void  TreeManager::displayTrees( int  num, TreeData data[]) {      for ( int  i = 0; i < num; i++)      {          TreeData treeData = data[i];          getTree(treeData.age)->display(treeData.xCoord, treeData.yCoord);      } }                          Tree* TreeManager::getTree( int  age) {      Tree* tree;      TREEMAP::iterator iter = treeMap.find(age);      if  (iter == treeMap.end())  // Save the memeory      {          tree =  new  Tree(age);          cout<< "new a tree" <<endl;          treeMap[age] = tree;      }      else          tree = treeMap[age];                                   return  tree; }          //Flyweight          TreeData treeData[3] =          {              {10, 20, 3},              {20, 10, 5},              {30, 30, 3}          };          TreeManager treeManager;          treeManager.displayTrees(3, treeData);

5解释器 Interpreter 为语言创建解释器

>优点 将每一个语法规则表示成一个类; 语法由许多类表示 容易改变或扩展语言; 通过在类结构中加入新的方法 可以在解释的同时增加新的行为 例如格式美化或程序验证

>用途和缺点 需要实现一个简单的语言时; 有一个简单的语法 简单比效率更重要时; 处理脚本语言和编程语言; 当语法规则数目过大时 模式将变得非常繁复 这种情况下适合解析器/编译器

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

//***********Interpreter*********** class  Context { public :      Context(string s,  int  d) : statement(s), data(d) {};      string getState() {  return  statement;}      int  getData() {  return  data;} private :      string statement;      int  data; };               class  IExpression { public :      virtual  void  Interpreter(Context context) = 0; };               class  Expression :  public  IExpression { public :      void  Interpreter(Context context);      void  parseState(string);      void  parseData( int ); };

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

void  Expression::Interpreter(Context context) {      parseState(context.getState());      parseData(context.getData()); }              void  Expression::parseState(string s) {      cout <<  "string: "  << s << endl; }              void  Expression::parseData( int  d) {      cout <<  "data: "  << d << endl; }          //Interpreter          Context context( "test" , 1);          Expression expression;          expression.Interpreter(context);