设计模式学习

dxgzg

已于 2022-02-25 20:34:20 修改

阅读量221

点赞数

分类专栏：设计模式文章标签：学习

于 2022-02-19 14:27:17 首次发布

本文链接：https://blog.youkuaiyun.com/dxgzg/article/details/123017930

版权

设计模式专栏收录该内容

4 篇文章

订阅专栏

李建忠老师讲的，以前B站有，后来被删了，只能上youtube看了添加链接描述
以前听过几堂课，代码写的少并没有真正的理解，自己网站前一阵子更新了一波代码突然发现代码之间组合竟然设计的紊乱，所以重新认真的学习一下。

重要的原则

记住依赖倒置原则、针对接口编程而不是实现编程，依赖抽象而不是具体实现的细节，比如有一个类需要调用跑车，我们不要真的调用跑车这个类，而是要让代码调用汽车这个类，跑车这个类继承汽车类。这样的好处就是如果添加SUV这个类不需要在重新一遍相似的代码，这样提高复用性。

封闭开放原则也是，划分成稳定和变化的因素

好好利用晚绑定，利用虚函数和多态。模板方法、策略模式、观察者模式还是利用抽象来拆解具体实现的细节的模式。

理解且记住这些原则背后的思想比记住模式的架构有用100倍

装饰模式

他和桥接模式都是发现子类代码重复高，没有好的复用的时候来进行改造的

using byte = char;
//业务操作
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 decorate : public Stream {
protected:
    Stream* stream_;
    decorate(Stream* stm):stream_(stm){}
};
//扩展操作
class CryptoStream : public decorate
{
public:
    CryptoStream(Stream* stm):decorate(stm){}
    virtual char Read(int number)
    {

        //额外的加密操作...
        stream_->Read(number); //读文件流
    }
    virtual void Seek(int position)
    {
        //额外的加密操作...
        stream_->Seek(position); //定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data)
    {
        //额外的加密操作...
        stream_->Write(data); //写文件流
        //额外的加密操作...
    }
};

class BufferedStream : public decorate
{
public:
    BufferedStream(Stream* stm):decorate(stm){}
    virtual char Read(int number)
    {

        //额外的加密操作...
        //额外的缓冲操作...
        stream_->Read(number); //读文件流
    }
    virtual void Seek(int position)
    {
        // 应该再加一个模板方式的，启动这个seek
        //额外的加密操作...1
        //额外的缓冲操作...2
        stream_->Seek(position); //定位文件流3
        //额外的加密操作...4
        //额外的缓冲操作...5
    }
    virtual void Write(byte data)
    {
        //额外的加密操作...
        //额外的缓冲操作...
        stream_->Write(data); //写文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
};

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

    BufferedStream* s4 = new BufferedStream(s2);
    s4->Write('1');
}

decorate 这个类为什么要继承Stream呢？因为他下面的功能如果混合使用的话，构造参数就需要传参数s2（Process里的），如果不继承Stream，s2的参数类型就转换成Stream

工厂模式

/*
* 为什么需要工厂类？
* 像下面这个例子，其实我认为是完全不需要工厂类的，MainForm的
* factory类型换成ISplitter是完全可代替的。
* 但工厂模式秒处在哪里呢？这是一个产品，但如果我需要两个产品
* 比如键盘和鼠标，鼠标和键盘都是抽象基类，没有共同祖先，这时候MainForm
* 一个变量就不够了，但如果是Factory类型，就说明还是他一个就行，工厂这个
* 抽象基类相当于万物的鼻祖了。
*/

//抽象类
class ISplitter
{
public:
    virtual void split() = 0;
    virtual ~ISplitter() {}
};

//工厂基类
class SplitterFactory
{
public:
    virtual ISplitter* CreateSplitter() = 0;
    virtual ~SplitterFactory() {}
};

//具体类
class BinarySplitter : public ISplitter
{
public:
    void split() {

    }
};

class TxtSplitter : public ISplitter
{
};

class PictureSplitter : public ISplitter
{
};

class VideoSplitter : public ISplitter
{
};

//具体工厂
class BinarySplitterFactory : public SplitterFactory
{
public:
    virtual ISplitter* CreateSplitter()
    {
        return new BinarySplitter();
    }
};

class TxtSplitterFactory : public SplitterFactory
{
public:
    virtual ISplitter* CreateSplitter()
    {
        return new TxtSplitter();
    }
};

class PictureSplitterFactory : public SplitterFactory
{
public:
    virtual ISplitter* CreateSplitter()
    {
        return new PictureSplitter();
    }
};

class VideoSplitterFactory : public SplitterFactory
{
public:
    virtual ISplitter* CreateSplitter()
    {
        return new VideoSplitter();
    }
};



class MainForm : public Form
{
    SplitterFactory* factory; //工厂

public:
    MainForm(SplitterFactory* factory)
    {
        this->factory = factory;
    }

    void Button1_Click()
    {
        ISplitter* splitter = factory->CreateSplitter(); //多态new

        splitter->split();
    }
};