C++ 设计模式——装饰模式

于 2024-08-21 00:07:57 发布
阅读量1.1k 收藏 30
点赞数 47
分类专栏： # C++ 设计模式 文章标签： c++ 设计模式 装饰器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141337247
版权

装饰模式

装饰模式

装饰模式（Decorator Pattern）是一种结构型设计模式，允许在不改变对象结构的情况下，动态地为对象添加额外的功能。下面是一个基于控件的例子，展示了如何使用装饰模式来增强控件的功能。

引入“装饰”设计模式的定义(实现意图)：动态地给一个对象添加一些额外的职责，就增加功能来说，该模式相比生成子类更加灵活。

主要组成部分

  1. 组件接口（Component）：定义一个接口，供具体组件和装饰者实现。这个接口通常包含一个或多个方法，供客户端调用。
  2. 具体组件（ConcreteComponent）：实现组件接口的具体对象。它是被装饰的对象，提供基本的功能。
  3. 装饰者（Decorator）：持有一个组件对象的引用，并实现组件接口，通常会在其方法中调用组件对象的方法。
  4. 具体装饰者（ConcreteDecorator）：扩展装饰者的功能，添加新的行为。

例一：工作流程

  • Control（抽象控件类）：定义了控件的基本接口。
  • ListCtrl（具体控件类）：实现了 Control 接口，绘制普通的列表控件。
  • Decorator（抽象装饰器类）：持有一个 Control 对象的引用，调用其 draw 方法。
  • BorderDec（边框装饰器类）：在绘制控件的基础上，添加边框的绘制功能。
  • VerScrollBarDec（垂直滚动条装饰器类）：在绘制控件的基础上，添加垂直滚动条的绘制功能。
  • HorScrollBarDec（水平滚动条装饰器类）：在绘制控件的基础上，添加水平滚动条的绘制功能。
1. 定义组件接口
  • 创建一个抽象类 Control，定义一个纯虚函数 draw()，用于绘制控件。
//抽象的控件类
class Control
{
public:
    virtual void draw() = 0; //draw方法，用于将自身绘制到屏幕上
public:
    virtual ~Control() {} //做父类时析构函数应该为虚函数
};
2. 实现具体组件
  • 创建一个具体类 ListCtrl，继承自 Control，实现 draw() 方法，提供基本的控件绘制功能。
//列表控件类
class ListCtrl :public Control
{
public:
    virtual void draw()
    {
        cout << "绘制普通的列表控件!" << endl;//具体可以用DirectX或OpenGL来绘制
    }
};
3. 创建装饰者基类
  • 创建一个装饰者类 Decorator，继承自 Control，持有一个 Control 对象的引用，并在 draw() 方法中调用该对象的 draw() 方法。
//抽象的装饰器类
class Decorator : public Control
{
public:
    Decorator(Control* tmpctrl) :m_control(tmpctrl) {}//构造函数
    virtual void draw()
    {
        m_control->draw();//虚函数，调用的是哪个draw取决于m_control指向的对象
    }
private:
    Control* m_control;  //需要被装饰的其他控件，这里用的是父类指针Control *
};
4. 实现具体装饰者
  • 创建多个具体装饰者类，如 BorderDec、VerScrollBarDec 和 HorScrollBarDec，它们继承自 Decorator，在 draw() 方法中扩展功能（如绘制边框或滚动条）。
//具体的“边框”装饰器类
class BorderDec :public Decorator
{
public:
    BorderDec(Control* tmpctrl) :Decorator(tmpctrl) {}//构造函数
    virtual void draw()
    {
        Decorator::draw(); //调用父类的draw方法以保持以往已经绘制出的内容
        drawBorder(); //也要绘制自己的内容
    }
private:
    void drawBorder()
    {
        cout << "绘制边框!" << endl;
    }
};
//具体的“垂直滚动条”装饰器类
class VerScrollBarDec :public Decorator
{
public:
    VerScrollBarDec(Control* tmpctrl) :Decorator(tmpctrl) {}//构造函数
    virtual void draw()
    {
        Decorator::draw(); //调用父类的draw方法以保持以往已经绘制出的内容
        drawVerScrollBar(); //也要绘制自己的内容
    }
private:
    void drawVerScrollBar()
    {
        cout << "绘制垂直滚动条!" << endl;
    }
};
//具体的“水平滚动条”装饰器类
class HorScrollBarDec :public Decorator
{
public:
    HorScrollBarDec(Control* tmpctrl) :Decorator(tmpctrl) {}//构造函数
    virtual void draw()
    {
        Decorator::draw(); //调用父类的draw方法以保持以往已经绘制出的内容
        drawHorScrollBar(); //也要绘制自己的内容
    }
private:
    void drawHorScrollBar()
    {
        cout << "绘制水平滚动条!" << endl;
    }
};
5. 构建控件和装饰者
  • 在 main() 函数中，创建一个 ListCtrl 对象。
  • 使用装饰者类包装该对象，添加所需的功能。例如，先用 BorderDec 装饰，再用 VerScrollBarDec 装饰。
int main()
{
    //(1)创建一个又带边框，又带垂直滚动条的列表控件
    //首先绘制普通的列表控件
    Control* plistctrl = new ListCtrl();
    //plistctrl->draw(); //这里先不绘制了

    //接着“借助普通的列表控件”，可以通过边框装饰器绘制出一个“带边框的列表控件”
    Decorator* plistctrl_b = new BorderDec(plistctrl); //注意形参，是普通列表控件，这里类型用Control *而不用Decorator *也是可以的
    //plistctrl_b->draw();

    //接着“借助带边框的列表控件”，可以通垂直滚动条装饰器绘制出一个“带垂直滚动条又带边框的列表控件”
    Decorator* plistctrl_b_v = new VerScrollBarDec(plistctrl_b); //注意形参，是带边框的列表控件
    plistctrl_b_v->draw(); //这里完整最终绘制

    cout << "-------------------------------" << endl;
    //(2)创建一个只带水平滚动条的列表控件
    //首先绘制普通的列表控件
    Control* plistctrl2 = new ListCtrl();
    //plistctrl2->draw(); //这里先不绘制了

    //接着“借助普通的列表控件”，可以通水平滚动条装饰器绘制出一个“带水平滚动条的列表控件”
    Decorator* plistctrl2_h = new HorScrollBarDec(plistctrl2); //注意形参，是普通列表控件
    plistctrl2_h->draw(); //这里完成最终绘制

    //(3)释放资源
    delete plistctrl_b_v;
    delete plistctrl_b;
    delete plistctrl;

    delete plistctrl2_h;
    delete plistctrl2;

    return 0;
}

UML 图

装饰模式 UML 图1

UML 图解析

  • Control（抽象构件）：

    • 这是一个接口，定义了所有具体构件和装饰器必须实现的 draw() 方法。
    • 其目的是提供一个统一的接口，使得客户端可以以一致的方式操作未被装饰的对象和经过装饰的对象，实现透明操作。

  • ListCtrl（具体构件）：

    • 继承自 Control，实现了 draw() 方法，提供基本的列表控件绘制功能。
    • 作为被装饰的对象，允许后续的装饰者为其添加额外的功能。

  • Decorator（抽象装饰器类）：

    • 同样继承自 Control，持有一个指向 Control 对象的指针（m_control）。
    • 实现了 draw() 方法，调用 m_control 的 draw() 方法，以保持原有的绘制功能，并允许在此基础上添加新的行为。

  • BorderDec、VerScrollBarDec、HorScrollBarDec（具体装饰器类）：

    • 这些类继承自 Decorator，各自实现了额外的功能。
    • 通过重写 draw() 方法，调用父类的 draw() 方法，再添加自己的绘制逻辑（如绘制边框、垂直滚动条和水平滚动条）。

例二：工作流程

  • Beverage（抽象饮料类）：定义了饮料的基本接口。
  • FruitBeverage（具体饮料类）：实现了 Beverage 接口，返回普通水果饮料的价格。
  • Decorator（抽象装饰器类）：持有一个 Beverage 对象的引用，调用其 getprice 方法。
  • SugarDec（砂糖装饰器类）：在基础饮料价格上增加1元。
  • MilkDec（牛奶装饰器类）：在基础饮料价格上增加2元。
  • BubbleDec（珍珠装饰器类）：在基础饮料价格上增加2元。
1. 定义组件接口
  • 创建一个抽象类 Beverage，定义一个纯虚函数 getprice()，用于获取饮料价格。
// 抽象的饮料类
class Beverage {
public:
    virtual int getprice() = 0; // 获取价格
    virtual ~Beverage() {}
};
2. 实现具体组件
  • 创建一个具体类 FruitBeverage，继承自 Beverage，实现 getprice() 方法，返回水果饮料的基本价格。
// 水果饮料类
class FruitBeverage : public Beverage {
public:
    virtual int getprice() override {
        return 10; // 一杯单纯的水果饮料，售价为10元
    }
};
3. 创建装饰者基类
  • 创建一个装饰者类 Decorator，继承自 Beverage，持有一个 Beverage 对象的引用，并在 getprice() 方法中调用该对象的 getprice() 方法。
// 抽象的装饰器类
class Decorator : public Beverage {
public:
    Decorator(Beverage* tmpbvg) : m_pbvg(tmpbvg) {} // 构造函数
    virtual int getprice() override {
        return m_pbvg->getprice(); // 调用被装饰饮料的 getprice 方法
    }
    virtual ~Decorator() {
        delete m_pbvg; // 释放被装饰饮料的内存
    }
private:
    Beverage* m_pbvg; // 需要被装饰的饮料
};
4. 实现具体装饰者
  • 创建多个具体装饰者类，如 SugarDec、MilkDec 和 BubbleDec，它们继承自 Decorator，在 getprice() 方法中扩展功能（如增加价格）。
// 具体的“砂糖”装饰器类
class SugarDec : public Decorator {
public:
    SugarDec(Beverage* tmpbvg) : Decorator(tmpbvg) {} // 构造函数
    virtual int getprice() override {
        return Decorator::getprice() + 1; // 额外加1元
    }
};

// 具体的“牛奶”装饰器类
class MilkDec : public Decorator {
public:
    MilkDec(Beverage* tmpbvg) : Decorator(tmpbvg) {} // 构造函数
    virtual int getprice() override {
        return Decorator::getprice() + 2; // 额外加2元
    }
};

// 具体的“珍珠”装饰器类
class BubbleDec : public Decorator {
public:
    BubbleDec(Beverage* tmpbvg) : Decorator(tmpbvg) {} // 构造函数
    virtual int getprice() override {
        return Decorator::getprice() + 2; // 额外加2元
    }
};
5. 构建饮料和装饰者
  • 在 main() 函数中，创建一个 FruitBeverage 对象。
  • 使用装饰者类包装该对象，添加所需的功能。例如，先用 BubbleDec 装饰，再用 SugarDec 装饰。
int main() {
    // 创建一杯单纯的水果饮料，价格10元
    Beverage* pfruit = new FruitBeverage();
    
    // 向饮料中增加珍珠，价格多加了2元
    Decorator* pfruit_addbubb = new BubbleDec(pfruit);
    
    // 再向饮料中增加砂糖，价格又多加了1元
    Decorator* pfruit_addbubb_addsugar = new SugarDec(pfruit_addbubb);
    
    // 输出最终的价格
    cout << "加了珍珠又加了砂糖的水果饮料最终价格是：" 
         << pfruit_addbubb_addsugar->getprice() << "元人民币" << endl;

    // 释放资源
    delete pfruit_addbubb_addsugar; // 删除最外层装饰器
    delete pfruit_addbubb; // 删除中间装饰器
    delete pfruit; // 删除基础饮料

    return 0;
}

UML 图

装饰模式 UML 图2

UML 图解析

  • Beverage（抽象饮料类）：

    • 这是一个接口，定义了所有具体饮料和装饰器必须实现的 getprice() 方法。
    • 其目的是提供统一的接口，使客户端能够以一致的方式操作未被装饰的对象和经过装饰的对象，实现透明操作。

  • FruitBeverage（具体饮料类）：

    • 继承自 Beverage，实现了 getprice() 方法，返回水果饮料的基本价格（10元）。
    • 作为被装饰的对象，允许后续的装饰者为其添加额外的功能。

  • Decorator（抽象装饰器类）：

    • 同样继承自 Beverage，持有一个指向 Beverage 对象的指针（m_pbvg）。
    • 实现了 getprice() 方法，调用 m_pbvg 的 getprice() 方法，以保持原有的价格计算功能，并允许在此基础上添加新的价格调整。

  • SugarDec、MilkDec、BubbleDec（具体装饰器类）：

    • 这些类继承自 Decorator，各自实现了额外的功能。
    • 通过重写 getprice() 方法，调用父类的 getprice() 方法，再增加自己的价格（如砂糖加1元、牛奶加2元、珍珠加2元），实现对饮料价格的动态扩展。

优缺点

优点：

  • 灵活性：装饰模式允许在运行时动态地增加对象的功能，而不需要修改对象的结构。这使得功能的添加和组合变得更加灵活。

  • 可扩展性：可以通过添加新的装饰者类来扩展功能，避免了类的膨胀。每个装饰者都可以独立开发和维护。

  • 组合性：可以通过组合多个装饰者来创建复杂的功能，而不需要创建大量的子类。这种组合方式使得代码更整洁，易于理解。

  • 遵循单一职责原则：装饰者和具体组件各自负责不同的功能，符合单一职责原则，使得代码更加模块化。

缺点：

  • 复杂性：使用装饰模式可能会导致代码结构变得复杂，尤其是在装饰者层次较多时，可能会让理解和调试变得困难。
  • 装饰者数量：如果不加控制，可能会出现过度装饰的情况，导致对象的功能变得难以理解或者过于复杂。
  • 性能开销：每个装饰者都增加了一层间接调用，可能会导致性能开销，尤其是在装饰链较长时。

适用场景

  • 需要动态添加功能的场景：当需要在运行时为对象添加额外功能时，装饰模式是一个很好的选择。例如，图形界面中的控件可以在不修改原有控件的情况下，动态添加边框、滚动条等功能。
  • 避免类的膨胀：当有许多功能组合的可能性时，使用装饰模式可以避免创建大量的子类。比如，饮料的不同配料组合。
  • 需要组合多个功能的场景：当对象的功能需要组合时，装饰模式提供了一种灵活的方式来实现这些组合，而不需要修改现有的类。
  • 需要遵循开闭原则的场景：当系统需要对扩展开放而对修改关闭时，装饰模式可以通过添加新的装饰者来实现，而不需要修改现有的代码。

例一：示例代码

#include <iostream>
using namespace std;

//抽象的控件类
class Control
{
public:
    virtual void draw() = 0; //draw方法，用于将自身绘制到屏幕上
public:
    virtual ~Control() {} //做父类时析构函数应该为虚函数
};

//列表控件类
class ListCtrl :public Control
{
public:
    virtual void draw()
    {
        cout << "绘制普通的列表控件!" << endl;//具体可以用DirectX或OpenGL来绘制
    }
};

//---------------------------------
//抽象的装饰器类
class Decorator : public Control
{
public:
    Decorator(Control* tmpctrl) :m_control(tmpctrl) {}//构造函数
    virtual void draw()
    {
        m_control->draw();//虚函数，调用的是哪个draw取决于m_control指向的对象
    }
private:
    Control* m_control;  //需要被装饰的其他控件，这里用的是父类指针Control *
};

//具体的“边框”装饰器类
class BorderDec :public Decorator
{
public:
    BorderDec(Control* tmpctrl) :Decorator(tmpctrl) {}//构造函数
    virtual void draw()
    {
        Decorator::draw(); //调用父类的draw方法以保持以往已经绘制出的内容
        drawBorder(); //也要绘制自己的内容
    }
private:
    void drawBorder()
    {
        cout << "绘制边框!" << endl;
    }
};
//具体的“垂直滚动条”装饰器类
class VerScrollBarDec :public Decorator
{
public:
    VerScrollBarDec(Control* tmpctrl) :Decorator(tmpctrl) {}//构造函数
    virtual void draw()
    {
        Decorator::draw(); //调用父类的draw方法以保持以往已经绘制出的内容
        drawVerScrollBar(); //也要绘制自己的内容
    }
private:
    void drawVerScrollBar()
    {
        cout << "绘制垂直滚动条!" << endl;
    }
};
//具体的“水平滚动条”装饰器类
class HorScrollBarDec :public Decorator
{
public:
    HorScrollBarDec(Control* tmpctrl) :Decorator(tmpctrl) {}//构造函数
    virtual void draw()
    {
        Decorator::draw(); //调用父类的draw方法以保持以往已经绘制出的内容
        drawHorScrollBar(); //也要绘制自己的内容
    }
private:
    void drawHorScrollBar()
    {
        cout << "绘制水平滚动条!" << endl;
    }
};

int main()
{
    //(1)创建一个又带边框，又带垂直滚动条的列表控件
    //首先绘制普通的列表控件
    Control* plistctrl = new ListCtrl();
    //plistctrl->draw(); //这里先不绘制了

    //接着“借助普通的列表控件”，可以通过边框装饰器绘制出一个“带边框的列表控件”
    Decorator* plistctrl_b = new BorderDec(plistctrl); //注意形参，是普通列表控件，这里类型用Control *而不用Decorator *也是可以的
    //plistctrl_b->draw();

    //接着“借助带边框的列表控件”，可以通垂直滚动条装饰器绘制出一个“带垂直滚动条又带边框的列表控件”
    Decorator* plistctrl_b_v = new VerScrollBarDec(plistctrl_b); //注意形参，是带边框的列表控件
    plistctrl_b_v->draw(); //这里完整最终绘制

    cout << "-------------------------------" << endl;
    //(2)创建一个只带水平滚动条的列表控件
    //首先绘制普通的列表控件
    Control* plistctrl2 = new ListCtrl();
    //plistctrl2->draw(); //这里先不绘制了

    //接着“借助普通的列表控件”，可以通水平滚动条装饰器绘制出一个“带水平滚动条的列表控件”
    Decorator* plistctrl2_h = new HorScrollBarDec(plistctrl2); //注意形参，是普通列表控件
    plistctrl2_h->draw(); //这里完成最终绘制

    //(3)释放资源
    delete plistctrl_b_v;
    delete plistctrl_b;
    delete plistctrl;

    delete plistctrl2_h;
    delete plistctrl2;

    return 0;
}

例二：示例代码

#include <iostream>
using namespace std;

//抽象的饮料类
class Beverage
{
public:
    virtual int getprice() = 0; //获取价格
public:
    virtual ~Beverage() {}
};

//水果饮料类
class FruitBeverage : public Beverage
{
public:
    virtual int getprice()
    {
        return 10;  //一杯单纯的水果饮料，售价为10元
    }
};

//抽象的装饰器类
class Decorator : public Beverage
{
public:
    Decorator(Beverage* tmpbvg) :m_pbvg(tmpbvg) {}//构造函数
    virtual int getprice()
    {
        return m_pbvg->getprice();
    }
private:
    Beverage* m_pbvg;
};
//具体的“砂糖”装饰器类
class SugarDec : public Decorator
{
public:
    SugarDec(Beverage* tmpbvg) :Decorator(tmpbvg) {}//构造函数
    virtual int getprice()
    {
        return Decorator::getprice() + 1; //额外加多1元，要调用父类的getprice方法以把以往的价格增加进来
    }
};
//具体的“牛奶”装饰器类
class MilkDec : public Decorator
{
public:
    MilkDec(Beverage* tmpbvg) :Decorator(tmpbvg) {}//构造函数
    virtual int getprice()
    {
        return Decorator::getprice() + 2; //额外加多2元，要调用父类的getprice方法以把以往的价格增加进来
    }
};
//具体的“珍珠”装饰器类
class BubbleDec : public Decorator
{
public:
    BubbleDec(Beverage* tmpbvg) :Decorator(tmpbvg) {}//构造函数
    virtual int getprice()
    {
        return Decorator::getprice() + 2; //额外加多2元，要调用父类的getprice方法以把以往的价格增加进来
    }
};

int main()
{
    //-------------------
    //创建一杯单纯的水果饮料，价格10元
    Beverage* pfruit = new FruitBeverage();
    //向饮料中增加珍珠，价格多加了2元
    Decorator* pfruit_addbubb = new BubbleDec(pfruit);
    //再向饮料中增加砂糖，价格又多加了1元
    Decorator* pfruit_addbubb_addsugar = new SugarDec(pfruit_addbubb);
    //输出最终的价格
    cout << "加了珍珠又加了砂糖的水果饮料最终价格是：" << pfruit_addbubb_addsugar->getprice() << "元人民币" << endl;

    //释放资源
    delete pfruit_addbubb_addsugar;
    delete pfruit_addbubb;
    delete pfruit;

    return 0;
}
不是仙人的闲人
关注
专栏目录
C++ 装饰者模式
青春不老，奋斗不止！
03-27 8987
装饰者模式（Decorator Pattern）是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
装饰模式C++实现
mz5111089的专栏
01-31 281
装饰模式主要的应用场景是通过多个子类修改对象本身的属性。如游戏中人物换装备后，各属性的变化。对于增加新的装备的情况，采用装饰模式可以保持原有框架不变，只需增加对应装饰类即可。而对于变装，只需在客户端修改装饰操作即可。 类图结构如下：      实现如下： MyComponent.h   #pragma once class MyComponent { public:
C++设计模式——装饰模式
最新发布
weixin_56499830的博客
04-14 163
装饰模式
装饰模式（C++实现）
qq_23903863的博客
07-26 290
（本博客旨在个人总结回顾） 1、详情： 装饰模式：动态地给一个对象添加一些额外的职责，就扩展功能而言，装饰模式比生成子类更为灵活。 说明： 何时使用：在不想增加很多子类的情况下扩展类。 优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。 缺点：多层装饰比较复杂。 使用场景：①扩展一个类的功能。 ②动态增加功能，动态...
装饰模式 C++实现
stt2019
05-21 357
装饰模式​ 装饰模式（Decorator），动态地给一个对象添加一些额外的职责，就增加功能来说，装饰者模型比生成子类更为灵活。 #include &lt;iostream&gt; #include&lt;string&gt; using namespace std; //"Person"类（concretetcomponent） class Person { pub...
C++设计模式——装饰模式（decorator pattern）
净无邪博客
06-07 737
一、原理讲解 图1 装饰者模式UML图 1.1意图 装饰模式目的是：动态地给一个对象添加一些额外的职责，比生成之类更灵活。 1.2常用场景 一般用于给某个对象添加某个功能，但是又不希望更改该对象底层抽象借口，同时该功能可以动态增删，这时可以考虑用装饰者模式。 1.3实行方法 如图1所示，装饰着Decorator通过继承抽象基类Component，又组合一个Component指针*component，通过重写从Component继承而来的虚函数operation()，在里面用指针调用oper.
C++设计模式——装饰模式（Decorator）
萧海的博客
08-01 347
装饰模式 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。 装饰模式：动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码 & 减少子类个数）。 问题导入： //业务操作 class Stream{ public： virtual void Write(char
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
C++设计模式——组合模式（composite pattern）
净无邪博客
10-21 899
# 一、原理讲解 ## 1.1意图 将对象组合成树形结构以表示“部分 — 整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 ## 1.2应用场景 - 你想表示对象的部分 — 整体层次结构； - 你
装饰者模式 C++ 实现
05-20
装饰者模式 C++ 实现
.NET中的设计模式——一步步发现装饰模式
02-27
学习设计模式的基本目标是要用它，尤其是帮助那些有扎实的OOP基础，而对设计模式很困惑的人在设计中应用它。我不会为不同设计模式写很全面的参考，但我希望这些文章能让你入门。设计模式与特定的语言无关。虽然我用...
c++装饰器模式
燃犀的博客
07-14 643
c++装饰器模式
c++设计模式之装饰者模式
阿特图
04-24 3192
#include   //公共接口 class Component { public:  virtual void Operation() = 0; };     //需要被装饰的对象 class ConcreteComponent :public Component { public:  /*Operation代表每个类所有的操作*/  void Operatio
装饰者模式（C++）
a15605153800的专栏
11-10 448
解决的问题：当我们需要对一个对象添加新的功能。我们可以采用子类继承的方式来解决。 但是装饰者模式可以采用组合的方式，更加的灵活。比如我有一个人的抽象基类，从这个基类派生出了 中国人、美国人、新加坡人等具体类，他们有相同的方法：穿衣服（）。我们想对这个穿衣服进行修饰，>比如穿什么衣服。我们再从人基类中派生出一个装饰类，表示这个装饰类专门用来装饰“人”的。 然后再具体的生成装饰，如从这
C++装饰模式
zion--6135的博客
10-02 590
参考：设计模式C++实现（11）——装饰模式 1. 首先如果有一台手机，并且你一直在不停的换手机，那么可以关于手机抽象一个类(person)，在用具体的手机(iphone)去继承，并通过多态转换（iphone*转person*），从而可以调用统一的抽象接口(phoneTmp->showLook())，这样无论，你换哪个手机，调用的方法（phoneTmp->showLook()）都不会变，只会增加代码，不会修改代码。完美符合开闭原则。 #include <stdlib.h> .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值