设计模式--享元模式（Flyweight Pattern）

享元模式（Flyweight Pattern）是一种结构型设计模式，它的主要目的是用共享技术有效地支持大量细粒度的对象。

享元模式主要包含以下几个角色：

1. Flyweight（抽象享元类）：定义一个接口，通过这个接口flyweight可以接受并作用于外部状态。
2. ConcreteFlyweight（具体享元类）：实现Flyweight接口，并为内部状态（如果有的话）增加存储空间。ConcreteFlyweight对象必须是可共享的，它所存储的状态必须是内部的。
3. UnsharedConcreteFlyweight（不可共享的具体享元类）：并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。
4. FlyweightFactory（享元工厂类）：创建并管理flyweight对象。它确保flyweight被正确地共享。

享元模式的主要优点是：

• 大大减少了对象的创建，降低了程序内存的占用，提高性能。

享元模式适用于以下场景：

• 当一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用。
• 对象的大多数状态都可变为外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。

以下是一个简单的C++实现的享元模式（Flyweight Pattern）示例：

#include 
#include 

// 抽象享元类
class Flyweight {
public:
    virtual void operation(int extrinsicState) = 0;
    virtual ~Flyweight() {}
};

// 具体享元类
class ConcreteFlyweight : public Flyweight {
public:
    void operation(int extrinsicState) override {
        std::cout << "Concrete Flyweight: " << extrinsicState << std::endl;
    }
};

// 享元工厂类
class FlyweightFactory {
public:
    Flyweight* getFlyweight(const std::string& key) {
        if (flyweights.find(key) != flyweights.end()) {
            return flyweights[key];
        } else {
            Flyweight* flyweight = new ConcreteFlyweight();
            flyweights[key] = flyweight;
            return flyweight;
        }
    }

private:
    std::map<std::string, Flyweight*> flyweights;
};

int main() {
    int extrinsicState = 22;

    FlyweightFactory* factory = new FlyweightFactory();

    Flyweight* fx = factory->getFlyweight("X");
    fx->operation(--extrinsicState);

    Flyweight* fy = factory->getFlyweight("Y");
    fy->operation(--extrinsicState);

    Flyweight* fz = factory->getFlyweight("Z");
    fz->operation(--extrinsicState);

    delete factory;

    return 0;
}
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

在这个例子中，Flyweight是抽象享元类，定义了一个operation接口。ConcreteFlyweight是具体享元类，实现了operation接口。
FlyweightFactory是享元工厂类，它维护了一个对Flyweight对象的引用。当客户端请求一个Flyweight时，FlyweightFactory会检查是否已经创建了一个具有相同状态的Flyweight对象，如果有，就返回这个已经存在的对象，如果没有，就创建一个新的Flyweight对象。
通过这种方式，我们可以使得大量具有相同状态的对象共享同一个Flyweight对象，从而节省内存空间。