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

什么是装饰器模式？

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

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

装饰器模式的定义

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

生活中的例子

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

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

为什么需要装饰器模式？

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

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

1. 继承方式：

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

2. 装饰器方式：

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

装饰器模式的结构

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

1. Component（组件接口或抽象类）
   定义对象的基本行为接口。

2. ConcreteComponent（具体组件）
   被装饰的原始对象，提供基本行为的实现。

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

4. ConcreteDecorator（具体装饰器）
   继承自 Decorator，扩展被装饰对象的功能。

装饰器模式类图

Component <------- ConcreteComponent
    ↑
    ↑
Decorator <------- ConcreteDecorator

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

需求描述

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

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

2. 解决问题：

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

代码实现

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

1. 定义基础接口

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

#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 提供基础功能（黑咖啡）：

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

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

• 为什么需要具体组件？
  • 具体组件是装饰器的核心目标，装饰器通过“包装”具体组件来扩展其功能。

3. 创建抽象装饰器

抽象装饰器 BeverageDecorator 持有一个 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. 实现具体装饰器

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

// 具体装饰器：牛奶
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. 主函数测试

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

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

运行结果

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

装饰器模式的优缺点

优点

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

符合开闭原则**：功能扩展只需新增装饰器类。
3. 灵活组合：支持任意功能的叠加，避免了类爆炸。

缺点

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

应用场景

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

总结

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

完整代码

#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;
}

运行结果

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