设计模式中结构型模式

 

结构图：

结构型模式涉及到如何组合类和对象以获得更大的结构。
结构型对象模式不是对接口和实现进行组合，而是描述了如何对一些对象进行组合，从而
实现新功能的一些方法。因为可以在运行时刻改变对象组合关系，所以对象组合方式具有
更大的灵活性，而这种机制用静态类组合是不可能实现的。
定义：Adapter：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本
由于接口不兼容而不能一起工作的那些类可以一起工作。

尽管Adapter模式的实现方式通常简单直接，但是仍需要注意以下一些问题：
在使用C++实现适配器类时，Adapter类应该采用公共方式继承Target类，并且用私有方式
继承Adaptee类。因此，Adapter类应该是Target的子类型，但不是Adaptee的子类型。

适配器模式有两种方法实现，一种是类适配器，一种是对象适配器。
类适配器和对象适配器有不同的权衡。类适配器
1、用一个具体的Adapter类对Adaptee和Target进行匹配。结果是当我们想要匹配生个类以
及所有它的子类时，类Adapter将不能胜任工作。
2、使得Adapter可以重定义Adapter的部分行为，因为Adapter是Adaptee的一个子类。
3、仅仅引入了一个对象，并不需要额外的指针以间接得到adaptee.
对象适配器则
1、允许一个Adapter与多个Adaptee，即Adaptee本身以及它的所有子类（如果有子类的话）
同时工作。Adapter也可以一次给所有的Adaptee添加功能。
2、使得重定义Adaptee的行为比较困难。这就需要生成Adaptee的子类并且使得Adapter引用
这个子类而不是引用adaptee本身。

本章用两个实例分别讲述类适配器模式和对象适配器模式。

对于结构型模式，由于需要用到一些结构，因此这里先贴出来，部分只有申明无实现是因为还未被用到，用到时会逐步补上去的。

 一、类适配器

//  BasicClass.h: interface for the BasicClass class.
//
/**/ //

#if  !defined(AFX_BASICCLASS_H__459C19CB_0047_4A50_855E_B7FDCFC6F3B0__INCLUDED_)
#define  AFX_BASICCLASS_H__459C19CB_0047_4A50_855E_B7FDCFC6F3B0__INCLUDED_

#if  _MSC_VER > 1000
#pragma  once
#endif   //  _MSC_VER > 1000
//  
//  #include <iostream>
//  using namespace std;
#include  < iostream.h >  
#define  DEFAULT_LIST_CAPACITY 1000
template < class  Item >   class  List
... {
public:
    List(long size = DEFAULT_LIST_CAPACITY);
    List(List&);
    ~List();
    List& operator=(const List&);

    long Count() const;
    Item& Get(long index) const;
    Item& First() const;
    Item& Last() const;
    bool Includes(const Item&) const;

    void Append(const Item&);
    void Prepend(const Item&);

    void Remove(const Item&);
    void RemoveLast();
    void RemoveFirst();
    void RemoveAll();

    Item& Top() const;
    void Push(const Item&);
    Item& Pop();
} ;

template < class  Item >   class  iterator
... {
public:
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() const = 0;
    virtual Item CurrentItem() const = 0;
protected:
    iterator();
} ;

template < class  Item >   class  ListIterator:  public  iterator < Item >
... {
public:
    ListIterator(const List<Item>* aList);

    virtual void First();
    virtual void Next();
    virtual bool IsDone();
    virtual Item CurrentItem() const;
} ;
// CPoint

typedef  float  Coord;
class  Point ... {
public:
    static const Point Zero;

    Point(Coord x = 0.0,Coord y = 0.0);

    Coord X() const;//得到x值
    Coord Y() const;
    void X(Coord x);//设置x值
    void Y(Coord y);

    Point operator+(const Point&);
    Point operator-(const Point&);
    Point operator*(const Point&);
    Point operator/(const Point&);
    
    void operator+=(const Point&);
    void operator-=(const Point&);
    void operator*=(const Point&);
    void operator/=(const Point&);

    bool operator==(const Point&);
    bool operator!=(const Point&);

     friend ostream& operator<<(ostream&, const Point&);
     friend istream& operator>>(istream&, Point&);
private:
    Coord m_x;
    Coord m_y;
} ;

class  Rect
... {
public:
    static const Rect Zero;

    Rect(Coord x, Coord y, Coord w, Coord h);
    Rect(const Point& origin, const Point& extent);

    Coord Width() const;
    void Width(Coord);
    Coord Height() const;
    void Height(Coord);
    Coord Left() const;
    void Left(Coord);
    Coord Bottom() const;
    void Bottom(Coord);

    Point& Origin() const;
    void Origin(const Point&);
    Point& Extent() const;
    void Extent(const Point&);

    void MoveTo(const Point&);
    void MoveBy(const Point&);

    bool IsEmpty() const;
    bool Contains(const Point&) const;
} ;





















#endif   //  !defined(AFX_BASICCLASS_H__459C19CB_0047_4A50_855E_B7FDCFC6F3B0__INCLUDED_)


//  BasicClass.cpp: implementation of the BasicClass class.
//
/**/ //

#include  " stdafx.h "
#include  " BasicClass.h "

Point::Point(Coord x  /**/ /* = 0.0 */ ,Coord y  /**/ /* = 0.0 */ )
... {
    m_x = x;
    m_y = y;
}

Coord Point::X()  const
... {
    return m_x;
}

Coord Point::Y()  const
... {
    return m_y;
}

void  Point::X(Coord x)
... {
    m_x = x;
}

void  Point::Y(Coord y)
... {
    m_y = y;
}

Point Point:: operator   + ( const  Point &  p)
... {
    return Point(m_x+p.m_x, m_y + p.m_y);
}

Point Point:: operator   - ( const  Point &  p)
... {
    return Point(m_x-p.m_x, m_y-p.m_y);
}

Point Point:: operator   * ( const  Point &  p)
... {
    return Point(m_x* p.m_x, m_y* p.m_y);
}

Point Point:: operator   / ( const  Point &  p)
... {
    return Point(m_x/p.m_x, m_y/p.m_y);
}


void  Point:: operator   += ( const  Point &  p)
... {
    m_x += p.m_x;
    m_y += p.m_y;
}
// CPoint
void  Point:: operator   -= ( const  Point &  p)
... {
    m_x -= p.m_x;
    m_y -= p.m_y;
}

void  Point:: operator   *= ( const  Point &  p)
... {
    m_x *= p.m_x;
    m_y *= p.m_y;
}

void  Point:: operator   /= ( const  Point &  p)
... {
    m_x /= p.m_x;
    m_y /= p.m_y;
}

bool  Point:: operator == ( const  Point &  p)
... {
    return (m_x == p.m_x && m_y == p.m_y);
}

bool  Point:: operator != ( const  Point &  p)
... {
    return !(*this== p);
}

ostream &   operator << (ostream &  cout, const  Point &  p)
... {
    cout<<p.m_x<<","<<p.m_y;
    return cout;
}

istream &   operator >> (istream &   in , Point &  p)
... {
    in>>p.m_x>>p.m_y;
    return in;
}

 

类适配器模式例，在这里，TextView认为是一个工具箱，没有源码，为了调用其中的功能，需要用一个类TextShape来调用TextView中的功能，这里TextShape就叫做适配器类，它的接口BoundingBox()调用TextView中的GetExtent(),实现通过一致的接口，完成GetExtent()功能的要求。CreateManipulator功能在原TextView中没有，这是对于原有TextView中功能增强的一种方式。

代码如下：

 

//  Adapter.h: interface for the Adapter class.
//
/**/ //

#if  !defined(AFX_ADAPTER_H__02F2DD6D_CFF8_4E63_A14B_63C2E58ACB53__INCLUDED_)
#define  AFX_ADAPTER_H__02F2DD6D_CFF8_4E63_A14B_63C2E58ACB53__INCLUDED_

#if  _MSC_VER > 1000
#pragma  once
#endif   //  _MSC_VER > 1000

#include  " BasicClass.h "

class  Manipulator;
class  Shape;
class  TextManipulator;
class  TextShape;
class  TextView;



class  Manipulator
... {
public:
    Manipulator()...{}
} ;

class  TextManipulator:  public  Manipulator
... {
public:
    TextManipulator(const Shape* sp)...{ m_pShape = (Shape*)sp; }
private:
    Shape* m_pShape;
} ;

class  Shape ... {
public:
    Shape()...{}
    virtual void BoundingBox(Point& bottomLeft,Point& topRight) const
    ...{
        bottomLeft = m_bottomLeft;
        topRight = m_topRight;
    }
    virtual Manipulator* CreateManipulator() const
    ...{
        return new Manipulator();
    }

private:
    Point m_bottomLeft;
    Point m_topRight;
} ;

class  TextView
... {
public:
    TextView(Point org =0, Coord width = 0, Coord height = 0);
    void GetOrigin(Coord& x, Coord& y) const;
    void GetExtent(Coord& width, Coord& height) const;
    virtual bool IsEmpty() const;
private:
    Point m_org;//原点
    Coord m_width;//宽度
    Coord m_height;//高度
} ;


class  TextShape:  public  Shape,  private  TextView
... {
public:
    TextShape()...{}

    virtual void BoundingBox(Point& bottomLeft,Point& topRight) const;

    virtual bool IsEmpty() const;
    virtual Manipulator* CreateManipulator() const;
} ;

#endif   //  !defined(AFX_ADAPTER_H__02F2DD6D_CFF8_4E63_A14B_63C2E58ACB53__INCLUDED_)



//  Adapter.cpp: implementation of the Adapter class.
//
/**/ //

#include  " stdafx.h "
#include  " Adapter.h "

/**/ //
//  Construction/Destruction
/**/ //



//
TextView::TextView(Point org  /**/ /* =0 */ , Coord width  /**/ /* = 0 */ , Coord height  /**/ /* = 0 */ )
... {
    m_org = org;
    m_width = width;
    m_height = height;
}

void  TextView::GetOrigin(Coord &  x, Coord &  y)  const
... {
    x = m_org.X();
    y = m_org.Y();
}

void  TextView::GetExtent(Coord &  width, Coord &  height)  const
... {
    width = m_width;
    height = m_height;
    printf("TextView::GetExtent() ");
}

bool  TextView::IsEmpty()  const
... {
    return (m_width>0 && m_height>0);
}
/**/ //


// 通过BoundingBox调用TextShape()中的接口，达到适配的目的
void  TextShape::BoundingBox(Point &  bottomLeft,Point &  topRight)  const
... {
    Coord bottom, left, width, height;

    GetOrigin(bottom, left);
    GetExtent(width, height);

    bottomLeft = Point(bottom, left);
    topRight = Point(bottom + height, left + width);
}

bool  TextShape::IsEmpty()  const
... {
    return TextView::IsEmpty();
}

Manipulator *  TextShape::CreateManipulator()  const
... {
    return new TextManipulator(this);
}



//  testConfig.cpp : Defines the entry point for the console application.
//

#include  " stdafx.h "

#include  " BasicClass.h "
#include  " Adapter.h "

int  main( int  argc,  char *  argv[])
... {
    printf("Hello World! ");

    TextShape ts;
    Point p1(1,2);
    Point p2(3,4);
    ts.BoundingBox(p1,p2);
    
    return 0;
}

 

 

 

二、对象适配器

对象适配器的功用和类适配器相同，不过它不是采用多重继承来实现，而是通过组合的方式，在适配器类中定义一个被适配的子对象（Adaptee),通过这个子对象完成适配的功能。

相关代码和前面代码类似，只需改动以下部分即可。

 

// 采用组合的方式来编写适配器
class  TextShape:  public  Shape
... {
public:
    TextShape(TextView* t)...{ _text = t; }

    virtual void BoundingBox(Point& bottomLeft,Point& topRight) const;
    virtual bool IsEmpty() const;
    virtual Manipulator* CreateManipulator() const;
private:
    TextView * _text;
} ;



// 通过BoundingBox调用TextShape()中的接口，达到适配的目的
void  TextShape::BoundingBox(Point &  bottomLeft,Point &  topRight)  const
... {
    Coord bottom, left, width, height;

    _text->GetOrigin(bottom, left);
    _text->GetExtent(width, height);

    bottomLeft = Point(bottom, left);
    topRight = Point(bottom + height, left + width);
}

bool  TextShape::IsEmpty()  const
... {
    return _text->IsEmpty();
}

Manipulator *  TextShape::CreateManipulator()  const
... {
    return new TextManipulator(this);
}







int  main( int  argc,  char *  argv[])
... {
    printf("Hello World! ");

    TextView tv;
    TextShape ts(&tv);
    Point p1(1,2);
    Point p2(3,4);
    ts.BoundingBox(p1,p2);
    
    return 0;
}