1 享元模式的基本概念
享元模式（Flyweight Pattern）是一种主要用于减少创建对象的数量，以减少内存占用和提高性能的设计模式。它通过使用共享对象来支持大量的细粒度对象，从而减少了内存占用。在享元模式中，有些对象可以被多个客户端共享，以减少创建对象的数量。享元模式的核心在于享元工厂类，它负责创建和管理享元对象，并提供对外访问的接口。
享元模式主要适用于以下情况：
- 系统中存在大量的相似对象，这些对象消耗了大量的内存资源。
- 大部分的对象可以按照内在状态进行分组，并且可将分组对象中的一部分外部状态存储在享元对象中，而将其余的部分外部状态在需要时由外部传入。
- 系统不依赖于这些对象身份，这些对象是不可分辨的。
在 C++ 中实现享元模式，需要设计以下部分：
- 抽象享元类（Flyweight）：定义出对象的外部状态接口，让其子类可以接收外部状态并影响其行为。
- 具体享元类（ConcreteFlyweight）：实现抽象享元类定义的方法，并为其内部状态增加存储空间。
- 享元工厂类（FlyweightFactory）：负责创建和管理享元对象，它提供一个用于存储享元对象的享元池，在用户请求一个享元对象时，享元工厂首先检查享元池中是否存在符合要求的享元对象，如果存在则直接返回，否则创建一个新的享元对象并添加到享元池中。
2 享元模式的实现步骤
享元模式的实现步骤如下：
（1）定义抽象享元类（Flyweight）：
创建一个抽象基类，定义享元对象的接口。
这个接口应该包括操作享元对象内部状态的方法，以及可能设置或获取外部状态的方法。
抽象享元类通常不包含与具体实现相关的数据成员，它仅定义了一个通用的接口。
（2）实现具体享元类（ConcreteFlyweight）：
继承自抽象享元类，并实现其接口。
具体享元类包含享元对象的内部状态，这些内部状态在多个享元实例之间是共享的。
实现具体的业务逻辑，这些逻辑可能会依赖于外部状态。
（3）创建享元工厂类（FlyweightFactory）：
设计一个工厂类，用于创建和管理享元对象。
工厂类内部维护一个享元对象的集合（通常是一个哈希表或字典），用于存储已经创建的享元对象。
提供获取享元对象的方法，当请求某个享元对象时，工厂类首先检查集合中是否存在该对象，如果存在则直接返回，否则创建新的享元对象并添加到集合中。
（4）定义外部状态：
享元模式的关键在于将对象的状态分为内部状态和外部状态。
内部状态是存储在享元对象内部，并在多个对象中共享的状态。
外部状态是依赖于具体上下文的状态，通常在运行时通过参数传递给享元对象的方法。
（5）客户端代码使用享元对象：
客户端代码通过享元工厂获取享元对象，而不是直接创建享元对象。
在使用享元对象时，客户端需要传递必要的外部状态给享元对象的方法。
客户端不应直接访问享元对象的内部状态，而是应该通过享元对象提供的接口进行操作。
（1）优化与扩展：
根据需要，可以对享元工厂进行扩展，比如支持配置不同的享元对象池大小、缓存策略等。
对于复杂的系统，可能需要设计多个抽象享元类和具体享元类，以适应不同的业务场景。
如下为样例代码：
#include <iostream>
#include <unordered_map>
#include <memory>
#include <string>
// 抽象享元类
class Flyweight {
public:
virtual ~Flyweight() = default;
virtual void operation(const std::string& extrinsicState) = 0;
};
// 具体享元类
class ConcreteFlyweight : public Flyweight {
public:
ConcreteFlyweight(const std::string& state) : intrinsicState(state) {}
void operation(const std::string& extrinsicState) override {
std::cout << "Intrinsic: " << intrinsicState << ", Extrinsic: " << 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> fw1 = factory.getFlyweight("A");
fw1->operation("X"); // 输出: Intrinsic: A, Extrinsic: X
std::shared_ptr<Flyweight> fw2 = factory.getFlyweight("A");
fw2->operation("Y"); // 输出: Intrinsic: A, Extrinsic: Y
// 注意：fw1 和 fw2 指向同一个享元对象
std::shared_ptr<Flyweight> fw3 = factory.getFlyweight("B");
fw3->operation("Z"); // 输出: Intrinsic: B, Extrinsic: Z
return 0;
}
上面代码的输出为：
Intrinsic: A, Extrinsic: X
Intrinsic: A, Extrinsic: Y
Intrinsic: B, Extrinsic: Z
在这个示例中，Flyweight 是一个抽象基类，定义了一个操作享元对象的方法 operation。ConcreteFlyweight 是具体的享元类，它继承了 Flyweight 并实现了 operation 方法。它有一个内部状态 intrinsicState，该状态在多个享元实例之间是共享的。
FlyweightFactory 是享元工厂类，它使用 std::unordered_map 存储了享元对象的 std::shared_ptr。getFlyweight 方法负责获取或创建享元对象，并返回其 std::shared_ptr。
在 main 函数中，客户端代码通过 FlyweightFactory 获取享元对象，并调用其 operation 方法。由于使用了 std::shared_ptr，享元对象的生命周期由智能指针管理，当没有引用指向享元对象时，它会被自动删除。
通过这种方式，即使多次调用 getFlyweight 请求同一个享元对象，也只会创建一个 ConcreteFlyweight 实例，并且其生命周期由 std::shared_ptr 智能管理，避免了不必要的内存分配和释放。
3 享元模式的应用场景
在 C++ 中，享元模式的应用场景主要出现在需要处理大量相似或重复对象，且这些对象的内存占用较大时。通过共享这些对象的状态，享元模式能够显著减少内存消耗，并提高系统的性能。
具体来说，以下是一些 C++ 中享元模式的应用场景：
图形界面开发：在图形用户界面中，可能需要大量的按钮、图标或其他 UI 元素。这些元素通常具有相似的外观和行为，但数量众多。通过应用享元模式，可以共享这些元素的内部状态，减少内存占用。
字符串处理：在 C++ 中，字符串的创建和销毁是一个常见的性能瓶颈。使用享元模式，可以设计一个字符串缓存池，对于相同的字符串，只在缓存池中保留一份实例，多次使用时直接引用该实例，避免了重复的创建和销毁操作。
数据库连接池：在数据库应用中，频繁地创建和关闭数据库连接会消耗大量的系统资源。通过使用享元模式实现连接池，可以复用已建立的数据库连接，提高系统性能和稳定性。
总的来说，享元模式在 C++ 中的应用场景主要是那些需要处理大量相似或重复对象，且内存消耗成为性能瓶颈的情况。通过共享对象的状态，享元模式能够优化内存使用，提高系统的整体性能。
游戏开发：在游戏中，经常需要创建大量的相似对象，如棋子、怪物、子弹等。这些对象可能具有相同的属性或行为，但由于数量众多，如果每个对象都单独创建，将会占用大量的内存。使用享元模式，可以将这些对象的共享部分提取出来，只保留一份实例，从而大大减少内存消耗。
3.1 享元模式应用于图形界面开发
在图形界面开发中，享元模式可以用于减少界面元素的内存占用，特别是当界面包含大量相似或重复的元素时。以下是一个简单的示例，展示了如何在图形界面开发中使用享元模式，并利用智能指针来管理对象生命周期。
#include <iostream>
#include <memory>
#include <unordered_map>
#include <string>
// 抽象享元类
class GUIElementFlyweight {
public:
virtual ~GUIElementFlyweight() = default;
virtual void draw() const = 0;
};
// 具体享元类
class ButtonFlyweight : public GUIElementFlyweight {
public:
ButtonFlyweight(const std::string& label) : label(label) {}
void draw() const override {
std::cout << "Drawing button with label: " << label << std::endl;
}
private:
std::string label;
// 这里可以添加更多的共享状态
};
// 享元工厂类
class GUIElementFlyweightFactory {
public:
std::shared_ptr<GUIElementFlyweight> getFlyweight(const std::string& label) {
if (flyweights.find(label) == flyweights.end()) {
flyweights[label] = std::make_shared<ButtonFlyweight>(label);
}
return flyweights[label];
}
private:
std::unordered_map<std::string, std::shared_ptr<GUIElementFlyweight>> flyweights;
};
// 客户端代码
int main()
{
GUIElementFlyweightFactory factory;
// 获取并绘制按钮
std::shared_ptr<GUIElementFlyweight> button1 = factory.getFlyweight("Save");
button1->draw(); // 输出: Drawing button with label: Save
std::shared_ptr<GUIElementFlyweight> button2 = factory.getFlyweight("Save");
button2->draw(); // 输出: Drawing button with label: Save
// 注意：button1 和 button2 指向同一个享元对象
std::shared_ptr<GUIElementFlyweight> button3 = factory.getFlyweight("Cancel");
button3->draw(); // 输出: Drawing button with label: Cancel
return 0;
}
上面代码的输出为：
Drawing button with label: Save
Drawing button with label: Save
Drawing button with label: Cancel
在上面代码中：
- GUIElementFlyweight 是抽象享元类，定义了图形界面元素应该有的行为（在这里是 draw 方法）。
ButtonFlyweight 是具体享元类，继承自 GUIElementFlyweight，代表一个具体的按钮元素，并实现了 draw 方法。 - GUIElementFlyweightFactory 是享元工厂类，它维护了一个哈希表来存储已创建的享元对象。当客户端请求一个享元对象时，工厂首先检查哈希表中是否存在具有相同标签的享元对象，如果存在则直接返回，否则创建一个新的享元对象并添加到哈希表中。
- 在 main 函数中，创建了享元工厂的一个实例，并通过它获取了几个按钮享元对象。这些对象被存储在 std::shared_ptr 智能指针中，当没有引用指向它们时，它们会被自动删除。
通过这个示例，可以看到享元模式如何帮助我们复用相似的图形界面元素，减少了内存的消耗。在实际应用中，draw 方法可能会涉及更复杂的渲染逻辑，而享元对象也可能包含更多的共享状态。但基本的原理是一样的：通过共享对象的状态来减少内存占用。
3.2 享元模式应用于字符串处理
在字符串处理中，享元模式可以应用于缓存和复用频繁使用的字符串对象，以减少内存分配和释放的开销。下面是一个简单的示例，展示了如何使用享元模式来处理字符串，并使用智能指针来管理字符串对象的生命周期。
#include <iostream>
#include <memory>
#include <unordered_map>
#include <string>
// 抽象享元类
class StringFlyweight {
public:
virtual ~StringFlyweight() = default;
virtual void display() const = 0;
// 可能还有其他的方法或属性
};
// 具体享元类
class StringFlyweightImpl : public StringFlyweight {
public:
StringFlyweightImpl(const std::string& value) : value(value) {}
void display() const override {
std::cout << "String: " << value << std::endl;
}
// 可能还有其他方法，比如获取字符串值等
private:
std::string value;
};
// 享元工厂类
class StringFlyweightFactory {
public:
std::shared_ptr<StringFlyweight> getFlyweight(const std::string& value) {
auto it = flyweights.find(value);
if (it == flyweights.end()) {
// 创建一个新的享元对象并添加到缓存中
flyweights[value] = std::make_shared<StringFlyweightImpl>(value);
it = flyweights.find(value); // 更新迭代器位置
}
return it->second;
}
private:
std::unordered_map<std::string, std::shared_ptr<StringFlyweight>> flyweights;
};
// 客户端代码
int main()
{
StringFlyweightFactory factory;
// 获取并显示字符串享元对象
std::shared_ptr<StringFlyweight> str1 = factory.getFlyweight("Hello");
str1->display(); // 输出: String: Hello
std::shared_ptr<StringFlyweight> str2 = factory.getFlyweight("Hello");
str2->display(); // 输出: String: Hello
// 注意：str1 和 str2 指向同一个享元对象
std::shared_ptr<StringFlyweight> str3 = factory.getFlyweight("World");
str3->display(); // 输出: String: World
return 0;
}
上面代码的输出为：
String: Hello
String: Hello
String: World
在上面代码中：
- StringFlyweight 是抽象享元类，定义了字符串对象应该有的行为（在这里是 display 方法）。
- StringFlyweightImpl 是具体享元类，继承自 StringFlyweight，并实现了 display 方法来显示字符串的内容。
- StringFlyweightFactory 是享元工厂类，它维护了一个哈希表来存储已创建的字符串享元对象。当客户端请求一个字符串享元对象时，工厂首先检查哈希表中是否存在具有相同值的字符串享元对象，如果存在则直接返回，否则创建一个新的享元对象并添加到哈希表中。
- 在 main 函数中，我们创建了享元工厂的一个实例，并通过它获取了几个字符串享元对象。这些对象被存储在 std::shared_ptr 智能指针中，当没有引用指向它们时，它们会被自动删除。
通过这个示例，可以看到享元模式如何帮助我们复用频繁使用的字符串对象，减少了内存分配和释放的开销。
4 享元模式的优点与缺点
C++ 享元模式的优点主要包括：
（1）减少内存使用： 这是享元模式最显著的优点。通过共享对象的状态，可以减少系统中相似对象的数量，从而显著减少内存占用。这在处理大量相似对象时尤其有效，如界面上的大量相似按钮或大量重复使用的字符串等。
（2）提高性能： 由于减少了对象的创建和销毁次数，享元模式可以提高系统的性能。频繁地创建和销毁对象会带来一定的性能开销，而享元模式通过共享对象避免了这种开销。
（3）易于管理： 享元模式通常与工厂模式结合使用，通过工厂来创建和管理享元对象。这使得对象的创建和使用更加统一和集中，便于管理和维护。
然而，C++ 享元模式也存在一些缺点：
（1）增加了系统复杂性： 引入享元模式会增加系统的复杂性。需要设计额外的享元工厂类来管理享元对象，还需要处理享元对象的状态共享问题。这可能会增加代码量和开发难度。
（1）不适合所有场景： 享元模式适用于系统中存在大量相似对象且这些对象的状态可以共享的情况。如果系统中对象差异较大或状态不能共享，那么使用享元模式可能并不合适。
（1）可能引入额外的开销： 虽然享元模式可以减少内存使用和提高性能，但在某些情况下可能会引入额外的开销。例如，当需要频繁地更新享元对象的状态时，由于状态是共享的，所以更新操作可能会变得复杂和耗时。
（1）可能破坏封装性： 由于享元对象的状态是共享的，因此需要谨慎处理状态的访问和修改。这可能会破坏对象的封装性，使得代码更难以理解和维护。