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

发布于:2024-11-29 ⋅ 阅读:(21) ⋅ 点赞:(0)

什么是装饰器模式?

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

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

装饰器模式的定义

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


生活中的例子

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

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

为什么需要装饰器模式?

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

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

  1. 继承方式:

    • 为每个功能扩展创建子类,例如 MilkCoffeeMilkSugarCoffee
    • 缺点:随着功能组合的增加,子类数量会呈指数级增长(类爆炸问题)。
  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. 实现具体装饰器

每个具体装饰器(如 MilkDecoratorSugarDecorator)都扩展了被装饰对象的功能:

// 具体装饰器:牛奶
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 元