设计模式 装饰模式

1、person.h

#ifndef PERSON_H
#define PERSON_H

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


class Person //Component,是抽象基类
{
public:
    Person(){}
    Person(string name)
    {
        mName = name;
    }
    virtual ~Person(){}
    virtual void Show()//Operation,是被装饰接口,它的所有派生类都要实现Operation方法
    {
        cout<< mName << ":  ";
    }

private:
    string mName;

};

#endif // PERSON_H

2、decorator.h

#ifndef DECORATOR_H
#define DECORATOR_H

#include "person.h"

class Decorator : public Person //Decorator,是装饰对象基类,继承自Component-Person
{
public:
    Decorator(){}
    void Decorate(Person* p)
    {
        mPerson = p;
    }
    virtual void Show()
    {
        mPerson->Show();
    }

private:
    Person* mPerson;
};

#endif // DECORATOR_H

3、jhluroom.h

#ifndef JHLUROOM_H
#define JHLUROOM_H

#include "person.h"

class JhluRoom : public Person //ConcreteComponent,是被装饰对象的具体类,继承自Component-Person
{
public:
    JhluRoom();
    JhluRoom(string name);
};

JhluRoom::JhluRoom(){}

JhluRoom::JhluRoom(string name) :Person(name){}

#endif // JHLUROOM_H

4、headergreen.h

#ifndef HEADERGREEN_H
#define HEADERGREEN_H

#include "decorator.h"

class HeaderGreen : public Decorator //ConcreateDecorator,是具体的装饰类
{
public:
    HeaderGreen();
    virtual void Show();
};

HeaderGreen::HeaderGreen(){}

void HeaderGreen::Show()
{
    Decorator::Show();
    cout<<"head ware green."<<endl;
}
#endif // HEADERGREEN_H

5、headerred.h

#ifndef HEADERRED_H
#define HEADERRED_H

#include "decorator.h"

class HeaderRed : public Decorator //ConcreateDecorator,是具体的装饰类
{
public:
    HeaderRed();
    virtual void Show();
};

HeaderRed::HeaderRed(){}

void HeaderRed::Show()
{
    Decorator::Show();
    cout<<"head ware red."<<endl;
}
#endif // HEADERRED_H

6、footergreen.h

#ifndef FOOTERGREEN_H
#define FOOTERGREEN_H

#include "decorator.h"

class FooterGreen : public Decorator //ConcreateDecorator,是具体的装饰类
{
public:
    FooterGreen();
    virtual void Show();
};

FooterGreen::FooterGreen(){}

void FooterGreen::Show()
{
    Decorator::Show();
    cout<<"foot ware green."<<endl;
}
#endif // FOOTERGREEN_H

7、footerred.h

#ifndef FOOTERRED_H
#define FOOTERRED_H

#include "decorator.h"

class FooterRed : public Decorator //ConcreateDecorator,是具体的装饰类
{
public:
    FooterRed();
    virtual void Show();
};

FooterRed::FooterRed(){}

void FooterRed::Show()
{
    Decorator::Show();
    cout<<"foot ware red."<<endl;
}
#endif // FOOTERRED_H

8、main.cpp

/*
作者：jhluroom弹   QQ：454676244  MSN：jhlu0815@hotmail.com
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

定义：
动态地给一个对象添加一些额外的职责。就增加功能来说，装饰（Decorator）模式相比生成子类更为灵活。
也叫包装器（Wrapper）。

理解：
1.Component是抽象基类，它是被装饰对象和装饰对象的共同基类，装饰的目的是为Component接口动态增加额外功能。
  ConcreteComponent是被装饰对象的具体类。
2.Decorator是装饰对象基类。它继承自Component，包含一个指向基类Component的指针，并且Decorator的接口必须和
  Component是一致的。ConcreateDecorator是具体的装饰类，装饰ConcreteComponent，具体装饰类包含额外职责方法
  （如AddedBehavior），这些方法可以作为私有成员来处理（对内开放-对外封闭原则）。
3.Component::Operation是被装饰接口。它的所有派生类都要实现Operation方法。具体的装饰类，
  在Operation方法的基础上增加额外职责。
4.将ConceteComponent对象指针传给ConcreteDecorator产生装饰类。装饰类对基类方法Operation进行多态处理，
  这样就完成了对动态对象添加额外指责的功能。

要点：
1.装饰模式从完成了一些继承的功能。继承是静态特性，在编译期间增加类的功能；
  而Decorator模式是动态特性，在运行时动态地增加某个对象的功能。装饰模式可以解决类继承灵活性差的问题。
2.使用继承方式产生子类，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长，成为“类爆炸”，
  装饰模式可以灵活地解决类爆炸问题。

应用：打印演员穿服装的报表，不同的演员穿着不同:
在这里主要讨论“头上穿的”（head）和“脚上穿的”(foot)，
一个演员可以只穿头上的，也可以只穿脚上的，也可以两者都穿。
头上可以穿红的也可以穿绿的，脚上可以穿红的也可以穿绿的。

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "person.h"
#include "decorator.h"
#include "jhluroom.h"
#include "headergreen.h"
#include "headerred.h"
#include "footergreen.h"
#include "footerred.h"

int main(int argc, char *argv[])
{
    cout << "=== jhluroom start ========" << endl;

    // client code here
    Person *xiaoli = new JhluRoom("xiaoli"); //被装饰对象
    Person *xiaolv = new JhluRoom("xiaolv"); //被装饰对象
    Person *xiaowang = new JhluRoom("xiaowang"); //被装饰对象
    Person *xiaoliang = new JhluRoom("xiaoliang"); //被装饰对象


    HeaderGreen headerGreen;
    HeaderRed headerRed;
    FooterGreen footerGreen;
    FooterRed footerRed;

    headerGreen.Decorate(xiaoli);
    headerGreen.Show();

    footerGreen.Decorate(xiaoli);
    footerGreen.Show();

    headerRed.Decorate(xiaolv);
    headerRed.Show();

    footerRed.Decorate(xiaolv);
    footerRed.Show();

    headerGreen.Decorate(xiaowang);
    headerGreen.Show();

    footerRed.Decorate(xiaoliang);
    footerRed.Show();

    cout << "=== jhluroom finish _^_ ===" << endl;

    return 0;
}

运行结果：
=== jhluroom start ========
xiaoli:  head ware green.
xiaoli:  foot ware green.
xiaolv:  head ware red.
xiaolv:  foot ware red.
xiaowang:  head ware green.
xiaoliang:  foot ware red.

=== jhluroom finish _^_ ===