Modo de decoración, también conocido como envoltorio (envoltorio), el escenario de uso de este modo es extender dinámicamente algunas responsabilidades adicionales al objeto. Las responsabilidades son funciones. La llamada "dinámica" significa que puedo hacer coincidir arbitrariamente las funciones que quiero, y el orden de las llamadas de función también se puede establecer arbitrariamente.
Utilice la combinación para reemplazar la herencia, para evitar la expansión de la subclase y el abuso de la herencia, de modo que la "extensión de la función de objeto" pueda extenderse dinámicamente según sea necesario. Por ejemplo, en la clase abstracta Se derivan flujo, flujo de archivo, flujo de red, flujo de memoria, etc. Si desea agregar funciones de cifrado de flujo, caché de flujo, cifrado de flujo y caché a los tres flujos, puede comparar la implementación heredada por el método 1. Método y método 2 de forma combinada.
class Stream{
public:
virtual char read(int num) = 0;
virtual void seek(int num) = 0;
virtual void write(int num) = 0;
};
//文件流
class FileStream:Stream{
public :
virtual char read(int num) {
// 读文件的功能
//fileread();
}
virtual void seek(int num){
// 查询文件功能
//fileseek();
}
virtual void write(int num) {
//写文件功能
//fileWrite()
}
};
//内存流
class MemoryStream:Stream{
public :
virtual char read(int num) {
// 读内存的功能
//memoryread();
}
virtual void seek(int num){
// 查询内存功能
//memoryseek();
}
virtual void write(int num) {
//写内存功能
//memoryWrite()
}
};
//加密文件流类
class CryptoFileStream : public FileStream{
virtual char read(int num) {
// 加密内容
// crypto();
// 读文件的功能
//fileread();
}
virtual void seek(int num){
// 加密内容
// crypto();
// 查询文件功能
//fileseek();
// 解密内容
// decrypto();
}
virtual void write(int num) {
// 加密内容
// crypto();
//写文件功能
//fileWrite()
}
};
//加密内存流
class CryptoMemoryStream: public:MemoryStream{
public :
virtual char read(int num) {
// 加密内容
// crypto();
// 读内存的功能
//memoryread();
}
virtual void seek(int num){
// 加密内容
// crypto();
// 查询内存功能
//memoryseek();
// 解密内容
// decrypto();
}
virtual void write(int num) {
// 加密内容
// crypto();
//写内存功能
//memoryWrite()
}
};El primer método es en realidad un ejemplo de abuso de la herencia: si existe un requisito "es necesario agregar una función de caché al flujo de red de flujo de archivos", de acuerdo con el primer método de diseño, ¿es necesario derivar la "clase de flujo de archivos de caché "", "¿Qué pasa con" Transmisión de red en caché "? Si necesita agregar otra secuencia de red, ¿desea agregar una nueva clase de secuencia de red que herede la secuencia según el primer método y luego derivar "clase de secuencia de red cifrada" y "clase de secuencia de red almacenada en caché"? De hecho, el primer diseño tiene mucha redundancia de código. El flujo de archivos, el flujo de memoria, el flujo de red y otras entidades tienen la misma experiencia durante el cifrado, es decir, "estable". El único cambio es leer, verificar y escribir. operando. La relación entre la transmisión y los archivos de transmisión debe ser archivos encriptados que en realidad no "relación entre padres e hijos" hereden el uso adecuado Los escenarios comerciales deben refinarse por encima de la teoría , como la relación del paralelogramo rectangular, la relación rectangular y cuadrada y la expansión funcional no debería utilizar herencia, pero debería utilizar combinación . Por ejemplo, "la relación entre un cuadrado y un cuadrado de color" no debería utilizar herencia.
El modo de decoración es en realidad una combinación
class Stream{
public:
virtual char read(int num) = 0;
virtual void seek(int num) = 0;
virtual void write(int num) = 0;
};
//文件流
class FileStream:Stream{
public :
virtual char read(int num) {
// 读文件的功能
//fileread();
}
virtual void seek(int num){
// 查询文件功能
//fileseek();
}
virtual void write(int num) {
//写文件功能
//fileWrite()
}
};
//内存流
class MemoryStream:Stream{
public :
virtual char read(int num) {
// 读内存的功能
//memoryread();
}
virtual void seek(int num){
// 查询内存功能
//memoryseek();
}
virtual void write(int num) {
//写内存功能
//memoryWrite()
}
};
//功能装饰流类
class DecoratorStream : public Stream{
protected：
Stream * stream;
public:
DecoratorStream(Stream * s ):stream(s){}
};
//流加密
class CryptoStream: public DecoratorStream {
public :
CryptoStream( Stream *s):DecoratorStream (s){}
virtual char read(int num) {
// 加密内容
// crypto();
stream ->read();
}
virtual void seek(int num){
// 加密内容
// crypto();
// 查询
stream ->seek();
// 解密内容
// decrypto();
}
virtual void write(int num) {
// 加密内容
// crypto();
//写功能
stream ->Write()
}
};
//流缓存
class BufferStream: public DecoratorStream {
public :
BufferStream( Stream *s):DecoratorStream (s){}
virtual char read(int num) {
//读缓存
if(bufferread() == null){
stream ->read();
//写缓存内容
bufferwrite();
}
}
virtual void seek(int num){
//读缓存
if(bufferread() == null){
stream ->seek();
//写缓存内容
bufferwrite();
}
}
virtual void write(int num) {
//写功能
stream ->Write()
bufferwrite();
}
};
///
void main(){
Stream* fstream = new FileStream();
fstream->write() ; //写文件
Stream * cryptofstream = new CryptoStream(fstream) ;
cryptofstream ->write() ; // 加密写文件
Stream * buffercryptofstream = new BufferStream(cryptofstream) ;
buffercryptofstream ->write () ; //先缓存后加密写文件
}El anterior es el modo de decoración. Si la clase DecoratorStream no hereda Stream, no admite la función de almacenar en caché y luego encriptar y escribir archivos. Heredar Stream significa que sigue siendo un objeto de flujo después de ensamblar la función. No hay flujo Stream *; puntero de miembro en la clase DecoratorStream, por lo que la decoración funcional es imposible. En comparación con el método 1, el código se simplifica enormemente y se elimina el abuso de la herencia. Se mejora la capacidad de mantenimiento. En el futuro, si "refina las clases de entidad de 5 flujos y las funciones de 5 flujos", la cantidad de clases nuevas necesarias para el método 1 es enorme y el método solo necesita agregar 10 nuevas para lograr Cualquier combinación de funciones de transmisión.