设计模式——装饰者模式（C++）

上车了不说了，就直接放代码了哈，有问题可留言。

先放main函数，注意理解注释哈。

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:main.cpp
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#include "Componet.h"               // 抽象装饰类    （抽象的基类）
#include "concreteComponet.h"       // 被装饰类      （基类的具体派生类）
#include "Decorator.h"              // 装饰方法类
#include <iostream>

using namespace std;

// 装饰模式：是为被装饰者动态的添加装饰方法，添加的装饰方法可以任意组合。

// 将基类中的核心方法和非核心方法抽象出来，基类的派生类持有其核心方法不变，并不同的派生类可根据自身需要扩展非核心方法（即：添加装饰或叫被装饰）
// 将众多的非核心方法单独封装成类（即：装饰方法类），再利用装饰模式将装饰方法类通过扩展接口任意重组添加到派生类中。
// 这样可以有效地将类的核心方法和非核心方法（装饰方法）区分开来，简化基类类和派生类。若要添加新的装饰方法，则只需建立一个该装饰方法类，
// 再用该类去装饰某个派生类，这样就非常好的做到了对"修改关闭，扩展开放"。

int main() {
// 对某个派生类进行层层装饰，最终返回满足需求的对象
Decorator dec1 = new oneDecorator(new twoDecorator(new threeDecorator(new concreteComponetA)));
dec1.dosomething();
dec1.coreFunction1();
dec1.coreFunction2();

// 装饰方法是可以任意组合的
Decorator dec2 = new threeDecorator(new oneDecorator(new concreteComponetB));
dec2.dosomething();
dec2.coreFunction1();
dec2.coreFunction2();

system("pause");
return 0;
}

将基类抽象出来，就是下面这个样子的。

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:Coomponet.h
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#ifndef _COMPONET_H
#define _COMPONET_H

// 抽象装饰类（基类），定义concreteComponet类（即：被装饰类，派生类）和Decorator类（即：装饰方法类）的接口。
class Componet {
public:
void coreFunction1();                   // 核心方法1
void coreFunction2();                   // 核心方法2
virtual void dosomething() = 0;         // 非核心方法（扩展接口）
};

#endif // _COMPONET_H

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:Coomponet.cpp
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#include "Componet.h"
#include <iostream>

using namespace std;

// 基类核心方法1
void Componet::coreFunction1() {
cout << "核心方法1" << endl;
}

// 基类核心方法2
void Componet::coreFunction2() {
cout << "核心方法2" << endl;

}

// 基类可扩展接口（由原有类的派生类去实现，这样的话不同的派生类都会持有原有类的核心方法，但可以根据自身需要扩展不同的方法）
void Componet::dosomething() {

}

然后具体的派生类，也就是被装饰者的定义及实现：

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:concreteCoomponet.h
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#ifndef _CONCRETECOMPONET_H
#define _CONCRETECOMPONET_H

#include "Componet.h"

// 具体被装饰类（派生类）A，要实现基类定义的接口
class concreteComponetA : public Componet {
public:
virtual void dosomething();
};

// 具体被装饰类（派生类）B，要实现基类定义的接口
class concreteComponetB : public Componet {
public:
virtual void dosomething();
};

// 具体被装饰类（派生类）C，要实现基类定义的接口
class concreteComponetC : public Componet {
public:
virtual void dosomething();
};

#endif // _CONCRETECOMPONET_H

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:concreteCoomponet.cpp
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#include "concreteComponet.h"
#include <iostream>

using namespace std;

// 具体被装饰类A
void concreteComponetA::dosomething() {
cout << "A类" << endl;
}

// 具体被装饰类B
void concreteComponetB::dosomething() {
cout << "B类" << endl;
}

// 具体被装饰类C
void concreteComponetC::dosomething() {
cout << "C类" << endl;
}

最后就是装饰方法类的定义及实现：

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:Decorator.h
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#ifndef _DECORATOR_H
#define _DECORATOR_H

#include "Componet.h"

class Componet;

// 定义装饰方法类（即：将各种装饰方法单独封装成类）
class Decorator : public Componet {
private:
Componet *com;
public:
Decorator(Componet *com);
virtual void dosomething();
};

// 装饰方法类1
class oneDecorator : public Componet {
private:
Componet *com;
public:
oneDecorator(Componet *com);
virtual void dosomething();
};

// 装饰方法类2
class twoDecorator : public Componet {
private:
Componet *com;
public:
twoDecorator(Componet *com);
virtual void dosomething();
};

// 装饰方法类3
class threeDecorator : public Componet {
private:
Componet *com;
public:
threeDecorator(Componet *com);
virtual void dosomething();
};

#endif // _DECORATOR_H

/*****************************************
Copyright (c) 2016 Jingshuang Hu

@filename:Decorator.cpp
@datetime:2016.09.11
@author:HJS
@e-mail:jingshuang_hu@163.com
@blog:http://blog.csdn.net/hujingshuang
*****************************************/
#include "Decorator.h"
#include <iostream>

using namespace std;

// 定义装饰方法类接口
Decorator::Decorator(Componet *com) {
this->com = com;
}

void Decorator::dosomething() {
com->dosomething();
}

// 当前被装饰者
oneDecorator::oneDecorator(Componet *com) {
this->com = com;
}

// 为当前被装饰者添加装饰方法1
void oneDecorator::dosomething() {
com->dosomething();
cout << "添加了装饰方法1" << endl;
}

// 当前被装饰者
twoDecorator::twoDecorator(Componet *com) {
this->com = com;
}

// 为当前被装饰者添加装饰方法2
void twoDecorator::dosomething() {
com->dosomething();
cout << "添加了装饰方法2" << endl;
}

// 当前被装饰者
threeDecorator::threeDecorator(Componet *com) {
this->com = com;
}

// 为当前被装饰者添加装饰方法3
void threeDecorator::dosomething() {
com->dosomething();
cout << "添加了装饰方法3" << endl;
}

你以为这样就完了？为方便观察，不使网页滑上滑下的，最后再放一下main函数代码及注释。

// 装饰模式：是为被装饰者动态的添加装饰方法，添加的装饰方法可以任意组合。

// 将基类中的核心方法和非核心方法抽象出来，基类的派生类持有其核心方法不变，并不同的派生类可根据自身需要扩展非核心方法（即：添加装饰或叫被装饰）
// 将众多的非核心方法单独封装成类（即：装饰方法类），再利用装饰模式将装饰方法类通过扩展接口任意重组添加到派生类中。
// 这样可以有效地将类的核心方法和非核心方法（装饰方法）区分开来，简化基类类和派生类。若要添加新的装饰方法，则只需建立一个该装饰方法类，
// 再用该类去装饰某个派生类，这样就非常好的做到了对"修改关闭，扩展开放"。

int main() {
// 对某个派生类进行层层装饰，最终返回满足需求的对象
Decorator dec1 = new oneDecorator(new twoDecorator(new threeDecorator(new concreteComponetA)));
dec1.dosomething();
dec1.coreFunction1();
dec1.coreFunction2();

// 装饰方法是可以任意组合的
Decorator dec2 = new threeDecorator(new oneDecorator(new concreteComponetB));
dec2.dosomething();
dec2.coreFunction1();
dec2.coreFunction2();

system("pause");
return 0;
}

结果：