C++设计模式---享元模式

1、介绍

原理：

        享元模式是一种主要用于减少创建对象的数量，以减少内存占用和提高性能的结构型设计模式。它通过共享多个对象所共有的相同状态，使得在有限的内存容量中能够载入更多的对象。具体来说，享元模式将对象的状态分为内部状态（Intrinsic State）和外部状态（Extrinsic State）。

        内部状态：是存储在享元对象内部的信息，它是不可变的，可以在多个享元对象之间共享。

        外部状态：是依赖于享元对象上下文的信息，它随着享元对象的每一次使用而变化，通常作为参数传递给享元对象的方法。

        享元模式的核心在于享元工厂类，它负责创建和管理享元对象，并提供对外访问的接口。当客户端请求一个享元对象时，享元工厂会首先检查是否已存在具有相同内部状态的享元对象，如果存在则直接返回该对象，否则创建一个新的享元对象并存储起来。通过这种方式，享元模式实现了对象的复用，减少了对象的创建和销毁次数，从而提高了系统的性能。

使用场景：

享元模式通常用于以下场景：

        （1）系统中存在大量相似对象：当系统中需要创建大量细粒度的对象，并且这些对象具有相同的内部状态时，可以使用享元模式来减少对象的数量，节省内存空间。

        （2）对象的创建和销毁代价较大：如果对象的创建和销毁需要消耗大量的计算资源或时间，使用享元模式可以通过复用已有的对象来避免不必要的创建和销毁操作，从而提高系统的性能。

        （3）系统不依赖于对象身份：在享元模式中，由于多个客户端可能共享同一个享元对象，因此系统不应该依赖于对象的身份（即内存地址）来区分不同的对象。相反，系统应该通过对象的内部状态和外部状态来区分对象。

优缺点：

优点：

        （1）减少了对象的数量，降低了内存占用。

        （2）提高了系统的性能，减少了对象的创建和销毁次数。

        （3）支持可变状态和不可变状态，提高了对象的灵活性。

缺点：

        （1）增加了系统的复杂性，需要额外的工厂类来管理享元对象的创建和共享。

        （2）可能引入线程安全问题，需要对共享对象的并发访问进行合理的同步控制。

总结：

        C++享元模式通过共享对象的内部状态来减少对象的数量，从而节省内存空间并提高系统的性能。它适用于处理大量相似对象或对象创建和销毁代价较大的场景。然而，引入享元模式也会增加系统的复杂性，并可能引入线程安全问题。因此，在使用享元模式时需要根据具体情况权衡利弊，合理设计和管理共享对象。

2、示例

示例模拟了一个咖啡店订单系统，其中咖啡口味被视为享元对象，可以被多个订单共享。

#include <iostream>
#include <map>
#include <vector>
#include <memory>

// 抽象享元接口
class CoffeeFlavor {
public:
    virtual ~CoffeeFlavor() {}
    virtual void serve() const = 0;
};

// 具体享元类
class ConcreteCoffeeFlavor : public CoffeeFlavor {
public:
    explicit ConcreteCoffeeFlavor(const std::string& flavorName)
        : flavorName_(flavorName) {}

    void serve() const override {
        std::cout << "Serving coffee flavor: " << flavorName_ << std::endl;
    }

private:
    std::string flavorName_;
};

// 享元工厂
class CoffeeFlavorFactory {
private:
    std::map<std::string, std::shared_ptr<CoffeeFlavor>> flavors;

public:
    std::shared_ptr<CoffeeFlavor> getOrder(const std::string& flavor) {
        if (flavors.find(flavor) == flavors.end()) {
            flavors[flavor] = std::make_shared<ConcreteCoffeeFlavor>(flavor);
        }
        return flavors[flavor];
    }
};

int main() {
    CoffeeFlavorFactory factory;

    // 创建几个不同的订单，但某些口味会被共享
    std::vector<std::string> orders = {"Espresso", "Latte", "Espresso", "Cappuccino", "Espresso"};
    for (const auto& order : orders) {
        auto flavor = factory.getOrder(order);
        flavor->serve();
    }

    return 0;
}

在这个例子中：

        （1）CoffeeFlavor 是抽象享元类，定义了所有咖啡口味的基本行为，即服务（serve）咖啡。
        （2）ConcreteCoffeeFlavor 是具体享元类，实现了咖啡口味的具体行为，并存储了口味名称这一内部状态。
        （3）CoffeeFlavorFactory 是享元工厂，它维护了一个储存所有咖啡口味实例的映射表。当客户请求某个口味的咖啡时，工厂会检查是否已经创建过该口味的实例，如果没有则创建一个新的实例，否则返回已有的实例，从而实现了口味的共享。

        运行此代码，可以看到虽然订单列表中有多个"Espresso"，但在打印结果中只会看到一次"Serving coffee flavor: Espresso"，这是因为享元模式让多次请求相同口味的咖啡共享了同一个实例。

        实际上，上述咖啡口味享元模式的案例并没有体现出享元模式对外部状态的处理。在一个更全面的示例中，我们可能还会遇到咖啡订单具有外部状态，如客户的偏好（加糖、加奶）、杯子大小等。这时可以对示例稍作修改，将外部状态从享元对象中分离出来：

#include <iostream>
#include <map>
#include <vector>
#include <memory>

// 抽象享元接口
class CoffeeFlavor {
public:
    virtual ~CoffeeFlavor() {}
    virtual void serve(const std::string& extras, const std::string& size) const = 0;
};

// 具体享元类
class ConcreteCoffeeFlavor : public CoffeeFlavor {
public:
    explicit ConcreteCoffeeFlavor(const std::string& flavorName)
        : flavorName_(flavorName) {}

    void serve(const std::string& extras, const std::string& size) const override {
        std::cout << "Serving " << size << " cup of " << flavorName_
                  << " with extras: " << extras << std::endl;
    }

private:
    std::string flavorName_;
};

// 享元工厂
class CoffeeFlavorFactory {
private:
    std::map<std::string, std::shared_ptr<CoffeeFlavor>> flavors;

public:
    std::shared_ptr<CoffeeFlavor> getOrder(const std::string& flavor) {
        if (flavors.find(flavor) == flavors.end()) {
            // 没有找到就新建一个对象
            flavors[flavor] = std::make_shared<ConcreteCoffeeFlavor>(flavor);
        }
        return flavors[flavor];
    }
};

// 订单类，包含外部状态
class CoffeeOrder {
public:
    CoffeeOrder(std::shared_ptr<CoffeeFlavor> flavor, const std::string& extras, const std::string& size)
        : flavor_(flavor), extras_(extras), size_(size) {}

    void serve() const {
        flavor_->serve(extras_, size_);
    }

private:
    std::shared_ptr<CoffeeFlavor> flavor_;
    std::string extras_;
    std::string size_;
};

int main() {
    CoffeeFlavorFactory factory;

    // 创建几个不同的订单，但某些口味会被共享
    std::vector<CoffeeOrder> orders = {
        {factory.getOrder("Espresso"), "no sugar", "small"},
        {factory.getOrder("Latte"), "extra foam", "medium"},
        {factory.getOrder("Espresso"), "double sugar", "large"},
        {factory.getOrder("Cappuccino"), "cinnamon", "medium"},
        {factory.getOrder("Espresso"), "single sugar", "small"}
    };

    for (const auto& order : orders) {
        order.serve();
    }

    return 0;
}

结果：

Serving small cup of Espresso with extras: no sugar
Serving medium cup of Latte with extras: extra foam
Serving large cup of Espresso with extras: double sugar
Serving medium cup of Cappuccino with extras: cinnamon
Serving small cup of Espresso with extras: single sugar

3、参考

        C++设计模式之——享元模式详解和代码案例_c++享元模式-CSDN博客