003 --- 第6章 装饰模式

简述：

　　装饰模式动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

　　装饰模式包括：抽象对象基类、具体对象类、抽象装饰类、具体装饰类。

　　　　抽象对象基类：定义一个对象接口，可以给这些对象动态的添加职责。

　　　　具体对象类：继承自抽象对象基类，定义了具体的对象，可以给这个对象添加一些职责。

　　　　抽象装饰类：继承自抽象对象基类，从类外扩展抽象对象基类的功能，但对于抽象对象基类来说，是无需知道抽象装饰类的存在的。

　　　　具体装饰类：就是具体的装饰对象类、起到给抽象对象基类添加职责的功能。

 

应用场景：为已有功能动态的添加更多功能，装饰类继承具体类的基类，将具体类的对象传入装饰类，装饰类内部执行具体类的逻辑和装饰类本身的逻辑

 

注：开发环境调整为VS2017，操作系统win11

装饰模式代码：

#include <iostream>
using namespace std;

// 装饰模式
// 抽象对象基类
class CComponent
{
public:
    virtual void Operation() = 0;
};

// 具体对象类
class CConcreteComponent : public CComponent
{
public:
    virtual void Operation()
    {
        cout << "具体对象的操作" << endl;
    }
};

// 抽象装饰类
class CDecorator : public CComponent
{
protected:
    CComponent* m_pComponent;

public:
    CDecorator() : m_pComponent(NULL) {};

    void SetComponent(CComponent* pComponent)
    {
        m_pComponent = pComponent;
    }

    virtual void Operation()
    {
        if (m_pComponent != NULL)
        {
            m_pComponent->Operation();
        }
    }
};

// 具体装饰类
class CConcreteDecDecoratorA : public CDecorator
{
private:
    string m_AddedState;

public:
    virtual void Operation()
    {
        CDecorator::Operation();
        m_AddedState = "New State";
        cout << "具体装饰对象A的操作" << endl;
    }
};

// 具体装饰类
class CConcreteDecDecoratorB : public CDecorator
{
public:
    virtual void Operation()
    {
        CDecorator::Operation();
        AddedBehavior();
        cout << "具体装饰对象B的操作" << endl;
    }

private:
    void AddedBehavior()
    {
        cout << "具体装饰对象B新增的行为" << endl;
    }
};

int main()
{
    CConcreteComponent ConcreteComponent;
    CConcreteDecDecoratorA ConcreteDecDecoratorA;
    CConcreteDecDecoratorB ConcreteDecDecoratorB;

    ConcreteDecDecoratorA.SetComponent(&ConcreteComponent);
    ConcreteDecDecoratorB.SetComponent(&ConcreteDecDecoratorA);
    ConcreteDecDecoratorB.Operation();

    system("pause");
    return 0;
}

 输出结果：

 

 

例：GHL见妹子的打扮

代码如下：

#include <iostream>
#include <string>
using namespace std;

// 人的类(具体对象类，本例不需要抽象对象基类)
class CPerson
{
private:
    string m_szName;

public:
    CPerson(){}

    CPerson(string szName)
    {
        m_szName = szName;
    }

    virtual void Show()
    {
        string str = "装扮的[" + m_szName + "]";
        cout << str << endl;
    }
};

// 服装抽象类(抽象装饰类，继承自具体对象类)
class CFinery : public CPerson
{
protected:
    CPerson* m_pComponent;

public:
    void Decorate(CPerson* pComponent)
    {
        m_pComponent = pComponent;
    }
    virtual void Show()
    {
        if (m_pComponent)
            m_pComponent->Show();
    }
};

// 具体服饰类
// 大T恤类（具体装饰类，继承自抽象装饰类）
class CTShirts : public CFinery
{
public:
    virtual void Show()
    {
        cout << "大T恤 ";
        CFinery::Show();
    }
};

// 垮裤类（具体装饰类，继承自抽象装饰类）
class CBigTrouser : public CFinery
{
public:
    virtual void Show()
    {
        cout << "垮裤 ";
        CFinery::Show();
    }
};

// 破球鞋类（具体装饰类，继承自抽象装饰类）
class CSneakers : public CFinery
{
public:
    virtual void Show()
    {
        cout << "破球鞋 ";
        CFinery::Show();
    }
};

// 西装类（具体装饰类，继承自抽象装饰类）
class CSuit : public CFinery
{
public:
    virtual void Show()
    {
        cout << "西装 ";
        CFinery::Show();
    }
};

// 领带类（具体装饰类，继承自抽象装饰类）
class CTie : public CFinery
{
public:
    virtual void Show()
    {
        cout << "领带 ";
        CFinery::Show();
    }
};

// 皮鞋类（具体装饰类，继承自抽象装饰类）
class CLeatherShoes : public CFinery
{
public:
    virtual void Show()
    {
        cout << "皮鞋 ";
        CFinery::Show();
    }
};

int main()
{
    CPerson Person("GHL");

    cout << "第一种装扮：" << endl;
    CSneakers Sneakers;
    CBigTrouser BigTrouser;
    CTShirts TShirts;
    Sneakers.Decorate(&Person);
    BigTrouser.Decorate(&Sneakers);
    TShirts.Decorate(&BigTrouser);
    TShirts.Show();

    cout << "第二种装扮：" << endl;
    CLeatherShoes LeatherShoes;
    CTie Tie;
    CSuit Suit;
    LeatherShoes.Decorate(&Person);
    Tie.Decorate(&LeatherShoes);
    Suit.Decorate(&Tie);
    Suit.Show();

    system("pause");
    return 0;
}

输出结果：