装饰器模式

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

ex:

class Stream{
public:
    virtual char Read(int num) = 0;
    virtual void Write(int num) = 0;
};

class FileStream : public Stream{
public:
    virtual char Read(int num) {
        return ' ';
    }
    virtual void Write(int num) {
        return ;
    }
};

class NetworkStream :public Stream{
public:
    virtual char Read(int num) {
        return ' ';
    }
    virtual void Write(int num) {
        return ;
    }
};


//如果我需要进行加密
class CryptoFilesStream : public FileStream {
public:
    virtual char Read(int num) {
        //解密操作
        // ...
        FileStream::Read(num);
    }
    virtual void Write(int num) {
        //加密操作
        //...
        FileStream::Write(num);
    }
};

//添加缓冲区
class CryptoBufferFileStream : public FileStream{
    virtual char Read(int num) {
        //解密操作
        //缓冲操作
        // ...
        FileStream::Read(num);
    }
    virtual void Write(int num) {
        //加密操作
        //缓冲操作
        //...
        FileStream::Write(num);
    }
};

有两个基本的 FileStream, NetworkStream 他们分别封装了文件和网络的write和read， 之后我们需要对这些文件加密，还要对这个stream进行缓存，甚至更多的操作。
上面代码存在的问题 CryptoBufferFileStream 这个类实际上又要将crypto又要重新写一次，显然不好

可以看下面的实现：

//这里继承Stream 是为了统一接口
class CryptoFilesStream1 : public Stream {
    Stream* stream;
public:

    CryptoFilesStream1(Stream* stm){
        stream = stm;
    }

    virtual char Read(int num) {
        //解密操作
        // ...
        return stream->Read(num);
    }
    virtual void Write(int num) {
        //加密操作
        //...
        stream->Write(num);
        return ;
    }
};

class BufferedStream : public Stream{
    Stream* stream;
public:
    BufferedStream(Stream* stm){
        stream = stm;
    }

    virtual char Read(int num) {
        //缓存操作
        return stream->Read(num);
    }
    virtual void Write(int num) {
        //缓存操作
        stream->Write(num);
        return ;
    }
};

// 这样子我们可以BufferedStream构建的时候放入任何Stream
/*
    FileStream file_stream = FileStream();
    CryptoStream crypto_stream =  CryptoStream(&file_stream)
    auto buff_stream = BufferedStream(&crypto_stream);
 * */
//

定义一个Stream 的指针，这样子每一层stram只需要关系自己的内容。 这里可以联想到ogre。
这里CryptoFilesStream1, BufferedStream 都继承Stream是为了统一接口。
Stream* stream; 可以向上提，但是能不放在base 的sream 显然不适合，因为FileStream和NerworkStream 显然用不到它们。

我们可以重新添加一个类 DecoratorStream, 封装Stream

class DecoratorStream: public Stream{
protected:
    Stream* stream;
    DecoratorStream(Stream* stream){

    }
};

class CryptoFilesStream2 : public DecoratorStream {
public:

    CryptoFilesStream2(Stream* stm): DecoratorStream(stm){
    }

    virtual char Read(int num) {
        //解密操作
        // ...
        return stream->Read(num);
    }
    virtual void Write(int num) {
        //加密操作
        //...
        stream->Write(num);
        return ;
    }
};