C++设计模式－装饰模式(Decorator)

关键词：组合，动态；而非继承，静态

“单一职责”模式：

        在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候关键是划分责任。

典型模式：

• Decorator
• Bridge

动机：

        在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更更多子类的膨胀。

        如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能地增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响降为最低？

结构：

要点：

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

举例：

反例：

 

//业务操作
class Stream {
public:
	virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;

	virtual ~Stream() {}
};

//主体类
class FileStream : public Stream {
public:
	virtual char Read(int number) {
		//读文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//写文件流
	}
};

class NetworkStream : public Stream {
public:
	virtual char Read(int number) {
		//读网络流
	}
	virtual void Seek(int position) {
		//定位网络流
	}
	virtual void Write(char data) {
		//写网络流
	}
};

class MemoryStream : public Stream {
public:
	virtual char Read(int number) {
		//读内存流
	}
	virtual void Seek(int position) {
		//定位内存流
	}
	virtual void Write(char data) {
		//写内存流
	}
};



//扩展操作
class CryptoFileStream : public FileStream {
public:
	virtual char Read(int number) {
		//额外的加密操作....
		FileStream::Read(number);//读文件流
	}
	virtual void Seek(int position) {
		//额外的加密操作....
		FileStream::Seek(position); // 定位文件流
		//额外的加密操作....
	}
	virtual void Write(char data) {
		//额外的加密操作....
		FileStream::Write(data);//写文件流
		//额外的加密操作....
	}
};

class CryptoNetworkStream : public NetworkStream {
public:
	virtual char Read(int number) {
		//额外的加密操作....
		NetworkStream::Seek(number); 
		//额外的加密操作....
	}
	virtual void Seek(int position) {
		//额外的加密操作....
		NetworkStream::Seek(position); 
		//额外的加密操作....
	}
	virtual void Write(char data) {
		//额外的加密操作....
		NetworkStream::Seek(data); 
		//额外的加密操作....
	}
};

class CryptoMemoryStream : public MemoryStream {
public:
	virtual char Read(int number) {
		//额外的加密操作....
		MemoryStream::Seek(number); 
		//额外的加密操作....
	}
	virtual void Seek(int position) {
		//额外的加密操作....
		MemoryStream::Seek(position); 
		//额外的加密操作....
	}
	virtual void Write(char data) {
		//额外的加密操作....
		MemoryStream::Seek(data); 
		//额外的加密操作....
	}
};

/*
其他继承的类类似，这里不过多赘述
*/
void Process() {
	//编译时装配
	CryptoFileStream* fs1 = new CryptoFileStream();
	BufferedFileStream* fs2 = new BufferdFileStream();
	CryptoBufferdFileStream* fs3 = new CryptoBufferdFileStream();
}

其中存在的大量重复。针对其中一个类举例进行重构。

//扩展操作
class CryptoFileStream {
	FileStream* stream;
public:
	virtual char Read(int number) {
		//额外的加密操作....
		stream->Read(number);//读文件流
	}
	virtual void Seek(int position) {
		//额外的加密操作....
		stream->Seek(position); // 定位文件流
		//额外的加密操作....
	}
	virtual void Write(char data) {
		//额外的加密操作....
		stream->Write(data);//写文件流
		//额外的加密操作....
	}
};

利用组合的方式。我们可以再次改进(Stream* stream=new Stream())，编译时一样，运行时不一样，利用多态支持他的变化

正例：

//扩展操作
class CryptoFileStream {
	Stream* stream;//=new Stream()
public:
	virtual char Read(int number) {
		//额外的加密操作....
		stream->Read(number);//读文件流
	}
	virtual void Seek(int position) {
		//额外的加密操作....
		stream->Seek(position); // 定位文件流
		//额外的加密操作....
	}
	virtual void Write(char data) {
		//额外的加密操作....
		stream->Write(data);//写文件流
		//额外的加密操作....
	}
};

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

DecoratorStream:public Stream{
protected:
	Stream* stream;
	DecoratorStream(Stream* stm) :steam(stm) {

	}
}