设计模式之 - 装饰模式

一、定义

        装饰模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。有时我们希望给某个对象而不是整个类添加一些功能。比如有一个手机，允许你为手机添加特性，比如增加挂件、屏幕贴膜等。一种灵活的设计方式是，将手机嵌入到另一对象中，由这个对象完成特性的添加，我们称这个嵌入的对象为装饰。这个装饰与它所装饰的组件接口一致，因此它对使用该组件的客户透明。

二、组成

1) 抽象构件角色（ Component）：定义一个抽象接口，以规范准备接收附加责任的对象。

2) 具体构件角色(ConcreteComponent)：这是被装饰者，定义一个将要被装饰增加功能的类。

3) 装饰角色(Decorator)：持有一个构件对象的实例，并定义了抽象构件定义的接口。

4) 具体装饰角色(ConcreteDecorator)：负责给构件添加增加的功能。

三、实现

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

//抽象构建角色--手机
class Phone
{
public:
	Phone() {}
	virtual ~Phone() {}
	virtual void ShowDecorate() {}
};

//具体构建角色--具体的手机类
class iPhone : public Phone
{
private:
	string m_name; //手机名称
public:
	iPhone(string name): m_name(name){}
	~iPhone() {}
	void ShowDecorate() { cout<<m_name<<"的装饰"<<endl;}
};
//具体构建角色--具体的手机类
class NokiaPhone : public Phone
{
private:
	string m_name;	
public:
	NokiaPhone(string name): m_name(name){}
	~NokiaPhone() {}
	void ShowDecorate() { cout<<m_name<<"的装饰"<<endl;}
};

//装饰角色--装饰类
class DecoratorPhone : public Phone
{
private:
	Phone *m_phone;  //要装饰的手机
public:
	DecoratorPhone(Phone *phone): m_phone(phone) {}
	virtual void ShowDecorate() { m_phone->ShowDecorate(); }
};

//具体装饰角色
class DecoratorPhoneA : public DecoratorPhone
{
public:
	DecoratorPhoneA(Phone *phone) : DecoratorPhone(phone) {}
	void ShowDecorate() { DecoratorPhone::ShowDecorate(); AddDecorate(); }
private:
	void AddDecorate() { cout<<"增加挂件"<<endl; } //增加的装饰
};

//具体装饰角色
class DecoratorPhoneB : public DecoratorPhone
{
public:
	DecoratorPhoneB(Phone *phone) : DecoratorPhone(phone) {}
	void ShowDecorate() { DecoratorPhone::ShowDecorate(); AddDecorate(); }
private:
	void AddDecorate() { cout<<"屏幕贴膜"<<endl; } //增加的装饰
};

int main()
{
	Phone *MyPhone = new NokiaPhone("N72");
	Phone *dpa = new DecoratorPhoneA(MyPhone); //装饰，增加挂件
	Phone *dpb = new DecoratorPhoneB(dpa);    //装饰，屏幕贴膜
	dpb->ShowDecorate();
	delete dpa;
	delete dpb;
	delete MyPhone;
	return 0;
}

四、使用场合

(1)      在不影响其他对象的情况下，以动态的，透明的方式给单个对象添加职责；

(2)      处理那些可以撤销的职责；

(3)      当不能采用生成子类的方法进行扩充时。一种情况是，可能存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。