设计模式 享元模式

1、character.h

#ifndef CHARACTER_H
#define CHARACTER_H

#include <iostream>
using namespace std;

class Character // Flyweight,是享元抽象基类
{
public:
virtual ~Character(){};
virtual void SetSize(int, int) = 0;//Flyweight::Operation,是公共接口
virtual void Display() = 0;//Flyweight::Operation,是公共接口
protected:
Character(){};
char mCharSymbol;
int mWeight;
int mHeight;
};
#endif // CHARACTER_H
2、charactera.h

#ifndef CHARACTERA_H
#define CHARACTERA_H

#include "character.h"

class CharacterA : public Character //ConcreteFlyweight,是具体享元类
{
public:
CharacterA();
virtual ~CharacterA();
void SetSize(int , int);
void Display();
};

CharacterA::CharacterA()
{
this->mCharSymbol = 'A';
this->mWeight = 100;
this->mHeight = 200;
}

CharacterA::~CharacterA(){}

void CharacterA::SetSize(int nWeight, int nHeight)
{
this->mWeight = nWeight;
this->mHeight = nHeight;
}

void CharacterA::Display()
{
cout << "CharacterA：" << mCharSymbol << "(" << mWeight << "," << mHeight << ")" << endl;
}
#endif // CHARACTERA_H
3、characterb.h

#ifndef CHARACTERB_H
#define CHARACTERB_H

#include "character.h"

class CharacterB : public Character //ConcreteFlyweight,是具体享元类
{
public:
CharacterB();
virtual ~CharacterB();
void SetSize(int, int);
void Display();
};

CharacterB::CharacterB()
{
this->mCharSymbol = 'B';
this->mWeight = 100;
this->mHeight = 200;
}

CharacterB::~CharacterB(){}

void CharacterB::SetSize(int nWeight, int nHeight)
{
this->mWeight = nWeight;
this->mHeight = nHeight;
}

void CharacterB::Display()
{
cout << "CharacterB：" << mCharSymbol << "(" << mWeight << "," << mHeight << ")" << endl;
}

#endif // CHARACTERB_H
4-1、characterfactory.h

#ifndef CHARACTERFACTORY_H
#define CHARACTERFACTORY_H

#include "character.h"
#include <map>

class CharacterFactory //FlyweightFactory,是享元工厂
{
public:
CharacterFactory();
virtual ~CharacterFactory();
Character* GetCharacter(char);
private:
std::map<char, Character*> mChar;
};

#endif // CHARACTERFACTORY_H
4-2、characterfactory.cpp

#include "characterfactory.h"
#include "charactera.h"
#include "characterb.h"

CharacterFactory::CharacterFactory()
{
mChar.insert(make_pair<char, Character*>('A', new CharacterA));
mChar.insert(make_pair<char, Character*>('B', new CharacterB));
}

CharacterFactory::~CharacterFactory(){}

Character* CharacterFactory::GetCharacter(char chIn)
{
map<char, Character*>::iterator it = mChar.find(chIn);
if(it != mChar.end())
{
return (Character*)it->second;
}
return NULL;
}
5、main.cpp

/*
作者：jhluroom弹   QQ：454676244  MSN：jhlu0815@hotmail.com
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

定义：
享元（Flyweight）模式是指，运用共享技术有效地支持大量细粒度的对象。

理解：
1.Flyweight是享元抽象基类。Flyweight::Operation是公共接口，享元依赖的外部状态（ExtrinsicState）通过接口参数传入。
2.ConcreteFlyweight是具体享元类。具体享元必须是可共享的，必须为内部状态（IntrinsicState）提供存储空间。
3.UnshareConcreteFlyweight是不可共享的具体享元，也叫做复合享元。复合享元是由单纯具体享元通过复合（Composite）
模式而成的,将若干个具体享元作为子节点。
4.FlyweightFactory是享元工厂。创建并管理享元对象。当Client请求一个享元对象时，FlyweightFactory返回一个已创建的
享元对象（如果没有就先创建）。
5.Client维护一个指向Flyweight的指针，并且存储Flyweight的外部状态。

要点：
1.一个应用程序使用了大量相同的对象。对于相同的对象只需要共享一份就可以了。
如文本文档中字符对象就会大量存在，如果不使用享元模式，就要使用大量的对象，将会耗费大量的存储开销。
2.对于文本文档的字符对象，字符代码是内部状态，字体字号大小排版位置等是外部状态。对象的大多数状态都可变为外部状态。
3.外部状态可以由一个单独的外部对象来存储。如文本文档，外部对象存储文档的排版信息。

应用：
以一个文本编辑器的例子来说明，在文本编辑器中经常要输入大量的重复字符，例如在文本中输入AAABBAABB......，这时AB大量重复出现，
这些字符可能只是某些属性不一样，若每次输入时都重新实例化一个字符，那么在内存空间中将存在大量的字符对象，
此时若利用享元模式将重复的字符进行共享，每次输入时都从共享单元中取出字符，并且对其进行相应的属性设置，那么就节省了很多空间。

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "character.h"
#include "characterfactory.h"

int main(int argc, char *argv[])
{
cout << "=== jhluroom start ========" << endl;

//Client,维护一个指向Flyweight的指针，并且存储Flyweight的外部状态。
CharacterFactory* pFactory = new CharacterFactory();
Character* pChar;

pChar = pFactory->GetCharacter('A');
pChar->Display();

pChar = pFactory->GetCharacter('B');
pChar->SetSize(300, 400);
pChar->Display();

cout << "=== jhluroom finish _^_ ===" << endl;
}

运行结果：

=== jhluroom start ========

CharacterA：A(100,200)

CharacterB：B(300,400)
=== jhluroom finish _^_ ===