C++设计模式：装饰器模式 (Decorator) （咖啡订单系统）

机器视觉知识推荐、就业指导2024-11-29 19:26

什么是装饰器模式？

装饰器模式（Decorator Pattern）是一种结构型设计模式 ，它允许在不修改原始对象的代码的情况下，通过动态地将对象"包装"到一个或多个装饰器对象中，来扩展对象的功能。

装饰器模式的核心思想是：用组合代替继承，动态地为对象添加职责。相比传统的继承方式，它的灵活性更强，能够在运行时对功能进行动态组合。

装饰器模式的定义

装饰器模式：动态地为对象添加新功能。这种模式通过使用一个或多个装饰器类来包装原始对象，从而扩展其行为，而无需修改对象的结构。

生活中的例子

咖啡店的饮料定制是装饰器模式的经典例子：

  • 顾客可以点一杯基础咖啡（黑咖啡）。
  • 之后可以自由选择配料（牛奶、糖、巧克力等）。
  • 最终的咖啡价格由基础价格加上所有配料的价格总和组成。
  • 而配料的功能（如描述和价格）可以动态叠加，无需为每种组合创建一个独立的类。

为什么需要装饰器模式？

问题背景：功能扩展的挑战

假如一个系统需要为对象增加功能，可以通过以下两种方式实现：

  1. 继承方式：

    • 为每个功能扩展创建子类，例如 MilkCoffee、MilkSugarCoffee。
    • 缺点 ：随着功能组合的增加，子类数量会呈指数级增长（类爆炸问题）。

  2. 装饰器方式：

    • 使用装饰器类动态地为对象添加功能。
    • 优点：灵活可扩展，不需要为每种功能组合创建子类。

装饰器模式的结构

装饰器模式的结构可以概括为以下四个角色：

  1. Component（组件接口或抽象类）

    定义对象的基本行为接口。

  2. ConcreteComponent（具体组件）

    被装饰的原始对象，提供基本行为的实现。

  3. Decorator（抽象装饰器）

    持有一个 Component 类型的成员变量，用于引用被装饰对象，同时实现 Component 接口。

  4. ConcreteDecorator（具体装饰器）

    继承自 Decorator，扩展被装饰对象的功能。

装饰器模式类图

plaintext 复制代码 
Component <------- ConcreteComponent
    ↑
    ↑
Decorator <------- ConcreteDecorator

C++中的装饰器模式：咖啡订单系统示例

需求描述

  1. 实现一个咖啡订单系统，支持以下功能：

    • 基础咖啡（黑咖啡）。
    • 可以动态添加牛奶、糖、巧克力等配料。
    • 最终描述显示所有添加的配料，价格为基础价格加上配料价格总和。

  2. 解决问题：

    • 避免为每种组合创建一个子类。
    • 符合开闭原则，能够轻松扩展新配料。

代码实现

以下是完整的 C++ 实现，并对每部分代码进行详细解析。

1. 定义基础接口

基础接口 Beverage 用于定义所有咖啡的基本行为，包括获取描述和计算价格的方法：

cpp 复制代码 
#include <iostream>
#include <string>
#include <memory> // 使用智能指针，防止内存泄漏

// 抽象组件
class Beverage {
public:
    virtual std::string getDescription() const = 0; // 获取描述
    virtual double cost() const = 0;                // 获取价格
    virtual ~Beverage() = default;                 // 虚析构函数
};
  • 为什么要有这个接口？
    • 为了保证装饰器模式的灵活性，所有装饰器和具体组件必须实现相同的接口。
    • 这使得装饰器可以替代组件，实现动态组合。
2. 实现基础组件

具体组件 BlackCoffee 提供基础功能（黑咖啡）：

cpp 复制代码 
// 具体组件
class BlackCoffee : public Beverage {
public:
    std::string getDescription() const override {
        return "黑咖啡";
    }

    double cost() const override {
        return 5.0; // 黑咖啡的基础价格
    }
};
  • 为什么需要具体组件？
    • 具体组件是装饰器的核心目标，装饰器通过"包装"具体组件来扩展其功能。
3. 创建抽象装饰器

抽象装饰器 BeverageDecorator 持有一个 Beverage 对象，用于对其功能进行扩展：

cpp 复制代码 
// 抽象装饰器
class BeverageDecorator : public Beverage {
protected:
    std::shared_ptr<Beverage> beverage; // 持有被装饰对象（组合）

public:
    explicit BeverageDecorator(std::shared_ptr<Beverage> b) : beverage(std::move(b)) {}
    virtual ~BeverageDecorator() = default;
};
  • 为什么需要抽象装饰器？
    • 抽象装饰器为具体装饰器提供基础结构，实现代码复用。
    • 它将所有装饰器与具体组件连接起来。
4. 实现具体装饰器

每个具体装饰器（如 MilkDecorator、SugarDecorator）都扩展了被装饰对象的功能：

cpp 复制代码 
// 具体装饰器：牛奶
class MilkDecorator : public BeverageDecorator {
public:
    explicit MilkDecorator(std::shared_ptr<Beverage> b) : BeverageDecorator(std::move(b)) {}

    std::string getDescription() const override {
        return beverage->getDescription() + " + 牛奶";
    }

    double cost() const override {
        return beverage->cost() + 1.0; // 增加牛奶价格
    }
};

// 具体装饰器：糖
class SugarDecorator : public BeverageDecorator {
public:
    explicit SugarDecorator(std::shared_ptr<Beverage> b) : BeverageDecorator(std::move(b)) {}

    std::string getDescription() const override {
        return beverage->getDescription() + " + 糖";
    }

    double cost() const override {
        return beverage->cost() + 0.5; // 增加糖价格
    }
};

// 具体装饰器：巧克力
class ChocolateDecorator : public BeverageDecorator {
public:
    explicit ChocolateDecorator(std::shared_ptr<Beverage> b) : BeverageDecorator(std::move(b)) {}

    std::string getDescription() const override {
        return beverage->getDescription() + " + 巧克力";
    }

    double cost() const override {
        return beverage->cost() + 2.0; // 增加巧克力价格
    }
};
  • 每个装饰器的职责：
    • 动态扩展描述（getDescription）。
    • 动态叠加价格（cost）。
5. 主函数测试

通过动态组合装饰器实现任意功能叠加：

cpp 复制代码 
int main() {
    // 1. 创建基础的黑咖啡
    std::shared_ptr<Beverage> coffee = std::make_shared<BlackCoffee>();
    std::cout << "基础订单：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    // 2. 加牛奶
    coffee = std::make_shared<MilkDecorator>(coffee);
    std::cout << "加牛奶后：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    // 3. 加糖
    coffee = std::make_shared<SugarDecorator>(coffee);
    std::cout << "加糖后：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    // 4. 加巧克力
    coffee = std::make_shared<ChocolateDecorator>(coffee);
    std::cout << "加巧克力后：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    return 0;
}

运行结果

plaintext 复制代码 
基础订单：黑咖啡，价格：5 元
加牛奶后：黑咖啡 + 牛奶，价格：6 元
加糖后：黑咖啡 + 牛奶 + 糖，价格：6.5 元
加巧克力后：黑咖啡 + 牛奶 + 糖 + 巧克力，价格：8.5 元

装饰器模式的优缺点

优点

  1. 动态扩展功能：无需修改现有类即可添加新功能。
  2. **

符合开闭原则**：功能扩展只需新增装饰器类。

  1. 灵活组合：支持任意功能的叠加，避免了类爆炸。

缺点

  1. 复杂性增加：装饰器嵌套较多时，可能增加代码的阅读和调试难度。
  2. 运行时成本：由于多层包装，可能会影响性能。

应用场景

  1. 图形界面系统：为控件动态添加滚动条、边框、阴影等。
  2. 流处理：如 Java 的 I/O 流中动态添加加密、压缩功能。
  3. 日志系统：动态为日志添加格式化、过滤、分级等功能。

总结

装饰器模式是一种强大的设计模式，适合需要动态扩展功能的场景。通过"组合优于继承"的设计思想，它能够在保持代码灵活性的同时，减少类的数量，提升系统的可扩展性。以上的咖啡订单系统示例清晰地展示了装饰器模式的强大功能，是理解和应用这一模式的理想参考。

完整代码

cpp 复制代码 
#include <iostream>
#include <string>
#include <memory> // 使用智能指针，防止内存泄漏

// 1. 抽象组件：定义所有咖啡的基本行为接口
class Beverage {
public:
    virtual std::string getDescription() const = 0; // 获取描述
    virtual double cost() const = 0;                // 获取价格
    virtual ~Beverage() = default;                 // 虚析构函数，避免内存泄漏
};

// 2. 具体组件：基础咖啡（黑咖啡）
class BlackCoffee : public Beverage {
public:
    std::string getDescription() const override {
        return "黑咖啡";
    }

    double cost() const override {
        return 5.0; // 黑咖啡的基础价格
    }
};

// 3. 抽象装饰器：持有一个 `Beverage` 指针，用于扩展功能
class BeverageDecorator : public Beverage {
protected:
    std::shared_ptr<Beverage> beverage; // 持有被装饰的对象（组合）

public:
    explicit BeverageDecorator(std::shared_ptr<Beverage> b) : beverage(std::move(b)) {}
    virtual ~BeverageDecorator() = default;
};

// 4. 具体装饰器：实现动态功能扩展
// 4.1 牛奶装饰器
class MilkDecorator : public BeverageDecorator {
public:
    explicit MilkDecorator(std::shared_ptr<Beverage> b) : BeverageDecorator(std::move(b)) {}

    std::string getDescription() const override {
        return beverage->getDescription() + " + 牛奶"; // 在描述中添加牛奶
    }

    double cost() const override {
        return beverage->cost() + 1.0; // 增加牛奶价格
    }
};

// 4.2 糖装饰器
class SugarDecorator : public BeverageDecorator {
public:
    explicit SugarDecorator(std::shared_ptr<Beverage> b) : BeverageDecorator(std::move(b)) {}

    std::string getDescription() const override {
        return beverage->getDescription() + " + 糖"; // 在描述中添加糖
    }

    double cost() const override {
        return beverage->cost() + 0.5; // 增加糖价格
    }
};

// 4.3 巧克力装饰器
class ChocolateDecorator : public BeverageDecorator {
public:
    explicit ChocolateDecorator(std::shared_ptr<Beverage> b) : BeverageDecorator(std::move(b)) {}

    std::string getDescription() const override {
        return beverage->getDescription() + " + 巧克力"; // 在描述中添加巧克力
    }

    double cost() const override {
        return beverage->cost() + 2.0; // 增加巧克力价格
    }
};

// 5. 主函数：测试装饰器模式的功能
int main() {
    // 1. 创建基础的黑咖啡
    std::shared_ptr<Beverage> coffee = std::make_shared<BlackCoffee>();
    std::cout << "基础订单：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    // 2. 动态添加装饰器功能
    coffee = std::make_shared<MilkDecorator>(coffee); // 添加牛奶
    std::cout << "加牛奶后：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    coffee = std::make_shared<SugarDecorator>(coffee); // 添加糖
    std::cout << "加糖后：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    coffee = std::make_shared<ChocolateDecorator>(coffee); // 添加巧克力
    std::cout << "加巧克力后：" << coffee->getDescription() << "，价格：" << coffee->cost() << " 元" << std::endl;

    return 0;
}

运行结果

plaintext 复制代码 
基础订单：黑咖啡，价格：5 元
加牛奶后：黑咖啡 + 牛奶，价格：6 元
加糖后：黑咖啡 + 牛奶 + 糖，价格：6.5 元
加巧克力后：黑咖啡 + 牛奶 + 糖 + 巧克力，价格：8.5 元
相关推荐
AI原吾27 分钟前
探索 Python 任务自动化的新境界：Invoke 库揭秘
开发语言·python·自动化·invoke
HMS Core31 分钟前
未成年人模式护航，保障安全健康上网
开发语言·安全·华为·php·harmonyos
每天写点bug38 分钟前
golang每日一题：context、goroutine相关
开发语言·sql·golang
qq_5704163039 分钟前
qt音频实战
开发语言·qt
越努力^越幸运1 小时前
类和对象--中--运算符重载、日期类实现（重要）
开发语言·c++·算法
IsToRestart1 小时前
String的设计，用到了哪些设计模式？
java·jvm·设计模式
自律的阿龙1 小时前
C++练级计划-＞《多态》虚函数表，菱形继承多态
开发语言·c++
XiaoLeisj1 小时前
【JavaEE初阶 — 网络编程】TCP流套接字编程
java·开发语言·网络·网络协议·java-ee
MaxCosmos20011 小时前
读《Effective Java》笔记 - 条目11
java·开发语言·笔记·effective java
达斯维达的大眼睛1 小时前
文本搜索程序（Qt）
开发语言·qt·命令模式
热门推荐
01Docker 夺命连环 15 问02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04文件或文件夹名称中有空格如何批量去除05玄机平台应急响应—webshell查杀06PyTorch机器学习实现液态神经网络07如何识别手机是否有灵动岛（dynamic island）08软件工程从理论到实践客观题汇总(头歌第一章至第八章)09Coze扣子平台完整体验和实践（附国内和国际版对比）10基于微信小程序的自习室预约系统的设计与实现