享元模式（Flyweight）

设计模式系列

Flyweight享元模式——对象结构模式

1.意图

运用共享技术有效地支持大量细颗粒度的对象

2.适用性

• 一个运用程序使用了大量的对象
• 完全由于使用大量的对象，造成很大的存储开销
• 对象的大多数状态都可变为外部状态
• 如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象
• 应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值

3.结构

4.参与者

• Flyweight

—— 描述一个接口，通过这个接口flyweight可以接受并作用于外部状态

• ConcreteFlyweight

—— 实现Flyweight接口，并为内部状态（如果有的话）增加存储空间。ConcreteFlyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景

• UnsharedConcreteFlyweight

—— 并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。在Flyweight对象结构的某些层次，UnshareConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。

• FlyweightFactory

—— 创建并管理flyweight。当用户请求一个flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）

• Client

—— 计算或存储一个（多个）flyweight的外部状态

5.协作

• flyweight执行是所需的状态必定是内部的或外部的。内部状态存储于ConcreteFlyweight对象之中；而外部对象则由Client对象存储或计算。当用户调用flyweight对象的操作时，将该状态传递给它。
• 用户不应直接对ConcreteFlyweight类进行实例化，而只能从FlyweightFactory对象得到ConcreteFlyweight对象，这可以保证对它们适当地进行共享。

6.效果

优点：

1）可以减少内存中对象的数量，使得相同或者相似的对象在内存中只保存一份，从而可以节约系统资源

2）提高系统性能 外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享

缺点：

1）使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化

2）为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长

适用环境：

一个系统有大量相同或者相似的对象，造成内存的大量耗费 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，在需要多次重复使用享元对象时才值得使用享元模式。

7.相关模式

Flyweight模式通常和Composite模式结合起来，用共享叶结点的有向无环图实现一个逻辑上的层次结构。

通常，最好用Flyweight实现State和Strategy对象。

8.案例

围棋有黑白两种类型，怎样在棋盘上绘制玩家下的旗子？ 玩家下围棋需要知道是黑方/白方，以及坐标。可以用享元模式，黑棋/白棋绘制可以共享，棋子坐标不需要共享。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//棋子的颜色
enum PieceColor { BLACK, WHTIE };
//棋子的位置
struct PiecePos 
{
	int m_x;
	int m_y;
	PiecePos(int a, int b) :m_x(a), m_y(b) {}
};

class Piece 
{
public:
	Piece(PieceColor color) : m_color(color) {}
	~Piece() {}
	virtual void draw() {}
protected:
	PieceColor m_color;
};

class BlackPiece :public Piece 
{
public:
	BlackPiece(PieceColor color) :Piece(color) {}
	~BlackPiece() {}
	void draw() { cout << "绘制一个黑棋 " << endl; }
};

class WhitePiece :public Piece 
{
public:
	WhitePiece(PieceColor color) :Piece(color) {}
	~WhitePiece() {}
	void draw() { cout << "绘制一个白棋 " << endl; }
};

class PieceBoard 
{
public:
	PieceBoard(string black, string white) :m_blackName(black), m_WhiteName(white) 
	{
		m_pBlackPiece = nullptr;
		m_pWhitePiece = nullptr;
	}
	~PieceBoard()
	{
		clear();
	}
	void setPiece(PieceColor color, PiecePos pos) 
	{
		if (color == BLACK) 
		{
			if(m_pBlackPiece == nullptr)
				m_pBlackPiece = new BlackPiece(color);
			
			cout << m_blackName << "在" << pos.m_x << "," << pos.m_y << "下了一步" << endl;
			m_pBlackPiece->draw();
		}
		else 
		{
			if(m_pWhitePiece == nullptr)
			    m_pWhitePiece = new WhitePiece(color);
			
			
			cout << m_WhiteName << "在" << pos.m_x << "," << pos.m_y << "下了一步" << endl;
			m_pWhitePiece->draw();
		}
		m_vecPiece.push_back(pos);
	}
	void clear() 
	{
		delete m_pBlackPiece;
		delete m_pWhitePiece;
	}
private:
	vector<PiecePos> m_vecPiece;//棋盘上的棋子,
	string m_blackName;
	string m_WhiteName;
	Piece* m_pBlackPiece;
	Piece* m_pWhitePiece;
};

int main(void) 
{
	PieceBoard pieceBoard("laoxia", "laoding");
	pieceBoard.setPiece(BLACK, PiecePos(44, 37));
	pieceBoard.setPiece(WHTIE, PiecePos(19, 70));
	pieceBoard.setPiece(BLACK, PiecePos(1, 1));
	pieceBoard.setPiece(WHTIE, PiecePos(2, 2));
	system("pause");
	return 0;
}

设计模式系列 https://blog.csdn.net/nie2314550441/article/details/105849726