设计模式汇总

最新推荐文章于 2024-10-16 17:27:55 发布

傲娇小二哈

最新推荐文章于 2024-10-16 17:27:55 发布

阅读量166

点赞数

文章标签：设计模式策略模式

本文链接：https://blog.csdn.net/weixin_39668905/article/details/126294287

版权

单例模式

工厂模式

模板方法

定义：定义一个操作中的算法的骨架稳定，而将一些步骤延迟变化到子类中去。模板方法使得子类可以不改变一个算法的结构即可重定义（override重写）该算法的某些特定步骤
使用举例：
在C++高性能服务器搭建中，在io调度部分，使用了模板方法，比如先实现一个调度器，在run函数中，首先实现start创建线程，然后在idle中向列表中添加事件，然后run中将链表的事件一一执行，同时如果该线程有不能处理的事件可以通过tickle通知别的线程处理。

#include <iostream>
using namespace std;
class  Scheduler{
public:
	virtual ~Scheduler(){};
    void run(){
        start();
        idle();
        tickle();
    }
protected:
    virtual void start()=0;
    virtual void idle()=0;
    virtual void tickle()=0;
    
};
class Epoll :public Scheduler{
protected:
    virtual void start() override{
        cout<<"epoll start"<<endl;
    }
    virtual void idle() override{
        cout<<"epoll idle"<<endl;
    }
    virtual void tickle() override{
        cout<<"epoll tickle"<<endl;
    }
};

class Select :public Scheduler{
protected:
    virtual void start() override{
        cout<<"select start"<<endl;
    }
    virtual void idle() override{
        cout<<"select idle"<<endl;
    }
    virtual void tickle() override{
        cout<<"select tickle"<<endl;
    }
};
int main()
{
    Scheduler* ep=new Epoll;
    Scheduler* se=new Select;
    ep->run();
    se->run();
    delete ep;
    delete se;
}

策略模式

定义：定义一系列算法，把他们一个个的封装起来，并且使他们可以互相替换。即通过不同的方法达到同样的目的。
策略模式及其子类为组件提供了一系列可重用的算法，从而可以使得类型在运行时方便的根据需要在各个算法之间切换。

class Log_Print{
public:
    virtual void Print()=0;
    virtual ~Log_Print(){}
};
class Std_Print : public Log_Print{
public:
    virtual void Print() override{
        cout<<"print to std"<<endl;
    }
};

class File_Print : public Log_Print{
public:
    virtual void Print() override{
        cout<<"print to file"<<endl;
    }
};

class Log_out{
public:
    Log_out(Log_Print *p){
        m_print=p;
    }
    void Logout(){
        m_print->Print();
    }
private:
    Log_Print *m_print;
};
void test_Strategy(){
    Log_Print* st=new Std_Print;
    Log_Print* fi=new File_Print;
    Log_out *st_log=new Log_out(st);
    Log_out *fi_log=new Log_out(fi);
    st_log->Logout();
    fi_log->Logout();
    delete st;
    delete fi;
    delete st_log;
    delete fi_log;
}
int main()
{
    test_Strategy();
}

观察者模式

定义：定义对象间的一种一对多（变化）的依赖关系，以便当一个对象的状态发生改变时，所有依赖他的对象都得到通知并自动更新。

class Observer { // 抽象观察者，为所有具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫更新接口
public:
    virtual void Update() = 0;
};

class Subject { // 主题或抽象通知者，一般用一个抽象类或者接口实现
private:
    list<Observer* > observers;
public:
    void Attach(Observer* observer) { observers.push_back(observer); } // 增加观察者
    void Detach(Observer* observer) { observers.remove(observer); } // 移除观察者
    void Notify() { // 通知
        for (auto observer = observers.begin(); observer != observers.end(); observer++) {
            (*observer)->Update();
        }
    }
};

class ConcreteSubject : public Subject { // 具体主题或具体通知者，将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发送通知
private:
    string subjectState;
public:
    string GetState() { return subjectState; }
    void SetState(string state) { subjectState = state; }
};

class ConcreteObserver : public Observer { // 具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态相协调
private:
    string name;
    ConcreteSubject* subject;
    string observerState;
public:
    ConcreteObserver(ConcreteSubject* s, string n) {
        subject = s;
        name = n;
    }
    void Update() {
        observerState = subject->GetState();
        cout << "observer: " << name << ", its new state is: " << observerState << endl;
    }
    string GetState() { return observerState; }
    void SetState(string state) { observerState = state; }
};
void test_Observer(){
    ConcreteSubject* s = new ConcreteSubject();
       s->SetState("ABC");
       ConcreteObserver* ox = new ConcreteObserver(s, "X");
       ConcreteObserver* oy = new ConcreteObserver(s, "Y");
       ConcreteObserver* oz = new ConcreteObserver(s, "Z");
       s->Attach(ox);
       s->Attach(oy);
       s->Attach(oz);
       s->Notify();
       // observer: X, its new state is: ABC
       // observer: Y, its new state is: ABC
       // observer: Z, its new state is: ABC
       s->SetState("XYZ");
       s->Notify();
       // observer: X, its new state is: XYZ
       // observer: Y, its new state is: XYZ
       // observer: Z, its new state is: XYZ
       delete ox;
       delete oy;
       delete oz;
       delete s;
}

装饰者模式

定义：动态组合的给一个对象增加一些额外的职责。就增加功能而言，装饰者模式比生成子类(继承)而言，更灵活(消除重复代码与子类个数)
应用场景：stream有多种类型，有文件流，网络流，且各自有各自的read、write、seek，此时需要对这些流进行加密、buffer等操作，常规思路是再对各个流写不同的加密文件流、加密网络流、缓存文件流、缓存网络流等操作的类，这样会产生大量重复的代码和写大量的类。但其实对于加密或者缓存，只有其本身的read，write，seek等是不同的，剩下的加密、缓存操作完全一致，所以就写一个装饰者模式，装饰器中有一个sream（可以在运行时变成各种stream），然后统一进行加密、缓存等操作。

class Stream{
public:
    virtual ~Stream(){}
    virtual void read()=0;
    virtual void write()=0;
    virtual void seek()=0;
};

class FileStream:public Stream{
public:
    void read(){
        cout<<"filestream read"<<endl;
    }
    void write(){
        cout<<"filestream write"<<endl;
    }
    void seek(){
        cout<<"filestream seek"<<endl;
    }
};

class NetworkStream:public Stream{
public:
    void read(){
        cout<<"NetworkStream read"<<endl;
    }
    void write(){
        cout<<"NetworkStream write"<<endl;
    }
    void seek(){
        cout<<"NetworkStream seek"<<endl;
    }
};
class DecoratorStream:public Stream{
protected:
    Stream *m_stream;
public:
    DecoratorStream(Stream *stream):m_stream(stream){}
};

class CryptoStream:public DecoratorStream{
public:
    CryptoStream(Stream *stream):DecoratorStream(stream){}
    virtual void read(){
        m_stream->read();
        cout<<"CryptoStream other read"<<endl;
    }
    virtual void write(){
        m_stream->write();
        cout<<"CryptoStream other write"<<endl;
    }
    virtual void seek(){
        m_stream->seek();
        cout<<"CryptoStream other seek"<<endl;
    }
};

class BuffertoStream:public DecoratorStream{
public:
    BuffertoStream(Stream *stream):DecoratorStream(stream){}
    virtual void read(){
        m_stream->read();
        cout<<"BuffertoStream other read"<<endl;
    }
    virtual void write(){
        m_stream->write();
        cout<<"BuffertoStream other write"<<endl;
    }
    virtual void seek(){
        m_stream->seek();
        cout<<"BuffertoStream other seek"<<endl;
    }
};
void test_decorator(){
    Stream *fi=new FileStream;
    DecoratorStream* cd=new CryptoStream(fi);
    DecoratorStream* bd=new BuffertoStream(fi);
    cd->read();
    bd->seek();
}

桥接模式

定义：桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。
这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。
应用场景：

//颜色抽象类
class Color
{
public:
    virtual string GetColor()=0;//获取颜色，用于验证
};

//颜色实现类
class Red:public Color
{
public:
    virtual string GetColor()//获取颜色，用于验证
    {
        return "Red";
    }
};

class Blue:public Color
{
public:
    virtual string GetColor()//获取颜色，用于验证
    {
        return "Blue";
    }
};

class Green:public Color
{
public:
    virtual string GetColor()//获取颜色，用于验证
    {
        return "Green";
    }
};

//形状抽象类
class Shape
{
public:
    Shape(Color* pColor):m_pColor(pColor){}
    virtual void Show()=0;//展示接口，验证实现类中颜色与形状
protected:
    Color* m_pColor;//将图形的颜色抽象，与形状类桥接
};

//形状实现类
class Circle:public Shape
{
public:
    Circle(Color* pColor):Shape(pColor){}//构造圆形时指定颜色
    void Show()//重写展示接口，用于验证
    {
        cout << m_pColor->GetColor() << "Circle" << endl;
    }
};

class Rectangle:public Shape
{
public:
    Rectangle(Color* pColor):Shape(pColor){}//构造矩形时指定颜色
    void Show()//重写展示接口，用于验证
    {
        cout << m_pColor->GetColor() << "Rectangle" << endl;
    }
};

class Triangle:public Shape
{
public:
    Triangle(Color* pColor):Shape(pColor){}//构造三角形时指定颜色
    void Show()//重写展示接口，用于验证
    {
        cout << m_pColor->GetColor() << "Triangle" << endl;
    }
};
void test_bridge(){
    Shape* pBlueCircle = new Circle(new Blue());
    pBlueCircle->Show();
}