享元模式

最新推荐文章于 2025-01-16 21:46:39 发布

你一身傲骨怎能输

最新推荐文章于 2025-01-16 21:46:39 发布

阅读量374

点赞数 3

分类专栏：设计模式文章标签：享元模式 c++ 算法

本文链接：https://blog.csdn.net/qq_33060405/article/details/141125030

版权

设计模式专栏收录该内容

20 篇文章 1 订阅

订阅专栏

享元模式（Flyweight Pattern）是一种结构型设计模式，它通过共享大量细粒度对象来减少内存使用和提高性能。享元模式的核心思想是将对象的状态分为内部状态和外部状态，内部状态是可以共享的，而外部状态是每个对象独有的。

为了生动形象地解释享元模式，我们可以用一个日常生活中的例子来说明：假设我们要设计一个文字处理器，它需要显示大量的字符。每个字符都有相同的字体、大小和颜色，但它们的位置和内容是不同的。

场景描述

想象一下，你正在设计一个文字处理器，它需要显示大量的字符。每个字符都有相同的字体、大小和颜色，但它们的位置和内容是不同的。如果我们为每个字符都创建一个独立的对象，这将会占用大量的内存。为了节省内存，我们可以使用享元模式，将字符的共享部分（字体、大小、颜色）提取出来，作为内部状态，而将字符的独有部分（位置、内容）作为外部状态。

享元模式的类图

+----------------+       +----------------+
| Flyweight      |       | FlyweightFactory|
|----------------|       |----------------|
| + operation()  |       | + getFlyweight()|
+----------------+       +----------------+
        ^                        ^
        |                        |
+----------------+       +----------------+
| ConcreteFlyweight |       | Client        |
|----------------|       |----------------|
| - intrinsicState |       | - flyweights   |
| + operation()  |       | + operation()  |
+----------------+       +----------------+

代码示例：文字处理器

#include <iostream>
#include <unordered_map>
#include <memory>
#include <string>

// 享元接口
class Flyweight {
public:
    virtual void operation(int extrinsicState) const = 0;
    virtual ~Flyweight() = default;
};

// 具体享元类
class ConcreteFlyweight : public Flyweight {
public:
    explicit ConcreteFlyweight(const std::string& intrinsicState) : intrinsicState(intrinsicState) {}
    void operation(int extrinsicState) const override {
        std::cout << "Intrinsic State: " << intrinsicState << ", Extrinsic State: " << extrinsicState << std::endl;
    }
private:
    std::string intrinsicState;
};

// 享元工厂类
class FlyweightFactory {
public:
    std::shared_ptr<Flyweight> getFlyweight(const std::string& key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = std::make_shared<ConcreteFlyweight>(key);
        }
        return flyweights[key];
    }
private:
    std::unordered_map<std::string, std::shared_ptr<Flyweight>> flyweights;
};

// 客户端代码
int main() {
    FlyweightFactory factory;
    std::shared_ptr<Flyweight> flyweightA = factory.getFlyweight("A");
    std::shared_ptr<Flyweight> flyweightB = factory.getFlyweight("B");
    std::shared_ptr<Flyweight> flyweightC = factory.getFlyweight("A"); // 共享已有的对象

    flyweightA->operation(1);
    flyweightB->operation(2);
    flyweightC->operation(3);

    return 0;
}

解释

享元接口（Flyweight）：定义了一个操作方法 operation()，所有具体的享元类都需要实现这个方法。
具体享元类（ConcreteFlyweight）：实现了享元接口，并包含了可以共享的内部状态 intrinsicState。在 operation() 方法中，它使用内部状态和外部状态来执行操作。
享元工厂类（FlyweightFactory）：负责创建和管理享元对象。它维护一个享元对象的缓存池，当客户端请求一个享元对象时，工厂会检查缓存池中是否已有该对象，如果有则返回已有的对象，如果没有则创建一个新的对象并添加到缓存池中。
客户端代码：客户端通过享元工厂获取享元对象，并调用享元对象的 operation() 方法来执行操作。

享元模式的工作原理

享元模式通过将对象的状态分为内部状态和外部状态来实现对象的共享。内部状态是可以共享的，而外部状态是每个对象独有的。享元工厂负责创建和管理享元对象，并通过缓存池来实现对象的共享。

获取享元对象：客户端通过享元工厂获取享元对象。
检查缓存池：享元工厂检查缓存池中是否已有该对象。
创建新对象：如果缓存池中没有该对象，享元工厂创建一个新的享元对象，并将其添加到缓存池中。
返回享元对象：享元工厂返回享元对象，客户端使用该对象执行操作。

客户端代码

在客户端代码中，我们通过享元工厂获取享元对象，并调用享元对象的 operation() 方法来执行操作。

int main() {
    FlyweightFactory factory;
    std::shared_ptr<Flyweight> flyweightA = factory.getFlyweight("A");
    std::shared_ptr<Flyweight> flyweightB = factory.getFlyweight("B");
    std::shared_ptr<Flyweight> flyweightC = factory.getFlyweight("A"); // 共享已有的对象

    flyweightA->operation(1);
    flyweightB->operation(2);
    flyweightC->operation(3);

    return 0;
}

运行结果

Intrinsic State: A, Extrinsic State: 1
Intrinsic State: B, Extrinsic State: 2
Intrinsic State: A, Extrinsic State: 3

总结

通过这个文字处理器的示例，我们可以看到享元模式的工作原理和应用场景。享元模式通过共享大量细粒度对象来减少内存使用和提高性能。

享元模式的优点

减少内存使用：通过共享对象，减少了内存的使用。
提高性能：减少了对象的创建和销毁，提高了系统的性能。

享元模式的缺点

复杂性增加：需要分离内部状态和外部状态，增加了系统的复杂性。
不适用于所有场景：享元模式适用于有大量相似对象的场景，对于对象数量较少的场景，使用享元模式可能得不偿失。

享元模式的应用场景

文字处理器：用于显示大量的字符，每个字符的字体、大小和颜色相同，但位置和内容不同。
图形编辑器：用于显示大量的图形对象，每个图形对象的形状和颜色相同，但位置和大小不同。
游戏开发：用于显示大量的游戏对象，每个游戏对象的外观相同，但位置和状态不同。

通过这个生动形象的例子，希望你对享元模式有了更深入的理解。在实际应用中，可以根据具体需求选择合适的设计模式，并结合使用以实现更复杂的功能。
好的，我们继续深入探讨享元模式，进一步了解其应用和实现细节。

享元模式的内部状态和外部状态

在享元模式中，内部状态和外部状态的区分是关键。内部状态是可以共享的，不会随环境改变而改变的状态；外部状态是每个对象独有的，会随环境改变而改变的状态。

内部状态

定义：内部状态是享元对象中可以共享的部分，不会随环境改变而改变。
特点：内部状态通常是固定的，可以在多个对象之间共享。
示例：在文字处理器的例子中，字符的字体、大小和颜色就是内部状态。

外部状态

定义：外部状态是享元对象中不能共享的部分，会随环境改变而改变。
特点：外部状态通常是动态的，每个对象都有自己独特的外部状态。
示例：在文字处理器的例子中，字符的位置和内容就是外部状态。

享元模式的优化策略

为了更好地理解享元模式的优化策略，我们可以通过一个更复杂的示例来说明：假设我们要设计一个图形编辑器，它需要显示大量的图形对象（如圆形、矩形、线条等）。每个图形对象都有相同的颜色和线条粗细，但它们的位置和大小是不同的。

类图

+----------------+       +----------------+
| Flyweight      |       | FlyweightFactory|
|----------------|       |----------------|
| + operation()  |       | + getFlyweight()|
+----------------+       +----------------+
        ^                        ^
        |                        |
+----------------+       +----------------+
| ConcreteFlyweight |       | Client        |
|----------------|       |----------------|
| - intrinsicState |       | - flyweights   |
| + operation()  |       | + operation()  |
+----------------+       +----------------+

代码示例：图形编辑器

#include <iostream>
#include <unordered_map>
#include <memory>
#include <string>

// 享元接口
class Flyweight {
public:
    virtual void operation(int x, int y, int width, int height) const = 0;
    virtual ~Flyweight() = default;
};

// 具体享元类
class ConcreteFlyweight : public Flyweight {
public:
    explicit ConcreteFlyweight(const std::string& intrinsicState) : intrinsicState(intrinsicState) {}
    void operation(int x, int y, int width, int height) const override {
        std::cout << "Intrinsic State: " << intrinsicState 
                  << ", Position: (" << x << ", " << y << ")"
                  << ", Size: (" << width << ", " << height << ")" << std::endl;
    }
private:
    std::string intrinsicState;
};

// 享元工厂类
class FlyweightFactory {
public:
    std::shared_ptr<Flyweight> getFlyweight(const std::string& key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = std::make_shared<ConcreteFlyweight>(key);
        }
        return flyweights[key];
    }
private:
    std::unordered_map<std::string, std::shared_ptr<Flyweight>> flyweights;
};

// 客户端代码
int main() {
    FlyweightFactory factory;
    std::shared_ptr<Flyweight> circle = factory.getFlyweight("Circle");
    std::shared_ptr<Flyweight> rectangle = factory.getFlyweight("Rectangle");
    std::shared_ptr<Flyweight> line = factory.getFlyweight("Line");

    circle->operation(10, 20, 30, 30);
    rectangle->operation(50, 60, 100, 50);
    line->operation(70, 80, 150, 5);

    return 0;
}

解释

享元接口（Flyweight）：定义了一个操作方法 operation()，所有具体的享元类都需要实现这个方法。
具体享元类（ConcreteFlyweight）：实现了享元接口，并包含了可以共享的内部状态 intrinsicState。在 operation() 方法中，它使用内部状态和外部状态来执行操作。
享元工厂类（FlyweightFactory）：负责创建和管理享元对象。它维护一个享元对象的缓存池，当客户端请求一个享元对象时，工厂会检查缓存池中是否已有该对象，如果有则返回已有的对象，如果没有则创建一个新的对象并添加到缓存池中。
客户端代码：客户端通过享元工厂获取享元对象，并调用享元对象的 operation() 方法来执行操作。

享元模式的工作原理

获取享元对象：客户端通过享元工厂获取享元对象。
检查缓存池：享元工厂检查缓存池中是否已有该对象。
创建新对象：如果缓存池中没有该对象，享元工厂创建一个新的享元对象，并将其添加到缓存池中。
返回享元对象：享元工厂返回享元对象，客户端使用该对象执行操作。

客户端代码

在客户端代码中，我们通过享元工厂获取享元对象，并调用享元对象的 operation() 方法来执行操作。

int main() {
    FlyweightFactory factory;
    std::shared_ptr<Flyweight> circle = factory.getFlyweight("Circle");
    std::shared_ptr<Flyweight> rectangle = factory.getFlyweight("Rectangle");
    std::shared_ptr<Flyweight> line = factory.getFlyweight("Line");

    circle->operation(10, 20, 30, 30);
    rectangle->operation(50, 60, 100, 50);
    line->operation(70, 80, 150, 5);

    return 0;
}

运行结果

Intrinsic State: Circle, Position: (10, 20), Size: (30, 30)
Intrinsic State: Rectangle, Position: (50, 60), Size: (100, 50)
Intrinsic State: Line, Position: (70, 80), Size: (150, 5)