设计模式C++实现（9）——享元模式

分类： 设计模式

设计模式 c++ string class delete struct

        软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》（DP）两本书。本文介绍享元模式的实现。

        举个围棋的例子，围棋的棋盘共有361格，即可放361个棋子。现在要实现一个围棋程序，该怎么办呢？首先要考虑的是棋子棋盘的实现，可以定义一个棋子的类，成员变量包括棋子的颜色、形状、位置等信息，另外再定义一个棋盘的类，成员变量中有个容器，用于存放棋子的对象。下面给出代码表示：

        棋子的定义，当然棋子的属性除了颜色和位置，还有其他的，这里略去。这两个属性足以说明问题。

[cpp]  view plain copy print ?

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. };  

        棋盘的定义：

[cpp]  view plain copy print ?

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. };  

        客户的使用方式如下：

[cpp]  view plain copy print ?

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。这里是关键。

       棋子的新定义，只包含内在属性：

[cpp]  view plain copy print ?

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. };  

        相应棋盘的定义为：

[cpp]  view plain copy print ?

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图，以围棋为例。棋盘中含两个共享的对象，黑棋子和白棋子，所有棋子的外在属性都存放在单独的容器中。

        程序有bug,明白意思就好转载http://blog.csdn.net/wuzhekai1985