定义

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

使用场景

• 在软件系统采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价——主要指内存需求方面的代价。
• 如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作?

结构

代码示例

//Flyweight.h
/****************************************************/
#ifndef FLYWEIGHT_H
#define FLYWEIGHT_H
#include<iostream>
#include<map>
using namespace std; 
 //享元模式 
 
class Flyweight  //抽象的享元类
{
public :
	virtual void Operator(int i) = 0;
};
 
class ConcreteFlyweight : public Flyweight  //共享的子类
{
public:
	void Operator(int i)
	{
		cout <<"共享的Flyweight： " << i<<endl;
	}
};
 
 
class UnshareConcreteFlyweight : public Flyweight
{
	void Operation(int i)
	{
		cout << "不共享的Flyweight : " << i << endl;
	}
};
 
class FlyweightFactory  //享元工厂
{
private: 
	map<string, Flyweight*> flyweights;  //模块名列表
public:
	FlyweightFactory()
	{
		//这里需要用堆，因为这是给客户程序返回的，如果不用堆，则会返回局部对象的引用
		flyweights["x"] = new ConcreteFlyweight();
		flyweights["y"] = new ConcreteFlyweight();
		flyweights["z"] = new ConcreteFlyweight();//所有的属性为“z”的模块都只对应这个一个实例，这正是享元模式的精髓所在呀
	}
	Flyweight* GetFlyWeight(string key)
	{
		if (!flyweights.count(key))
			flyweights[key] = new ConcreteFlyweight();
		return flyweights[key];
	}
	map<string, Flyweight*>::size_type CountN()//返回当前可共享的模块数
	{
		return flyweights.size();
	}
 
};


#endif

//test.cpp
/****************************************************/
#include "Flyweight.h"
int main()
{
	int i = 100;
	FlyweightFactory f;//整个过程采用一个工厂
 
	Flyweight *px = f.GetFlyWeight("x");//获取x对应的模块
	px->Operator(--i);
 
	Flyweight* py = f.GetFlyWeight("y");//获取x对应的模块
	py->Operator(--i);
 
	Flyweight* pz = f.GetFlyWeight("a");//a不在初始化的表中
	pz->Operator(--i);
	//原来就有 x,y,z  加上现在的a 一共4个 
	cout << "可共享的模块："<<f.CountN() <<"个!" << endl;
 
	delete px;
	delete py;
	delete pz;
	px = py = pz = NULL;
	
	return 0;
}

运行结果

要点总结

• 面向对象很好地解决了抽象性的问题，但是作为一个运行在机器中的程序实体，我们需要考虑对象的代价问题。Flyweight主要解决面向对象的代价问题，一般不触及面向对象的抽象性问题。
• Flyweight采用对象共享的做法来降低系统中对象的个数,从而降低细粒度对象给系统带来的内存压力。在具体实现方面，要注意对象状态的处理。
• 对象的数量太大从而导致对象内存开销加大——什么样的数量才算大?这需要我们仔细的根据具体应用情况进行评估，而不能凭空臆断。