设计模式之桥接（Bridge）---对象结构性模式

设计模式之桥接（Bridge）---对象结构性模式(设计模式笔记）

1.意图

       将抽象部分与它的实现部分分离，使它们都可以独立地变化。

 

 

2.别名   Handle/Body

 

 

3.动机

       当一个抽象可能有多个实现时,通常用继承来协调它们.但不够灵活.可以用Bridge模式.

 

 

4.适用性

       1)你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。

       2)类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时Bridge 模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。

       3)对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。

       4)（C + +）你想对客户完全隐藏抽象的实现部分。在C + +中，类的表示在类接口中是可见的。

 

 

5.结构

              

 

 

6.参与者

* Abstraction

---定义抽象类的接口.

---维护一个指向Implementor类型的指针.

*RefinedAbstraction

---扩充由Abstrastion定义的接口.

*Implementor

---定义实现类的接口,该接口不一定要与Abstraction接口完全一致;一般是: Implementor接口仅提供基本操作,而Abstraction则定义了基于这些基本操作的较高层次的操作.( 重点理解)

* ConcreteImplementor接口并定义它的具体实现.

 

 

7.协作:

       Abstraction将Client的请求转发给它的Implementor对象.( 重点理解)

 

 

8.代码示例:

//------------------------------------------------------

 

 

 

 

/*    1）与模式对应关系

          Abstraction----Window

       RefineAbstraction---IconWindow&&ApplicationWindow

       Implementor----ImpWindow

       ConcreteImplementor---XWindowImp,PMWindowImp

2）结构图

   

 

 

      

*/

class Body {

  public:

   void Ref();

   void Unref();

   int RefCount();

 private:

};

 

 

class Handle {

  public:

    Handle& operator=(const Handle& other);

  private:

    Body* _body;

};

/*

*/

Handle& Handle::operator= (const Handle& other)  {

    other._body->Ref();

    _body->Unref();

 

 

    if (_body->RefCount() == 0) {

        delete _body;

    }

    _body = other._body;

 

 

    return *this;

}

/*

*/

#include "Geom.H"

#include "math.h"

class Window;

 

 

class View {

  public:

    DrawOn(Window*);

};

 

 

class WindowImp;

struct Display;

typedef unsigned int Drawable;

typedef struct XXX { int y; }  *GC;

extern XDrawRectangle(

    Display*,

    Drawable,

    GC,

    int,

    int,

    unsigned int,

    unsigned int

);

 

 

struct PPOINTL {

    Coord x;

    Coord y;

};

const int GPI_ERROR = 1;

 

 

typedef int HPS;

int GpiBeginPath(HPS, unsigned long);

int GpiSetCurrentPosition(HPS, PPOINTL*);

int GpiPolyLine(HPS, unsigned long, PPOINTL*);

int GpiEndPath(HPS);

void  ReportError();

void GpiStrokePath(HPS, unsigned long, unsigned long);

class WindowSystemFactory {

  public:

    static WindowSystemFactory* Instance();

    WindowImp* MakeWindowImp();

};

 

 

/*

*/

class Window {

public:

    Window(View* contents);

 

 

    // requests handled by window

    virtual void DrawContents();

/*

*/

    virtual void Open();

    virtual void Close();

    virtual void Iconify();

    virtual void Deiconify();

/*

*/

    // requests forwarded to implementation

    virtual void SetOrigin(const Point& at);

    virtual void SetExtent(const Point& extent);

    virtual void Raise();

    virtual void Lower();

/*

*/

    virtual void DrawLine(const Point&, const Point&);

    virtual void DrawRect(const Point&, const Point&);

    virtual void DrawPolygon(const Point[], int n);

    virtual void DrawText(const char*, const Point&);

/*

*/

protected:

    WindowImp* GetWindowImp();

    View* GetView();

/*

*/

private:

    WindowImp* _imp;

    View* _contents; // the window's contents

};

/*

*/

class WindowImp {

public:

    virtual void ImpTop() = 0;

    virtual void ImpBottom() = 0;

    virtual void ImpSetExtent(const Point&) = 0;

    virtual void ImpSetOrigin(const Point&) = 0;

/*

*/

    virtual void DeviceRect(Coord, Coord, Coord, Coord) = 0;

    virtual void DeviceText(const char*, Coord, Coord) = 0;

    virtual void DeviceBitmap(const char*, Coord, Coord) = 0;

    // lots more functions for drawing on windows...

protected:

    WindowImp();

};

/*

*/

class ApplicationWindow : public Window {

public:

    // ...

    virtual void DrawContents();

};

 

 

void ApplicationWindow::DrawContents () {

    GetView()->DrawOn(this);

}

/*

*/

class IconWindow : public Window {

public:

    // ...

    virtual void DrawContents();

private:

    const char* _bitmapName;

};

/*

*/

void IconWindow::DrawContents() {

    WindowImp* imp = GetWindowImp();

    if (imp != 0) {

        imp->DeviceBitmap(_bitmapName, 0.0, 0.0);

    }

}

/*

*/

void Window::DrawRect (const Point& p1, const Point& p2) {

    WindowImp* imp = GetWindowImp();

    imp->DeviceRect(p1.X(), p1.Y(), p2.X(), p2.Y());

}

/*

*/

class XWindowImp : public WindowImp {

public:

    XWindowImp();

 

 

    virtual void DeviceRect(Coord, Coord, Coord, Coord);

    // remainder of public interface...

private:

    // lots of X window system-specific state, including:

    Display* _dpy;

    Drawable _winid;  // window id

    GC _gc;           // window graphic context

};

/*

*/

class PMWindowImp : public WindowImp {

public:

    PMWindowImp();

    virtual void DeviceRect(Coord, Coord, Coord, Coord);

 

 

    // remainder of public interface...

private:

    // lots of PM window system-specific state, including:

    HPS _hps;

};

/*

*/

void XWindowImp::DeviceRect (

    Coord x0, Coord y0, Coord x1, Coord y1

) {

    int x = round(min(x0, x1));

    int y = round(min(y0, y1));

    int w = round(abs(x0 - x1));

    int h = round(abs(y0 - y1));

    XDrawRectangle(_dpy, _winid, _gc, x, y, w, h);

}

/*

*/

void PMWindowImp::DeviceRect (

    Coord x0, Coord y0, Coord x1, Coord y1

) {

    Coord left = min(x0, x1);

    Coord right = max(x0, x1);

    Coord bottom = min(y0, y1);

    Coord top = max(y0, y1);

/*

*/

    PPOINTL point[4];

/*

*/

    point[0].x = left;    point[0].y = top;

    point[1].x = right;   point[1].y = top;

    point[2].x = right;   point[2].y = bottom;

    point[3].x = left;    point[3].y = bottom;

/*

*/

    if (

        (GpiBeginPath(_hps, 1L) == false) ||

        (GpiSetCurrentPosition(_hps, &point[3]) == false) ||

        (GpiPolyLine(_hps, 4L, point) == GPI_ERROR)  ||

        (GpiEndPath(_hps) == false)

    ) {

        // report error

/*

*/

    } else {

        GpiStrokePath(_hps, 1L, 0L);

    }

}

/*

*/

WindowImp* Window::GetWindowImp () {

    if (_imp == 0) {

        _imp = WindowSystemFactory::Instance()->MakeWindowImp();

    }

    return _imp;

}

/*

*/

 

 

//---------------------------------------------------------------------------