概述
一般有两种方式可以实现给一个类或对象增加行为：
- 继承机制
- 关联机制
继承机制
使用继承机制是给现有类添加功能的一种有效途径，通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法。但是这种方法是静态的，用户不能控制增加行为的方式和时机。
关联机制
即将一个类的对象嵌入另一个对象中，由另一个对象来决定是否调用嵌入对象的行为以便扩展自己的行为，我们称这个嵌入的对象为装饰器(Decorator)
定义
动态地给一个对象增加一些额外的职责(
Responsibility)，就增加对象功能来说，装饰模式比生成子类实现更为灵活。其别名也可以称为包装器(Wrapper)，与适配器模式的别名相同，但它们适用于不同的场合。
角色
Component:抽象构件ConcreteComponent:具体构件Decorator:抽象装饰类ConcreteDecorator:具体装饰类
场景
- 动态透明地向单个对象添加责任，即不影响其他对象
- 可以撤销责任
- 当通过子类扩展不切实际时
实现一
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//抽象构建类 class Component { public: virtual ~Component() {} virtual void operation() = 0; //... }; //具体构建类 class ConcreteComponent : public Component { public: ~ConcreteComponent() {} void operation() { std::cout << "Concrete Component operation" << std::endl; } //... }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
//抽象装饰器类 class Decorator : public Component { public: ~Decorator() {} Decorator(Component * c) : component(c) { } virtual void operation() { component->operation(); } //... private: Component * component; }; //具体装饰器类 class ConcreteDecoratorA : public Decorator { public: ConcreteDecoratorA(Component * c) : Decorator(c) { } void operation() { Decorator::operation(); std::cout << "Decorator A" << std::endl; } //... }; class ConcreteDecoratorB : public Decorator { public: ConcreteDecoratorB(Component * c) : Decorator(c) { } void operation() { Decorator::operation(); std::cout << "Decorator B" << std::endl; } //... } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
auto main()->int { ConcreteComponent * cc = new ConcreteComponent(); ConcreteDecoratorB * db = new ConcreteDecoratorB(cc); ConcreteDecoratorA * da = new ConcreteDecoratorA(db); Component * component = da; component->operation(); delete da; delete db; delete cc; return 0; } |
实现二
|
1 2 3 4 5 6 7 8 9 10 11 |
// 基础咖啡类 class Coffee { public: virtual ~Coffee() {} virtual std::string getDescription() const { return "Simple Coffee"; } virtual double cost() const { return 2.0; } }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
// 装饰器基类 class CoffeeDecorator : public Coffee { protected: Coffee* coffee; public: CoffeeDecorator(Coffee* coffee) : coffee(coffee) {} virtual ~CoffeeDecorator() {} }; // 牛奶装饰器 class MilkDecorator : public CoffeeDecorator { public: MilkDecorator(Coffee* coffee) : CoffeeDecorator(coffee) {} std::string getDescription() const override { return coffee->getDescription() + ", Milk"; } double cost() const override { return coffee->cost() + 0.5; } }; // 糖装饰器 class SugarDecorator : public CoffeeDecorator { public: SugarDecorator(Coffee* coffee) : CoffeeDecorator(coffee) {} std::string getDescription() const override { return coffee->getDescription() + ", Sugar"; } double cost() const override { return coffee->cost() + 0.2; } }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
int main() { Coffee* simpleCoffee = new Coffee(); std::cout << "Description: " << simpleCoffee->getDescription() << " Cost: " << simpleCoffee->cost() << std::endl; Coffee* milkCoffee = new MilkDecorator(simpleCoffee); std::cout << "Description: " << milkCoffee->getDescription() << " Cost: " << milkCoffee->cost() << std::endl; Coffee* sugarMilkCoffee = new SugarDecorator(milkCoffee); std::cout << "Description: " << sugarMilkCoffee->getDescription() << " Cost: " << sugarMilkCoffee->cost() << std::endl; delete simpleCoffee; delete milkCoffee; delete sugarMilkCoffee; return 0; } |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ 行为型：备忘录模式09/25
- ♥ 创建型：原型模式09/25
- ♥ 行为型：责任链模式09/25
- ♥ 行为型：模板方法模式09/25
- ♥ 行为型：解释器模式09/25
- ♥ 创建型：工厂方法模式08/25