设计模式（三）

2023-10-12

字数统计: 931字 | 阅读时长≈ 4分

对象创建，绕开new来避免对象创建。

工厂模式

定义：定义一个创建对象的接口，让子类决定实例化哪一个类，工厂将这个类的实例化延迟。

/*
假设我们需要对二进制文件进行分割
可以创建一个BinarySplitter类，它有一个分割方法
*/

class BinarySplitter 
{
public:
    void Split()
    {
        //...
    }
};

/*
但现在需要增加一些功能
还需要对文本文件、图片文件等进行分割，需要额外声明类
*/

class TextSplitter
{
public:
    void Split()
    {
        //...
    }
};

class ImageSplitter
{
public:
    void Split()
    {
        //...
    }
};

/*
对于这种情况，我们可以提取一个抽象基类
让子类继承并重写Split方法
但使用时依然会在窗口类种添加new，仍是依赖具体类造成紧耦合
所以我们定义一个工厂来帮我们做new这件事
*/

class ISplitter
{
public:
    virtual void Split() = 0;
};

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

class MainWindow
{
    SplitterFactory* Factory;
public:
    MainWindow(SplitterFactory* Factory)
    {
        this->Factory=Factory;
    }

    void ButtonClick()
    {
        ISplitter* Splitter=Factory->CreateSplitter(); //此时Splitter的具体实现便交给未来（Factory）来决定
        Splitter->Split();
    }
   
};

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

//...

抽象工厂

同样是为了绕开new创建对象，区别在于一系列相互依赖的对象的创建。

/*
假设现在需要对数据库进行访问
需要创建一个类包含连接、命令等
因为使用的数据库可能有所不同，所以可以抽象出一个基类来使用
*/

//抽象基类同时定义相应的工厂
class IDateBaseConnection
{

};

class IDateBaseConnectinFactory
{
public:
    virtual IDateBaseConnection* CreateConnection() = 0;
};

class IDateBaseCommand
{

};

class IDateBaseCommandFactory
{
public:
    virtual IDateBaseCommand* CreateCommand() = 0;
};

class IDateBaseReader
{

};

class IDateBaseReaderFactory
{
public:
    virtual IDateBaseReader* CreateReader() = 0;
};

//支持Sql的类
class SqlConnect:public IDateBaseConnection
{

};

class SqlCommand:public IDateBaseCommand
{

};

//...

//我们使用工厂模式发现子类膨胀很严重，而且并不灵活
//所以我们考虑将同一系列类放在一个抽象工厂中

class IDateBaseFactory
{
public:
    virtual IDateBaseConnection* CreateConnection() = 0;
    virtual IDateBaseCommand* CreateCommand() = 0;
    virtual IDateBaseReader* CreateReader() = 0;
};

class SqlFactory:public IDateBaseFactory
{
    IDateBaseFactory* Factory;
public:

};

//与工厂模式相比，它一次生产一族的对象，减少了子类的膨胀，同时减少了工厂类的数量
//其核心在于应对一系列对象的创建

原型模式

同样是用来避免new创建对象，使用原型实例来指定创建对象的实例，然后通过拷贝这些原型创建新的对象。

/*
还是对于上述案例，我们将工厂与原型合二为一
*/

class ISplitter
{
public:
    virtual void Split() = 0;

    virtual ISplitter* Clone() = 0; //通过克隆来创建自己

    virtual ~ISplitter() {}
}；

//对于具体的类
class BinarySplitter:public ISplitter
{
    public:
    virtual ISplitter* Clone()
    {
        return new BinarySplitter(*this);
    }
};

//...

//对于MainWindow

class MainWindow
{
    ISplitter* Prototype;
public:
    MainWindow(ISplitter* Prototype)
    {
        this->Prototype = Prototype;
    }

    void Click()
    {
        ISplitter* Splitter = Prototype->Clone();  //通过克隆得到新对象
    }
};

构建器模式

构建器模式就是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

/*
现在要构建一个房子，流程如下
*/

class House
{
public:
    //不能放在狗仔函数的原因：子类还没有构造完成，父类不能调用子类的实现
    void Init()
    {
        this->BuildPart1();

        this->BuildPart2();

        if(this->BuildPart3()){
            this->BuildPart4();
        }
    }

    virtual ~House() {}

    virtual void BuildPart1() = 0;
    virtual void BuildPart2() = 0;
    virtual bool BuildPart3() = 0;
    virtual void BuildPart4() = 0;
};

class StoneHouse:public House
{
public:
    virtual void BuildPart1()
    {
        
    }

    virtual void BuildPart2()
    {
        
    }

    virtual bool BuildPart3()
    {      
        return true;
    }

    virtual void BuildPart4()
    {

    }
};

//...

//可以将Init单独抽出来，当Init变得更复杂时可以选择抽出

本文作者： KongXinQing
本文链接： https://13114987559.github.io/2023/10/12/note/设计模式3/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！