享元模式详解-优快云博客

使用场景
当程序中使用到大量的类似对象实体时，大部分时候会出现内存不够用的情况。此时我们就可以考虑使用享元模式，一般在符合以下几点情况下来使用。1.是大量的对象 2.注重空间消耗而不是时间消耗 3.对象实体存在多种相同的内在属性。
大概思想
根据我所总结的就是将对象的大部分相同属性抽离出来实现一个共同属性结构，而其他的不共同属性保留下来让每个对象独立拥有。然后在使用的时候得先找到特有属性的共用属性结构在执行相应的操作。本质上就是时间换取空间。
示例代码

#pragma once

#include <string>
#include <map>
#include <vector>

struct SharedState
{
	std::string _name;
	std::string _version;

	SharedState(const std::string& name, const std::string& version)
		:_name(name),_version(version)
	{}

	SharedState(const SharedState& ss) :_name(ss._name), _version(ss._version)
	{}

	friend void info(std::ostream& os, SharedState* ss);

};

void info(std::ostream& os, SharedState* ss)
{
	os << ss->_name << " " << ss->_version<<" ";
}

struct UniqueState
{
	std::string _color;
	int _size;

	UniqueState(const std::string& color, int size)
		:_color(color),_size(size)
	{}
};

class FlyWeight
{

public:
	FlyWeight(SharedState* sharedState):_sharedState(new SharedState(*sharedState))
	{}

	FlyWeight(const FlyWeight& flyWeight):_sharedState(new SharedState(*flyWeight._sharedState))
	{}

	~FlyWeight()
	{
		if (_sharedState)
			delete _sharedState;
	}

	void doOperation(const UniqueState& uniqueState)
	{
		if (_sharedState)
			info(std::cout, _sharedState);

		std::cout << uniqueState._color << " " << uniqueState._size << std::endl;;
	}

private:

	SharedState *_sharedState;
};


class FlyWeightFacotry
{
public:
	static FlyWeightFacotry& getInstance()
	{
		static FlyWeightFacotry factory;
		return factory;
	}

	void cache(const std::string& id, FlyWeight* flyWeight)
	{
		_flyWeightMap[id] = flyWeight;
	}

	FlyWeight* getFlyWeight(const std::string& id)

	{
		if (_flyWeightMap.find(id) != _flyWeightMap.end())
			return _flyWeightMap[id];
		else
			return nullptr;
	}

	~FlyWeightFacotry(){
		for (const auto& itr : _flyWeightMap)
		{
			if (itr.second)
				delete itr.second;
		}
	}

private:
	FlyWeightFacotry() = default;
	FlyWeightFacotry(const FlyWeightFacotry& factory) = default;
	FlyWeightFacotry& operator=(const FlyWeightFacotry& factory) = default;


	std::map<std::string, FlyWeight*> _flyWeightMap;
};

void flyWeightTest()
{
	SharedState* ss1 = new SharedState("Product1", "v1.0");
	FlyWeightFacotry::getInstance().cache("v1.0", new FlyWeight(ss1));
	SharedState* ss2 = new SharedState("Product1", "v2.0");
	FlyWeightFacotry::getInstance().cache("v2.0", new FlyWeight(ss2));

	std::vector<UniqueState> uniqueStateVec = {
		{"red", 1},{"green", 2},{"blue", 3},{"white", 4}
	};

	for (const UniqueState& us : uniqueStateVec)
	{
		FlyWeight* fly1 = FlyWeightFacotry::getInstance().getFlyWeight("v1.0");
		if (fly1) fly1->doOperation(us);
		
		FlyWeight* fly2 = FlyWeightFacotry::getInstance().getFlyWeight("v2.0");
		if (fly2) fly2->doOperation(us);
	}

	delete ss1;
	delete ss2;
}