装饰模式(decorator-pattern)

已于 2023-02-01 11:27:10 修改
阅读量1k 收藏 1
点赞数 3
分类专栏： 设计模式 文章标签： c++ 算法 开发语言
于 2023-01-19 18:53:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyf_fj/article/details/128737172
版权

装饰模式(decorator-pattern)

文章目录

一、手抓饼点餐系统

请设计一个手抓饼点餐系统，支持加配菜，比如里脊、肉松、火腿等，并提供接口，获取加了哪些配菜，和最后的总价。

听起来很简单嘛，代码敲起来：

"ingredient.hpp"，用来定义各种配料。

class Ingredient {
public:
  virtual std::string get_description() = 0;
  virtual double get_price() = 0;

protected:
  std::string description_;
  double price_;
};

class Ham : public Ingredient {
public:
  Ham() {
    description_ = "火腿";
    price_ = 1.0;
  }

  std::string get_description() {
    return description_;
  }

  double get_price() {
    return price_;
  }
};

class Tenderloin : public Ingredient {
public:
  Tenderloin() {
    description_ = "里脊肉";
    price_ = 2.0;
  }

  std::string get_description() {
    return description_;
  }

  double get_price() {
    return price_;
  }
};

class PorkFloss : public Ingredient {
public:
  PorkFloss() {
    description_ = "肉松";
    price_ = 1.5;
  }

  std::string get_description() {
    return description_;
  }

  double get_price() {
    return price_;
  }
};

"shredded_cake.hpp"，定义手抓饼。

class ShreddedCake {
public:
  ShreddedCake() : description_("饼, 单价3元\n"), total_price_(3.0) {}

  void add_ingredient(Ingredient *ingredient) {
    description_ += ingredient->get_description() + "\n";
    total_price_ += ingredient->get_price();
  }

  std::string get_description() {
    return description_;
  }

  double get_total_price() {
    return total_price_;
  }

private:
  std::string description_;
  double total_price_;
};

最后的测试:

int main() {
  ShreddedCake shredded_cake;
  std::shared_ptr<Ham> ham = std::make_shared<Ham>();
  std::shared_ptr<Tenderloin> tenderloin = std::make_shared<Tenderloin>();
  std::shared_ptr<PorkFloss> pork_floss = std::make_shared<PorkFloss>();

  shredded_cake.add_ingredient(ham.get());
  shredded_cake.add_ingredient(tenderloin.get());
  shredded_cake.add_ingredient(pork_floss.get());

  std::cout << "手抓饼配料: \n" << shredded_cake.get_description() << std::endl;
  std::cout << "总价: " << shredded_cake.get_total_price() << std::endl;
  return 0;
}

// output
手抓饼配料: 
饼, 单价3元
火腿, 单价1元
里脊肉, 单价2元
肉松, 单价1.5元

总价: 7.5元

很简单的实现，对吧？

二、要求进阶

现在，店铺扩张了，不仅可以点手抓饼，还有煎饼、汤包啥的，咋办呢？

简单，写一个抽象Breakfast类，让各种早点继承它就ok了：

class BreakFast {
public:
  virtual void add_ingredient(Ingredient *ingredient) = 0;
  virtual std::string get_description() = 0;
  virtual double get_total_price() = 0;

protected:
  std::string description_;
  double total_price_;
};

class ShreddedCake : public BreakFast {
public:
  ShreddedCake() {
    description_ = "饼, 单价3元\n"; 
    total_price_ = 3.0;
  } 

  void add_ingredient(Ingredient *ingredient) {
    description_ += ingredient->get_description() + "\n";
    total_price_ += ingredient->get_price();
  }

  std::string get_description() {
    return description_;
  }

  double get_total_price() {
    return total_price_;
  }

};

class Pancake : public BreakFast {
public:
  Pancake() {
    description_ = "煎饼, 单价2元\n"; 
    total_price_ = 2.0;
  } 

  void add_ingredient(Ingredient *ingredient) {
    description_ += ingredient->get_description() + "\n";
    total_price_ += ingredient->get_price();
  }

  std::string get_description() {
    return description_;
  }

  double get_total_price() {
    return total_price_;
  }

};

class SteamedDumpling : public BreakFast {
public:
  SteamedDumpling() {
    description_ = "汤包, 单价7元\n"; 
    total_price_ = 7.0;
  } 

  std::string get_description() {
    return description_;
  }

  double get_total_price() {
    return total_price_;
  }

};

但这样一份代码有一个尴尬的问题：

  1. SteamedDumpling，即汤包类，没有重写抽象方法add_ingredient，虽然编译通过但是不能正常使用这个类。
  2. 但是，汤包在现实生活中，也不需要add_ingredient，即加配料。

怎么办呢？一个办法，就是为需要加配料的早餐添加add_ingredient方法，但是有没有什么更优雅的解决方案呢？

我们即将引入装饰模式的概念。

三、装饰模式概要

image-20230119134802024

  • Abstract BaseClass
    • 抽象基类
    • 提供抽象方法Operation
  • Concrete DerivedClass
    • 派生于抽象基类，用来描述具体的对象特性
    • 重写抽象方法Operation（纯虚方法）
  • Decorator
    • 装饰抽象类，派生于抽象基类，用于装饰Concrete DerivedClass
  • Concrete Decorator
    • 重写抽象方法Operation
    • 可以添加自己私有的成员变量和成员函数，用于给Operation扩展新功能

听起来非常抽象，我们改写代码后进行分析：

"breakfast.hpp"

class Breakfast {
public:
  virtual std::string get_description() = 0;
  virtual double get_price() = 0;

protected:
  std::string description_;
  double price_;
};

class ShreddedCake : public Breakfast {
public:
  ShreddedCake() {
    description_ = "手抓饼, 单价3元"; 
    price_ = 3.0;
  } 

  std::string get_description() {
    return description_ + "\n";
  }

  double get_price() {
    return price_;
  }

};

class Pancake : public Breakfast {
public:
  Pancake() {
    description_ = "煎饼, 单价2元"; 
    price_ = 2.0;
  } 

  std::string get_description() {
    return description_ + "\n";
  }

  double get_price() {
    return price_;
  }

};

class SteamedDumpling : public Breakfast {
public:
  SteamedDumpling() {
    description_ = "汤包, 单价7元"; 
    price_ = 7.0;
  } 

  std::string get_description() {
    return description_ + "\n";
  }

  double get_price() {
    return price_;
  }

};

这是早餐类的继承体系，基类是Breakfast，提供两个纯虚函数，派生出的三个子类重写这两个函数。

  • Breakfast对应Abstract BaseClass
  • ShreddedCake、Pancake和SteamedDumpling对应Concrete DerivedClass

"ingredient.hpp"

class Ingredient : public Breakfast {
protected:
  Breakfast *breakfast_;
};

class Ham : public Ingredient {
public:
  Ham(Breakfast *breakfast) {
    breakfast_ = breakfast;
    description_ = "火腿, 单价1元";
    price_ = 1.0;
  }

  std::string get_description() {
    return breakfast_->get_description() + description_ + "\n";
  }

  double get_price() {
    return breakfast_->get_price() + price_;
  }
};

class Tenderloin : public Ingredient {
public:
  Tenderloin(Breakfast *breakfast) {
    breakfast_ = breakfast;
    description_ = "里脊肉, 单价2元";
    price_ = 2.0;
  }

  std::string get_description() {
    return breakfast_->get_description() + description_ + "\n";
  }

  double get_price() {
    return breakfast_->get_price() + price_;
  }
};

class PorkFloss : public Ingredient {
public:
  PorkFloss(Breakfast *breakfast) {
    breakfast_ = breakfast;
    description_ = "肉松, 单价1.5元";
    price_ = 1.5;
  }

  std::string get_description() {
    return breakfast_->get_description() + description_ + "\n";
  }

  double get_price() {
    return breakfast_->get_price() + price_;
  }
};

这是配料类的继承体系，Ingredient继承自Breakfast，由于没有重写纯虚函数，因此也是抽象类。

派生出的三个子类重写了get_description和get_price两个纯虚函数。

  • Ingredient对应装饰基类Decorator
  • Tenderloin、PorkFloss对应Concrete Decorator，即具体的装饰子类。
    • 由于是装饰类，因此它们可以有自己的方法和变量，其中不可或缺的是一个指向父类的Breakfast指针。
    • 通过指向父类的Breakfast指针，装饰类可以获得父类的特性，并且将自己的新特性追加过去。
      • 比如装饰类中重写get_price：先使用breakfast指针获取父类的价格，再将自身的价格追加过去。

"main.cpp"

int main() {
  try {
    std::shared_ptr<Breakfast> breakfast = std::make_shared<Pancake>();
    std::shared_ptr<Breakfast> add_1_ingredient = std::make_shared<Ham>(breakfast.get());
    std::shared_ptr<Breakfast> add_2_ingredient  = std::make_shared<Tenderloin>(add_1_ingredient.get());
    std::shared_ptr<Breakfast> add_3_ingredient  = std::make_shared<PorkFloss>(add_2_ingredient.get());

    std::cout << "配料: \n" << add_3_ingredient->get_description() << std::endl;
    std::cout << "总价: " << add_3_ingredient->get_price() << "元" << std::endl << std::endl;
  } catch (const std::exception &e) {
    std::cout << e.what() << std::endl;
  }
  return 0;
}

  1. 首先，让breakfast指向一个Pancake，表示要点一个煎饼。

  2. 其次，new一个Ham，并将刚刚的基类指针传过去，表示要追加一个火腿。

  3. Tenderloin和PorkFloss同理。

  4. 加入我还要加一份肉松，那么可以添一句：

    std::shared_ptr<Breakfast> add_4_ingredient  = std::make_shared<PorkFloss>(add_3_ingredient.get());

四、装饰模式的优劣及应用场景

1. 优点

  1. 可以在不修改原先类的基础上给它追加一些新的特性，减少被装饰类的复杂程度。
  2. 相比于纯粹的继承体系，装饰可以通过用户主动的包装完成功能的复合叠加，而继承则需要老老实实地写多个类。假如有4个功能，则一共有2^4-1=15种复合情况，使用装饰模式只需要写4种装饰类，而继承则需要完成15个类（功能更多会导致指数爆炸！）

2.缺点

1. 会导致代码更加复杂，出现问题时排查难度加大。

3.应用场景

就像装饰模式的优点那样，如果你想动态地增加原有类的特性，那么装饰模式再合适不过了。

以Java的IO流举例：image-20230119184230465

InputStream中的FilterInputStream就是一个装饰基类，为其它的IO流类提供缓冲的功能。如果这里用继承，那么会有多少个类呢…想想都离谱！

白龙码~
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++设计模式——装饰模式（decorator pattern）
净无邪博客
06-07 700
一、原理讲解 图1 装饰者模式UML图 1.1意图 装饰模式目的是：动态地给一个对象添加一些额外的职责，比生成之类更灵活。 1.2常用场景 一般用于给某个对象添加某个功能，但是又不希望更改该对象底层抽象借口，同时该功能可以动态增删，这时可以考虑用装饰者模式。 1.3实行方法 如图1所示，装饰着Decorator通过继承抽象基类Component，又组合一个Component指针*component，通过重写从Component继承而来的虚函数operation()，在里面用指针调用oper.
C++设计模式之装饰模式
李兰溪的专栏
03-06 881
C++设计模式之装饰模式 动态地给一个对象增加一些额外的职责，就增加对象的功能来说，装饰模式比生成子类更为灵活。装饰模式是一种对象结构模式。 一、缘由我们常常通过继承的方式来对一个既有的类进行功能添加，但继承方式有显著的局限性，因为 继承具有侵入性 继承是一种is a的关系，具有强耦合性，难以复用代码。 例如在窗口控件当中，要增加新的功能如增加滚动条，增加背景图片，通过继承的方式来增加新的功能，
C++装饰模式实现
m0_47178337的博客
08-04 225
装饰模式是对对象进行一个包装，这样每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰只关心自己的实现功能，不需要关心如何被添加到对象链中。 class Person { public: Person() {} Person(string name) :name(name) {}; // 初始化列表 virtual void show() { cout << "装扮的" << name << endl; } private: string name; };
设计模式之装饰器模式，以C++为例。
Bobowen的博客
02-02 722
今天来盘一盘装饰器模式。装饰器模式以一种动态的方式给对象添加额外的职责，好似“装饰”在对象身上一样，通常通过继承和委托来实现。 设计模式始终遵循对“修改封闭，拓展开放”这样的特性，说白了就是尽量不要动源代码，去尽力适应源代码的方式去做拓展开发。装饰器模式同样遵循这样的原则，实现装饰器模式的主要手段同样为 C++最基本的特性：继承、C++11新特性：委托。
C++设计模式详解之装饰者模式解析
m0_73443478的博客
02-25 438
C++设计模式详解之装饰者模式解析
decorator-pattern:带有单一测试的装饰器模式演示
05-05
装饰图案 带有单一测试的装饰器模式演示
java 装饰模式（Decorator Pattern）详解
09-01
主要介绍了java 装饰模式（Decorator Pattern）详解的相关资料,需要的朋友可以参考下
详解java装饰模式（Decorator Pattern）
09-02
主要为大家详细介绍了java装饰模式Decorator Pattern，这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装，对装饰器模式感兴趣的小伙伴们可以参考一下
java实现装饰器模式（Decorator Pattern）
08-26
主要为大家详细介绍了java实现装饰器模式Decorator Pattern，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C#装饰器模式(Decorator Pattern)实例教程
09-04
主要介绍了C#装饰器模式(Decorator Pattern),以一个完整实例形式讲述了C#装饰器模式的实现过程,有助于深入理解C#程序设计思想,需要的朋友可以参考下
装饰模式C++详解
ahelloyou的博客
02-23 921
装饰模式的作用 装饰模式C++代码实现 代码实现 装饰模式的缺点 # 装饰模式 1. 装饰模式的作用 动态的给一个对象添一些额外的职责，就增加功能而言，装饰模式比生成子类更加的灵活。 为已有的功能动态的添加更多功能的一种方式 可以将勒种的核心职责和装饰从勒种移除，有效把职责和装饰分离 2. 装饰模式C++代码实现 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nBme9NTF-1645595496479)(./装饰模式.png)] 3....
【C++设计模式】装饰器模式
qq_33197518的博客
11-18 131
模式定义： 动态（组合）的给一个对象增加一些额外的职责，就增加功能而言Decorator模式比生成子类（继承）更为灵活（消除重复代码 & 减少子类个数）。 假设我们需要设计如下一个功能的程序： 1.对各种流的读取、写入和定位 2.添加对各种流的加密以及缓冲或者又加密又缓冲的功能。 那么我们最初设计的类（版本一）可能如下： //业务操作 class Stream{ public： virtual char Read(int number)=0; virtual void Seek(i
手抓饼加生菜加鸡蛋的装饰器模式
a779868946的博客
02-24 280
装饰器模式 装饰器模式（Decorator Patter），也称为包装模式（Wrapper Pattern）是指在不改变原有对象的基础之上，将功能附加在对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于结构型模式。 装饰器模式的核心是功能扩展。使用装饰器可以透明且动态地扩展类的功能。 下面是通用的UML类图： 生活中的应用场景 看完上面的概念以及类图可能比较抽象，接下来我会举一个生活中的场景，来通俗易懂的讲解装饰器模式。 我们在早上上班途中，往往会在公司门口买一个手抓饼，然后带到工位上慢慢
JAVA设计模式 之九 装饰模式
ghb741649543的博客
10-12 822
装饰模式（装饰设计模式）详解 在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等。 在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。 所有这些都可以釆用装饰模式来实现。 装饰模式的定义与特点 装饰（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。 装饰（Decorator）模式的主要优点有： 采用装饰模式扩
装饰者模式
zsw112637的博客
11-25 176
装饰者模式 装饰者模式主要功能是动态地给一个对象添加一些额外的职责，相比继承更加的灵活。 在学习装饰者模式之前，我们来回味一下继承。 继承 被增强的对象固定的 增强的内容也是固定的 我们举一个继承的例子： class 咖啡类 {} class 有糖咖啡 extends 咖啡类 { } class 加奶咖啡 extends 咖啡类 { } class 加盐咖啡 extends 咖啡类 { } 从这...
装饰模式
lena blog
05-02 6636
案例1 某图书管理系统中，书籍类(Book)具有借书方法borrowBook()和还书方法returnBook() 。现需要动态给书籍对象添加冻结方法freeze()和遗失方法lose()。使用装饰模式设计该系统，绘制类图并编程实现。 类图如下： 代码如下： public abstract class IBook { private String bookName; abstract void borrowBook(); abstract void returnBook(); p
C++教学——从入门到精通 10.循环
QIPABOSHI的博客
04-24 406
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
【C++ | Python 八股文（备战秋招）】—— 日积月累
最新发布
BigDavid123的博客
04-27 279
C++、Python常见八股文
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 928
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
decorator pattern
06-11
装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许您在运行时通过将对象包装在一个装饰器类的对象中来动态地修改对象的行为。使用装饰器模式，您可以将一个对象的行为分成多个单独的类，每个类都可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白龙码~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值