【C++设计模式】4.4-装饰者模式（Decorator）

装饰者模式（Decorator）

一、 装饰者模式（Decorator）

1. 模式动机

    在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性，并且随着子类的增多(扩展功能的增多)，各种子类的组合(扩展功能的组合)会导致更多子类的膨胀。
    如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响将为最低？

2. 模式定义

    动态(组合)地给一个对象增加一些额外的职责。就增加功能而言，Decorator 模式比生成子类(继承)更为灵活(消除重复代码&减少子类个数)。

3. 要点总结

（1）通过采用组合而非继承的手法，Decorator 模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。
（2）Decorator类在接口上表现为 is-a Component 的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
（3）Decorator 模式的目的并非解决“多子类衍生的多继承"问题，Decorator 模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。

三、实现

代码

    以文件流、网络流、内存流读写、定位操作以及扩展的加密及缓存功能实现为例，并对比重构前后代码。

重构前

    未使用装饰模式时，如下图结构，存在结构不行（不良使用继承）的缺点，其次是类的总数的暴增(很多重复的代码)，总数是：

/**
 * 未使用装饰模式
 */
// 业务操作
class Stream{
public:
	virtual bool Read(int num) = 0;
	virtual void Seek(int position) = 0;
	virtual bool Write(string data) = 0;
	void ~Stream(){}
};
// 主体操作
class FileStream : public Stream{
public:
	virtual bool Read(int num){
		//读文件流
	}
	virtual void Seek(int position){
		//定位文件流
	}
	virtual bool Write(string data){
		//写文件流
	}
};
class NetworkStream: public Stream{
public:
	virtual bool Read(int num){
		//读网络流
	}
	virtual void Seek(int position){
		//定位网络流
	}
	virtual bool Write(string data){
		//写网络流
	}
};
class MemoryStream : public Stream{
public:
	virtual bool Read(int num){
		//读内存流
	}
	virtual void Seek(int position){
		//定位内存流
	}
	virtual bool Write(string data){
		//写内存流
	}
};
// 扩展操作
class CryptoFileStream : public FileStream{	//加密操作
public:
	virtual bool Read(int number){
		//额外的加密操作
		FileStream::Read(number);
	}
	virtual void Seek(int position){
		//额外的加密操作
		FileStream::Seek(position);
	}
	virtualbool Write(string data){
		//额外的加密操作
		FileStream::Write(data);
	}
};
class CryptoNetworkStream : public Networktream{ //加密操作
	//...
}
class CryptoMemoryStream : public MemoryStream{ //加密操作
	//...
}
class BufferedFileStream : public FileStream{ //缓存操作
	//... 缓存操作与加密操作类似
}
class BufferedNetworkStream : public NetworkStream{ //缓存操作
	//... 缓存操作与加密操作类似
}
class BufferedMemoryStream : public MemoryStream{ //缓存操作
	//... 缓存操作与加密操作类似
}
// 此处省略其他操作 ... 文件流、网络流、内存流等其他流都需要做类似的操作

装饰模式类图

    下面是使用了观察者模式的类图及其对应重构后代码中的类。

• 代码在被大量的重复，找到具体的重构点进行重构
• 当多个类里都有一个变量Var的声明类型都是某个类型Class的子类ChildClass的时候则声明该变量Var为类型Class即可
• 多态，编译时的东西变成运行时的东西
• 一个类既有一个Stream的基类也有一个基类Stream的字段，基类Stream是为了完善子类内虚函数的接口规范，而基类Stream的字段是为了使用组和的方式支持未来多态的变化
• 如果有两个或多个子类内拥有同个类型的字段，应该把该类型字段往上并作为基类继承

重构后

/**
 * 使用装饰模式，在Decorator类中含有父类的字段
 */
class Stream{
public:
	virtual bool Read(int num) = 0;
	virtual void Seek(int position) = 0;
	virtual bool Write(string data) = 0;
	void ~Stream(){}
};
// 主体操作
class FileStream : public Stream{
public:
	virtual bool Read(int num){
		//读文件流
	}
	virtual void Seek(int position){
		//定位文件流
	}
	virtual bool Write(string data){
		//写文件流
	}
};
class NetworkStream: public Stream{
public:
	virtual bool Read(int num){
		//读网络流
	}
	virtual void Seek(int position){
		//定位网络流
	}
	virtual bool Write(string data){
		//写网络流
	}
};
class MemoryStream : public Stream{
public:
	virtual bool Read(int num){
		//读内存流
	}
	virtual void Seek(int position){
		//定位内存流
	}
	virtual bool Write(string data){
		//写内存流
	}
};
// 扩展操作
class DecoratorStream : public Stream{
protected:
	Stream* stream;		// 用组合的方式引出多态的支持
	DecoratorStream(Stream* stm):stream(stm){}
};
class CryptoStream : public DecoratorStream{
public:
	CryptoStream(Stream* stm):DecoratorStream(stm){}
	virtual bool Read(int num){
		stream->Read(number);	//读流
	}
	virtual void Seek(int position){
		stream->Seek(position);	//定位流
	}
	virtual bool Write(string data){
		stream->Write(data);	//写流
	}
};
class BufferedStream : public DecoratorStream{
	Stream* stream;
public:
	BufferedStream(Stream* stm) : DecoratorStream(stm){}
	//...
}

void onProcess(){
	// 运行时装配
	FileStream* s1 = new FileStream();
	CryptoStream* s2 = new CryptoStream(s1);
	BufferedStream* s3 = new BufferedStream(s1);
	BufferedStream* s4 = new BufferedStream(s2);
}