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

附录A: 余下的模式

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

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

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

//***********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();
};

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 封装一个产品的构造过程 允许按步骤构造

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

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

//***********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;
};

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 让一个以上的对象处理某个请求的时候

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

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

//***********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;};
};

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 让某个类的一个实例能用来提供很多"虚拟实例" 

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

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

//***********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;
};

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 为语言创建解释器

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

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

//***********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 );
};

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);