设计模式C++实现(9)——享元模式

[复制链接]

该用户从未签到

759

主题

763

帖子

4660

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
4660
跳转到指定楼层
楼主
发表于 2018-1-7 11:12:39 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式

想要查看内容赶紧注册登陆吧!

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性:封装、继承、多态,真正领悟设计模式的精髓是可能一个漫长的过程,需要大量实践经验的积累。最近看设计模式的书,对于每个模式,用C++写了个小例子,加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》(DP)两本书。本文介绍享元模式的实现。        举个围棋的例子,围棋的棋盘共有361格,即可放361个棋子。现在要实现一个围棋程序,该怎么办呢?首先要考虑的是棋子棋盘的实现,可以定义一个棋子的类,成员变量包括棋子的颜色、形状、位置等信息,另外再定义一个棋盘的类,成员变量中有个容器,用于存放棋子的对象。下面给出代码表示:
        棋子的定义,当然棋子的属性除了颜色和位置,还有其他的,这里略去。这两个属性足以说明问题。
  1. //棋子颜色
  2. enum PieceColor {BLACK, WHITE};
  3. //棋子位置
  4. struct PiecePos
  5. {
  6.         int x;
  7.         int y;
  8.         PiecePos(int a, int b): x(a), y(b) {}
  9. };
  10. //棋子定义
  11. class Piece
  12. {
  13. protected:
  14.         PieceColor m_color; //颜色
  15.         PiecePos m_pos;     //位置
  16. public:
  17.         Piece(PieceColor color, PiecePos pos): m_color(color), m_pos(pos) {}
  18.         ~Piece() {}
  19.         virtual void Draw() {}
  20. };
  21. class BlackPiece: public Piece
  22. {
  23. public:
  24.         BlackPiece(PieceColor color, PiecePos pos): Piece(color, pos) {}
  25.         ~BlackPiece() {}
  26.         void Draw() { cout<<"绘制一颗黑棋"<<endl;}
  27. };
  28. class WhitePiece: public Piece
  29. {
  30. public:
  31.         WhitePiece(PieceColor color, PiecePos pos): Piece(color, pos) {}
  32.         ~WhitePiece() {}
  33.         void Draw() { cout<<"绘制一颗白棋"<<endl;}
  34. };
复制代码
棋盘的定义:
  1. class PieceBoard
  2. {
  3. private:
  4.         vector<Piece*> m_vecPiece; //棋盘上已有的棋子
  5.         string m_blackName; //黑方名称
  6.         string m_whiteName; //白方名称
  7. public:
  8.         PieceBoard(string black, string white): m_blackName(black), m_whiteName(white){}
  9.         ~PieceBoard() { Clear(); }
  10.         void SetPiece(PieceColor color, PiecePos pos) //一步棋,在棋盘上放一颗棋子
  11.         {
  12.                 Piece * piece = NULL;
  13.                 if(color == BLACK) //黑方下的
  14.                 {       
  15.                         piece = new BlackPiece(color, pos); //获取一颗黑棋
  16.                         cout<<m_blackName<<"在位置("<<pos.x<<','<<pos.y<<")";
  17.                         piece->Draw(); //在棋盘上绘制出棋子
  18.                 }
  19.                 else
  20.                 {       
  21.                         piece = new WhitePiece(color, pos);
  22.                         cout<<m_whiteName<<"在位置("<<pos.x<<','<<pos.y<<")";
  23.                         piece->Draw();
  24.                 }
  25.                 m_vecPiece.push_back(piece);  //加入容器中
  26.         }
  27.         void Clear() //释放内存
  28.         {
  29.                 int size = m_vecPiece.size();
  30.                 for(int i = 0; i < size; i++)
  31.                         delete m_vecPiece[i];
  32.         }
  33. };
复制代码
客户的使用方式如下:
  1. int main()
  2. {
  3.         PieceBoard pieceBoard("A","B");
  4.         pieceBoard.SetPiece(BLACK, PiecePos(4, 4));
  5.         pieceBoard.SetPiece(WHITE, PiecePos(4, 16));
  6.         pieceBoard.SetPiece(BLACK, PiecePos(16, 4));
  7.         pieceBoard.SetPiece(WHITE, PiecePos(16, 16));
  8. }
复制代码
可以发现,棋盘的容器中存放了已下的棋子,而每个棋子包含棋子的所有属性。一盘棋往往需要含上百颗棋子,采用上面这种实现,占用的空间太大了。如何改进呢?用享元模式。其定义为:运用共享技术有效地支持大量细粒度的对象。        在围棋中,棋子就是大量细粒度的对象。其属性有内在的,比如颜色、形状等,也有外在的,比如在棋盘上的位置。内在的属性是可以共享的,区分在于外在属性。因此,可以这样设计,只需定义两个棋子的对象,一颗黑棋和一颗白棋,这两个对象含棋子的内在属性;棋子的外在属性,即在棋盘上的位置可以提取出来,存放在单独的容器中。相比之前的方案,现在容器中仅仅存放了位置属性,而原来则是棋子对象。显然,现在的方案大大减少了对于空间的需求。
       关注PieceBoard 的容器,之前是vector<Piece*> m_vecPiece,现在是vector<PiecePos> m_vecPos。这里是关键。
       棋子的新定义,只包含内在属性:
  1. //棋子颜色
  2. enum PieceColor {BLACK, WHITE};
  3. //棋子位置
  4. struct PiecePos
  5. {
  6.         int x;
  7.         int y;
  8.         PiecePos(int a, int b): x(a), y(b) {}
  9. };
  10. //棋子定义
  11. class Piece
  12. {
  13. protected:
  14.         PieceColor m_color; //颜色
  15. public:
  16.         Piece(PieceColor color): m_color(color) {}
  17.         ~Piece() {}
  18.         virtual void Draw() {}
  19. };
  20. class BlackPiece: public Piece
  21. {
  22. public:
  23.         BlackPiece(PieceColor color): Piece(color) {}
  24.         ~BlackPiece() {}
  25.         void Draw() { cout<<"绘制一颗黑棋\n"; }
  26. };
  27. class WhitePiece: public Piece
  28. {
  29. public:
  30.         WhitePiece(PieceColor color): Piece(color) {}
  31.         ~WhitePiece() {}
  32.         void Draw() { cout<<"绘制一颗白棋\n";}
  33. };
复制代码
相应棋盘的定义为:
  1. class PieceBoard
  2. {
  3. private:
  4.         vector<PiecePos> m_vecPos; //存放棋子的位置
  5.         Piece *m_blackPiece;       //黑棋棋子
  6.         Piece *m_whitePiece;       //白棋棋子
  7.         string m_blackName;
  8.         string m_whiteName;
  9. public:
  10.         PieceBoard(string black, string white): m_blackName(black), m_whiteName(white)
  11.         {
  12.                 m_blackPiece = NULL;
  13.                 m_whitePiece = NULL;
  14.         }
  15.         ~PieceBoard() { delete m_blackPiece; delete m_whitePiece;}
  16.         void SetPiece(PieceColor color, PiecePos pos)
  17.         {
  18.                 if(color == BLACK)
  19.                 {
  20.                         if(m_blackPiece == NULL)  //只有一颗黑棋
  21.                                 m_blackPiece = new BlackPiece(color);       
  22.                         cout<<m_blackName<<"在位置("<<pos.x<<','<<pos.y<<")";
  23.                         m_blackPiece->Draw();
  24.                 }
  25.                 else
  26.                 {
  27.                         if(m_whitePiece == NULL)
  28.                                 m_whitePiece = new WhitePiece(color);
  29.                         cout<<m_whiteName<<"在位置("<<pos.x<<','<<pos.y<<")";
  30.                         m_whitePiece->Draw();
  31.                 }
  32.                 m_vecPos.push_back(pos);
  33.         }
  34. };
复制代码
客户的使用方式一样,这里不重复给出,现在给出享元模式的UML图,以围棋为例。棋盘中含两个共享的对象,黑棋子和白棋子,所有棋子的外在属性都存放在单独的容器中。
        本人享有博客文章的版权,转载请标明出处 http://blog.csdn.net/wuzhekai1985


分享到:  QQ好友和群QQ好友和群
收藏收藏
回复

使用道具 举报

快速回复高级模式
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

快速回复 返回顶部 返回列表