设计模式之十三:Flyweight（享元）—对象结构型模式

2014-06-15 星期日 9:35:04 

Flyweight，继续GOF。

1、Intent

Use sharing to support large numbers of fine-grained objects efficiently.

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

2、Also Known As
3、Motivation

A flyweightis a shared object that can be used in multiple contexts simultaneously. The flyweight acts as an independent object in each context—it‘s indistinguishable from an instance of the object that‘s not shared.

Flyweights cannot make assumptions about the context in which they operate. The key concept here is the distinction between intrinsicand extrinsicstate. Intrinsic state is stored in the flyweight; it consists of information that‘s independent of the flyweight‘s context, thereby making it sharable. Extrinsic state depends on and varies with the flyweight‘s context and therefore can‘t be shared. Client objects are responsible for passing extrinsic state to the flyweight when it needs it.

flyweight是一个共享对象，它可以同时在多个场景 ( context ) 中使用，并且在每个场景中flyweight都可以作为一个独立的对象—这一点与非共享对象的实例没有区别。

flyweight不能对它所运行的场景做出任何假设，这里的关键概念是内部状态和外部状态之间的区别。内部状态存储于 flyweight 中，它包含了独立于 flyweigh t场景的信息，这些信息使得 flyweight 可以被共享。而外部状态取决于 Flyweight场景，并根据场景而变化，因此不可共享。用户对象负责在必要的时候将外部状态传递给 Flyweight。

4、Applicability

The Flyweight pattern‘s effectiveness depends heavily on how and where it‘s used. Apply the Flyweight pattern when allof the following are true:

●  An application uses a large number of objects.

●  Storage costs are high because of the sheer quantity of objects.

●  Most object state can be made extrinsic.

●  Many groups of objects may be replaced by relatively few shared objects once extrinsic state is removed.

●  The application doesn‘t depend on object identity. Since flyweight objects may be shared, identity tests will return true for conceptually distinct objects.

在以下情况使用享元模式：

●  一个应用程序使用了大量的对象。

●  完全由于使用大量的对象，造成很大的存储开销。

●  对象的大多数状态都可变为外部状态。

●  如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。

● 应用程序不依赖于对象标识。由于 F l y w e i g h t对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。

5、Structure

6、代码

代码采用此链接的  http://www.cnblogs.com/jiese/p/3171463.html。Flyweight主要要分出共同和不同的部分。

  • Flyweight.h

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

#ifndef _FLYWEIGHT_H_

#define _FLYWEIGHT_H_

#include <string>

#include <vector>

using namespace std;

//基类，定义操作接口Operation

class Flyweight

{

public:

    //操作外部状态extrinsicState

    virtual void Operation(const string& extrinsicState)=0;

    string GetIntrinsicState();

    virtual ~Flyweight();

protected:

    Flyweight(string intrinsicState);

private:

    //内部状态，也可以放在ConcreteFlyweight中

    string _intrinsicState;

};

class ConcreteFlyweight:public Flyweight

{

public:

    //实现接口函数

    virtual void Operation(const string& extrinsicState);

    ConcreteFlyweight(string intrinsicState);

    ~ConcreteFlyweight();

};

class UnsharedConcreteFlyweight:public Flyweight

{

public:

    virtual void Operation(const string& extrinsicState);

    UnsharedConcreteFlyweight(string intrinsicState);

    ~UnsharedConcreteFlyweight();

};

class FlyweightFactory

{

public:

    FlyweightFactory();

    ~FlyweightFactory();

    //获得一个请求的Flyweight对象

    Flyweight* GetFlyweight(string key);

    //获取容器中存储的对象数量

    void GetFlyweightCount();

protected:

private:

    //保存内部状态对象的容器

    vector<Flyweight*> m_vecFly;

};

#endif
  • Flyweight.cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

#include "Flyweight.h"

#include <iostream>

using namespace std;

Flyweight::Flyweight(string intrinsicState)

{

    this->_intrinsicState = intrinsicState;

}

Flyweight::~Flyweight()

{}

string Flyweight::GetIntrinsicState()

{

    return this->_intrinsicState;

}

ConcreteFlyweight::ConcreteFlyweight(string intrinsicState):Flyweight(intrinsicState)

{

}

ConcreteFlyweight::~ConcreteFlyweight()

{

}

void ConcreteFlyweight::Operation(const string& extrinsicState)

{

    cout << this->GetIntrinsicState() << endl;

    cout << extrinsicState << endl;

}

UnsharedConcreteFlyweight::UnsharedConcreteFlyweight(string intrinsicState):Flyweight(intrinsicState)

{

}

UnsharedConcreteFlyweight::~UnsharedConcreteFlyweight()

{

}

void UnsharedConcreteFlyweight::Operation(const string& extrinsicState)

{

    cout << "extrinsicState" << endl;

}

FlyweightFactory::FlyweightFactory()

{}

FlyweightFactory::~FlyweightFactory()

{}

//若该对象已存在，直接返回，否则新建一个对象，存入容器中，再返回

Flyweight* FlyweightFactory::GetFlyweight(string key)

{

    vector<Flyweight*>::iterator iter = this->m_vecFly.begin();

    for(;iter!= this->m_vecFly.end();iter++)

    {

        if((*iter)->GetIntrinsicState() == key)

        {

            return *iter;

        }

    }

    Flyweight* fly = new ConcreteFlyweight(key);

    this->m_vecFly.push_back(fly);

    return fly;

}

void FlyweightFactory::GetFlyweightCount()

{

    cout << this->m_vecFly.size() << endl;

}
  • main.cpp


    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    #include "Flyweight.h"

    #include <iostream>

    #include <string>

    using namespace std;

    int main()

    {

        //外部状态extrinsicState

        string extrinsicState = "ext";

        //工厂对象，工厂对象

        FlyweightFactory* fc = new FlyweightFactory();

        //向工厂申请一个Flyweight对象，且该对象的内部状态值为“hello”

        Flyweight* fly = fc->GetFlyweight("hello");

        Flyweight* fly1 = fc->GetFlyweight("hello");

        //应用外部状态

        fly->Operation(extrinsicState);

        fc->GetFlyweightCount();

        return 0;

    }
7、与其他模式的区别

来自为知笔记(Wiz)

设计模式之十三:Flyweight（享元）—对象结构型模式

时间： 2024-12-29 23:54:37

设计模式之十三:Flyweight（享元）—对象结构型模式的相关文章

Flyweight 享元（结构型）

一:描述:(该模式实际应用较少) Flyweight 享元模式是对大量细粒度的元素进行共享和重用.减少对象的创建减轻内存: 注和单例模式不同的是:享元模式的各个对象佣有各自的行为并可实例化,单例模式的各个对象佣有一样的行为并不可直接实例化. 二:模式图: 三:实现代码简单例子: 1.创建抽像的享元类 2.创建共享的享元对象(可以有很多这种对像) 3.创建非共享的享元对象 4.创建享元的工厂 5.客端的使用和效果;

设计模式之十四:Decorator（装饰）—对象结构型模式

2014-06-15 星期日 10:42:12  Decorator,继续GOF. 1.Intent Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality 动态地给一个对象添加一些额外的职责.就增加功能来说, Decorator模式相比生成子类更为灵活. 2.A

设计模式之十二:Proxy（代理）—对象结构型模式

2014-05-29 星期四 21:08:37  Proxy,继续GOF.此模式未按GOF编写. c++中使用StringBuilder 1.Intent Provide a surrogate or placeholder for another object to control access to it. 为其他对象提供一种代理以控制对这个对象的访问. 2.Also Known As 3.Motivation 4.Applicability 在以下情况使用适配模式: ● 创建开销大的对象时

设计模式之十一:Composite（组合）—对象结构型模式

2014-05-28 星期三 21:41:44  Composite,继续GOF. Composite组合模式 1.Intent Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. 将对象组合成树形结构以表示"部分 -整体&quo

设计模式（七）：Adapter 适配器模式 -- 结构型模式

1. 概述: 接口的改变,是一个需要程序员们必须(虽然很不情愿)接受和处理的普遍问题.程序提供者们修改他们的代码;系统库被修正;各种程序语言以及相关库的发展和进化.  例子1:iphone4,你即可以使用UBS接口连接电脑来充电,假如只有iphone没有电脑,怎么办呢?苹果提供了iphone电源适配器.可以使用这个电源适配器充电.这个iphone的电源适配器就是类似我们说的适配器模式.(电源适配器就是把电源变成需要的电压,也就是适配器的作用是使得一个东西适合另外一个东西.)  例子2:最典型的例

设计模式11： Flyweight 享元模式（结构型模式）

Flyweight 享元模式(结构型模式) 面向对象的代价 面向对象很好的解决了系统抽象性的问题,同时在大多数情况下也不会损及系统的性能.但是,在某些特殊应用中,由于对象的数量太大,采用面向对象会给系统带来难以承受的内存开销.比如图形应用中的图元等对象.字处理应用中的字符对象等. 动机(Motivation) 采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中,而带来很高的运行代价——主要指内存需求方面的代价. 如何避免大量细粒度对象问题的同时,让外部客户程序仍然能够透明地使用面向对象

Flyweight(享元）--对象结构型模式

1.意图 运用共享技术有效地支持大量细粒度的对象. 2.动机 Flyweight模式描述了如何共享对象,使得可以细粒度地使用它们,而无需高昂的代价.flyweight是一个共享对象,它可以同时在多个场景(context)中使用,并且在每个场景中flyweight都可以作为一个独立的对象---这一点与非共享对象的实例没有区别. 3.适用性 一个应用程序使用了大量的对象. 完全由于使用大量的对象,造成很大的存储开销. 对象的大多数状态都可变为外部状态. 如果删除对象的外部状态,那么可以用相对较少的共

Facade（外观）-对象结构型模式

1.意图 为子系统中的一组接口提供一个一致的接口,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用. 2.动机 将一个系统划分成若干子系统有利于降低系统的复杂性.一个常见的设计目标是使子系统间的通信和相互依赖达到最小.达到该目标的途径之一是引入一个外观对象,它为子系统提供了一个统一的接口. 3.适用性 当要为一个复杂子系统提供一个简单接口时.子系统往往因为不断演化而变得越来越复杂.大多数模式使用时都会产生更多更小的类.这使得子系统更具可重用性,也更容易对子系统进行定制,但这

Composite（组合）--对象结构型模式

1.意图 将对象组合成树形结构以表示"部分-整体"的层次结构.Composite使得用户对单个对象和组合对象的使用具有一致性. 2.动机 可以组合多个简单组件以形成一些较大的组件,这些组件又可以组合成更大的组件.Composite模式描述了如何使用递归组合,使得用户不必对这些类进行区别. 3.适用性 表示对象的部分-整体层次结构. 希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象. 4.结构 5.代码实例 #include <memory> #in