创建型设计模式

最新推荐文章于 2024-11-09 23:29:17 发布

花开花落为谁愁

最新推荐文章于 2024-11-09 23:29:17 发布

阅读量138

点赞数

分类专栏： gyw服务器架构文章标签：设计模式

本文链接：https://blog.csdn.net/Ge_yangwen/article/details/127933788

版权

gyw服务器架构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

设计模式

设计模式是指在软件开发中，经过验证的，用于解决在特定环境下，重复出现的，特定问题的解决
方案；
主要涉及到的思想：抽象思维和分治思维。
方法：

1.找稳定点和变化点，把变化点隔离出来
2.先满足设计原则，慢慢迭代出设计模式。
如：整洁的房间和好动的猫，如何保证房间的整洁？（把猫关笼子里）

类模型

类扩展的模型

类关系

在这里插入图片描述

友元是单向的，友元类可以访问该类的全部属性，
儿子类只能访问父类的公有和保护的属性

设计原则

依赖倒置

高层模块不应该依赖低层模块，两者都应该依赖抽象；
抽象不应该依赖具体实现，具体实现应该依赖于抽象；

在这里插入图片描述

自动驾驶系统公司是高层，汽车生产厂商为低层，它们不应该互相依赖，一方变动另一方也会跟着
变动；而应该抽象一个自动驾驶行业标准，高层和低层都依赖它；这样以来就解耦了两方的变动；
自动驾驶系统、汽车生产厂商都是具体实现，它们应该都依赖自动驾驶行业标准（抽象）；

开放封闭

一个类应该对扩展（组合和继承）开放，对修改关闭；C++中的类继承

面向接口

不将变量类型声明为某个特定的具体类，而是声明为某个接口；
客户程序无需获知对象的具体类型，只需要知道对象所具有的接口；
减少系统中各部分的依赖关系，从而实现“高内聚、松耦合”的类型设计方案；

封装变化点

将稳定点和变化点分离，扩展修改变化点；让稳定点和变化点的实现层次分离；

单一职责

一个类应该仅有一个引起它变化的原因；

里氏替换

子类型必须能够替换掉它的父类型；主要出现在子类覆盖父类实现，原来使用父类型的程序可能出
现错误；覆盖了父类方法却没有实现父类方法的职责；

接口隔离

不应该强迫客户依赖于它们不用的方法；
一般用于处理一个类拥有比较多的接口，而这些接口涉及到很多职责；

组合优于继承

继承耦合度高，组合耦合度低；

模板方法

定义

定义一个操作中的算法的骨架 ，而将一些步骤延迟到子类中。 Template Method使得子类可以不
改变一个算法的结构即可重定义该算法的某些特定步骤。 ——《设计模式》 GoF

背景

某个品牌动物园，有一套固定的表演流程，但是其中有若干个表演子流程可创新替换，以尝试迭代
更新表演流程；

要点

最常用的设计模式，子类可以复写父类子流程，使父类的骨架流程丰富；
反向控制流程的典型应用；
父类 protected 保护子类需要复写的子流程；这样子类的子流程只能父类来调用；

本质

通过固定算法骨架来约束子类的行为；

结构图

在这里插入图片描述

观察者模式

以下大部分引用CSDN博主「herryone123」的C++行为型模式-实现观察者模式

动机

建立一个对象与对象之间的依赖关系，一个对象发生改变时，将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，被通知的对象称为观察者，一个观察目标可以对应多个观察者，观察者之间没有相互联系。

定义

定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所
有依赖于它的对象都得到通知并自动更新。 ——《设计模式》 GoF
当一个对象发生了变化，关注它的对象就会得到通知；这种交互也称为发布-订阅(publish-subscribe)。
观察者模式又叫发布-订阅模式、模型-视图模式。

背景

（我们学习设计模式知道怎么去扩展他就好了）
气象站发布气象资料给数据中心，数据中心经过处理，将气象信息更新到两个不同的显示终端（A
和B）；

要点

观察者模式使得我们可以独立地改变目标与观察者，从而使二者之间的关系松耦合；
观察者自己决定是否订阅通知，目标对象并不关注谁订阅了；
观察者不要依赖通知顺序，目标对象也不知道通知顺序；
常用在基于事件的ui框架中，也是 MVC 的组成部分；
常用在分布式系统中、actor框架中；

涉及到的锁：公平锁（订阅发布），非公平锁（自旋锁）
1.lock(mutex);
2.临界资源
3.队列操作时间非常短（自旋锁），重IO操作（用互斥锁）
4.unlock(mutex);

本质

触发联动

结构图

在这里插入图片描述
（1）抽象目标（Subject）角色：抽象目标角色提供维护一个观察者对象集合的操作方法，对集合的增加、删除等。
（2）具体目标（ConcreteSubject）角色：将有关状态存入具体的观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发通知。具体主题角色负责实现抽象主题中的方法。
（3）抽象观察者（Observer）角色：为具体观察者提供一个更新接口。该接口声明了更新数据的方法。
（4）具体观察者（ConcreteObserver）角色：存储具体观察者的有关状态，这些状态需要和具体目标的状态一致，实现抽象观察者提供的更新接口。

优缺点

优点：
（1）可以实现表示层与数据逻辑层的分离；
（2）观察者模式支持广播通信，观察目标会向所有的注册的观察者发出通知，简化了一对多系统的设计难度；
（3）符合“开闭原则”，增加新的具体观察者无须修改原有的系统代码。

缺点：
如果一个观察目标对象有很多直接或间接的观察者，将所有的观察者都通知会花费很多时间。

c++实现观察者基本用法

#include <iostream>
#include <list>
using namespace std;
 
/*抽象观察者*/
class Observer{
public:
    virtual void Update(int) = 0;
};
 
/*抽象目标*/
class Subject{
public:
    virtual void Attach(Observer *) = 0;  //附加观察者
    virtual void Detach(Observer *) = 0; //移除观察者
    virtual void Notify() = 0; //通知观察者
};
 
/*具体观察者*/
class ConcreteObserver : public Observer{
public:
    ConcreteObserver(Subject *pSubject) : m_pSubject(pSubject){}
 
    void Update(int value){
        cout << "ConcreteObserver get the update. New State:" << value << endl;
    }
 
private:
    Subject *m_pSubject;
};
 /*具体观察者2*/
class ConcreteObserver2 : public Observer
{
public:
    ConcreteObserver2(Subject *pSubject) : m_pSubject(pSubject){}
 
    void Update(int value){
        cout << "ConcreteObserver2 get the update. New State:" << value << endl;
    }
 
private:
    Subject *m_pSubject;
};
 
/*具体目标*/
class ConcreteSubject : public Subject
{
public:
    void Attach(Observer *pObserver);
    void Detach(Observer *pObserver);
    void Notify();
 
    void SetState(int state){
        m_iState = state;
    }
 
private:
    std::list<Observer *> m_ObserverList;//观察者列表
    int m_iState;
};
 
//附加观察者
void ConcreteSubject::Attach(Observer *pObserver){
    m_ObserverList.push_back(pObserver);
}
 
//移除观察者
void ConcreteSubject::Detach(Observer *pObserver){
    m_ObserverList.remove(pObserver);
}
 
//通知观察者
void ConcreteSubject::Notify(){
    std::list<Observer *>::iterator it = m_ObserverList.begin();
    while (it != m_ObserverList.end())    {
        (*it)->Update(m_iState);
        ++it;
    }
}
 
int main(){
    // Create Subject  目标实例化
    ConcreteSubject *pSubject = new ConcreteSubject();
 
    // Create Observer  创建观察者
    Observer *pObserver = new ConcreteObserver(pSubject);
    Observer *pObserver2 = new ConcreteObserver2(pSubject);
 
    // Change the state 
    pSubject->SetState(2);
 
    // Register the observer
    pSubject->Attach(pObserver);
    pSubject->Attach(pObserver2);
 
    pSubject->Notify();
 
    // Unregister the observer
    pSubject->Detach(pObserver);
 
    pSubject->SetState(3);
    pSubject->Notify();
 
    delete pObserver;
    delete pObserver2;
    delete pSubject;
}

该观察者模式是经典模式，但是存在缺陷：
（1）需要继承，继承是强对象关系，只能对特定的观察者才有效，即必须是Observer抽象类的派生类才行；
（2）观察者被通知的接口参数不支持变化，导致观察者不能应付接口的变化，并且这个观察者还不能带参数；

C++11改进的观察者模式

为了解决上例观察者模式的缺陷，可使用C++11 做出改进，

（1）通过被通知接口参数化和std::function 来代替继承；

（2）通过可变参数模板和完美转发来消除接口变化产生的影响。

C++11 实现的观察者模式，内部维护了一个泛型函数列表，观察者只需要将观察者函数注册进来即可，消除了继承导致的强耦合。通知接口使用了可变参数模板，支持任意参数，消除了接口变化的影响。

改进之后的观察者模式和C# 中的event类似，通过定义委托类型来限定观察者，不要求观察者必须某个类派生，当需要和原来不同的观察者时，只需要定义一个新的event类型即可，通过event还可方便地增加或移除观察者。

需要控制event 类不可复制，C++11 提供了Default 和 Delete 函数，使我们可以更方便地实现一个NonCopyable，如果希望一个类不被复制，则直接从这个NonCopyable 派生即可。

C++11中，当类中含有不能默认初始化的成员变量时，可以禁止默认构造函数的生成，
myClass()=delete;//表示删除默认构造函数
myClass()=default;//表示默认存在构造函数

当类中含有不能默认拷贝成员变量时，可以禁止默认构造函数的生成，
myClass(const myClass&)=delete;//表示删除默认拷贝构造函数，即不能进行默认拷贝
myClass & operatir=(const myClass&)=delete;//表示删除默认拷贝构造函数，即不能进行默认拷贝

使用delete操作符屏蔽 拷贝构造函数 和 赋值操作符，使Events对象不能拷贝和赋值
使用std::map保存观察者事件列表
使用自增成员变量保存观察者事件key
使用可变模板参数屏蔽函数参数变动

举例：
noncopyable.hpp

#ifndef _NONCOPYABLE_HPP_
#define _NONCOPYABLE_HPP_
 
class NonCopyable {
    public:
        //禁用复制构造函数
        NonCopyable(const NonCopyable& n) = delete; // deleted
        //禁用赋值构造函数
        NonCopyable& operator=(const NonCopyable& n) = delete; // deleted
        NonCopyable() = default; // available
};
#endif

observer.hpp

#ifndef _OBSERVER_HPP_
#define _OBSERVER_HPP_
 
#include <iostream>
#include <string>
#include <functional>
#include <map>
 
using std::cout;
using std::endl;
using std::string;
using std::map;
 
#include "noncopyable.hpp"
 
template <typename Func>
class Events: NonCopyable {
    public:
        // 注册观察者，支持右值引用
        int Connect(Func&& f) {
            return Assign(f);
        }
 
        // 注册观察者，左值
        int Connect(const Func& f) {
            return Assign(f);
        }
 
        // 移除观察者
        void Disconnect(int key) {
            m_connections.erase(key);
        }
 
        // 通知所有观察者
        template <typename ... Args>
        void Notify(Args&& ... args) {
            for(auto &it : m_connections) {
                auto& func = it.second;
                func(std::forward<Args>(args)...);
            }
        }
    private:
 
        // 保存观察者并分配观察者编号
        template <typename F>
        int Assign(F&& f) {
            int k = m_observerId++;
            m_connections.emplace(k, std::forward<F>(f));
            return k;
        }
 
        int m_observerId = 0; //观察者对应编号
        map<int, Func> m_connections; // 观察者列表
};
 
#endif

main.cpp

#include "observer.hpp"
 
using ObserverFunc = std::function<int(int, int)>;
 
class Observer {
    public:
        int operator() (int a, int b) {
            cout << "Observer函数对象的事件2被调用" << endl;
            int res = a + b;
            return res;
        }
};
 
class Observer2 {
    public:
        int observerFunc(int a, int b) {
            cout << "Observer2成员函数事件3被调用" << endl;
            int res = a + b;
            return res;
        }
};
 
int gobserverFunc(int a, int b) {
    cout << "全局的gobserverFunc事件4被调用" << endl;
    int res = a + b;
    return res; 
}
 
int main(void) {
    Events<ObserverFunc> e;
    // 调用基于lambda表达式的观察者函数
    int lambdaID = e.Connect([](int a, int b){
        int res = a+b;
        cout << "lambda函数的事件1被调用" << endl;
        return res;
    });
 
    // 调用仿函数的观察者函数
    int obsID = e.Connect(Observer());
    
    // 调用成员函数的观察者函数
    Observer2 o2;
    int obsID1 = e.Connect(std::bind(&Observer2::observerFunc, o2, std::placeholders::_1, std::placeholders::_2));
    
    // 调用全局观察者函数
    int gID4 = e.Connect(gobserverFunc);
 
    e.Notify(1, 2);
 
    return 0;
}

策略模式

定义

定义一系列算法，把它们一个个封装起来，并且使它们可互相替换。该模式使得算法可独立于使用
它的客户程序而变化。 ——《设计模式》 GoF

背景

某商场节假日有固定促销活动，为了加大促销力度，现提升国庆节促销活动规格；

要点

策略模式提供了一系列可重用的算法，从而可以使得类型在运⾏时方便地根据需要在各个算法之间进行切换；
策略模式消除了条件判断语句；也就是在解耦合；

本质

分离算法，选择实现；

结构图

在这里插入图片描述

//
enum VacationEnum {
	VAC_Spring,
    VAC_QiXi,
	VAC_Wuyi,
	VAC_GuoQing,
    VAC_ShengDan,
};
// 稳定点  变化点
// 如果一个 只有稳定点  需不需要设计模式      不需要
// 如果 全是变化点（不需要）  怎么办？   c++  游戏开发  脚本语言
class Promotion {
    VacationEnum vac;
public:
    double CalcPromotion(){
        if (vac == VAC_Spring {
            // 春节
        }
        else if (vac == VAC_QiXi) {
            // 七夕
        }
        else if (vac == VAC_Wuyi) {
            // 五一
        }
		else if (vac == VAC_GuoQing) {
			// 国庆
		}
        else if (vac == VAC_ShengDan) {
        }
     }
};

class Context {
};

class ProStategy {
public:
    virtual double CalcPro(const Context &ctx) = 0;
    virtual ~ProStategy();   //为什么接口当中要将析构函数定义为虚函数  （释放子类资源）
};
// cpp
class VAC_Spring : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_QiXi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_QiXi1  : public VAC_QiXi {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_Wuyi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_GuoQing : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

class VAC_Shengdan : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

class Promotion {
public:
    Promotion(ProStategy *sss) : s(sss){}
    ~Promotion(){}
    double CalcPromotion(const Context &ctx){
        return s->CalcPro(ctx);
    }
private:
    ProStategy *s;
};

int main () {
    Context ctx;
    ProStategy *s = new VAC_QiXi1();
    Promotion *p = new Promotion(s);
    p->CalcPromotion(ctx);
    return 0;
}