装饰模式

“单一职责”模式:

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

典型模式

.Decorator

.Bridge

1.Decorator模式

代码1：

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

    virtual ~Stream(){}
};

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

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

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

//扩展操作
class CryptoFileStream :public FileStream{
public:
    virtual char Read(int number){

        //额外的加密操作....
        FileStream::Read(number);//读文件流
    }
    virtual char Seek(int position){ 

        //额外的加密操作....
        FileStream::Seek(position);//定位文件流
        //额外的加密操作....
    }
    virtual char Write(int data){
        
        //额外的加密操作....
        FileStream::Write(data);//写文件流
        //额外的加密操作....
    }
};

class BufferedFileSyream :public FileStream{
    //...
};

class BufferedNetWorkStream :public NetworkStream{

};

class BufferedMemoryStream : public MemoryStream{

};

class CryptoBuffedFileStream :public FileStream{
public:
    virtual char Read(int number){
        //额外的加密操作
        //额外的缓冲操作
        FileStream::Read(number);//读文件流
    }
    virtual char Seek(int position){ 
        //额外的加密操作
        //额外的缓冲操作
        FileStream::Seek(position);//定位内存流
    }
    virtual char Write(int data){ 
        //额外的加密操作
        //额外的缓冲操作
        FileStream::Write(data);//写文件流
    }
};

void Process()
{
    //编译时装配
    CryptoFileStream* fs1 = new CryptoFileStream;
    BufferedFileSyream *fs2 = new BufferedFileSyream;
    CryptoBuffedFileStream* fs3 = new CryptoBuffedFileStream;

}      

该代码有什么问题？

冗余度太高！

示意图：

该类的规模有多少？

1+n+n*m!/2

很明显，规模太大，在之后的维护中会占很大的时间

因此，为了消除冗余，使用装饰模型来修改上面的代码

代码2：

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

    virtual ~Stream(){}
};

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

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

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

//扩展操作
//当一个变量的声明类型都是某个类型的子类时候，那么把他声明为某个类型就可以了
class DecoratorStream:public Stream{
protected:
    Stream* stream;
    DecoratorStream(Stream stm) :stream(stm){    //构造器

    }
}

class CryptoStream :public DecoratorStream{
public:
    CryptoStream(Stream stm) :stream(stm){    //构造器

    }


    virtual char Read(int number){

        //额外的加密操作....
        stream->Read(number);//读文件流
    }
    virtual char Seek(int position){

        //额外的加密操作....
        stream->Seek(position);//定位文件流
        //额外的加密操作....
    }
    virtual char Write(int data){

        //额外的加密操作....
        stream->Write(data);//写文件流
        //额外的加密操作....
    }
};

class BufferedSyream :public DecoratorStream{

    //...
public:
    BufferedSyream(Stream stm) :stream(stm){    //构造器

    }
};


class CryptoBuffedFileStream :public FileStream{
public:
    virtual char Read(int number){
        //额外的加密操作
        //额外的缓冲操作
        FileStream::Read(number);//读文件流
    }
    virtual char Seek(int position){
        //额外的加密操作
        //额外的缓冲操作
        FileStream::Seek(position);//定位内存流
    }
    virtual char Write(int data){
        //额外的加密操作
        //额外的缓冲操作
        FileStream::Write(data);//写文件流
    }
};

void Process()
{
    //编译时装配
    FileStream* s1 = new FileStream();
    CryptoStream* s2 = new CryptoStream(s1);
    BufferedSyream* s3 = new BufferedSyream(s1);
    BufferedSyream* s4 = new BufferedSyream(s2);
}      

代码的规模为：1+n+1+m

已经达到了要求！