C++实现观察者模式

最新推荐文章于 2024-06-24 10:59:34 发布
最新推荐文章于 2024-06-24 10:59:34 发布
阅读量256 收藏 1
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rookie_yao/article/details/111822873
版权

所谓观察者模式，个人理解就是一对多的对象之间的关系，多个对象就是观察者，下面写一个项目中用到的类似于观察者模式。
1.写一个抽象的事件基类，暴露的函数写成虚函数，在继承该事件类中的子类中实现这些虚函数

#ifndef IEVENT_H
#define IEVENT_H
#include <QString>

class IEvent
{
public:
    virtual ~IEvent(){}
    virtual bool setCommand(QString cmd) = 0; //判断cmd 是否为 本对象的 执行命令

    // 返回 命令是否 成功执行
    //result  标记执行结果是否正确
    // discription 输出结果描述
    virtual bool exeCommand(bool &reslt, QString &discription) = 0;
};

#endif // IEVENT_H

2.继承抽象事件基类的观察者1：点击事件

#ifndef CLICKEVENT_H
#define CLICKEVENT_H
#include "IEvent.h"

class ClickEvent : public IEvent
{
private:
    const QString EVENT_NAME = "点击";
    QString command;

public:
    ClickEvent();
    //这两个函数必须是和继承的父类的暴露的虚函数同名同参数
    bool setCommand(QString cmd);
    bool exeCommand(bool &reslt, QString &discription);
};

#endif // CLICKEVENT_H

bool ClickEvent::setCommand(QString cmd)
{
    // cmd   格式为：“点击 CE”

    if(cmd.isEmpty())
        return false;

    QStringList list = cmd.split(QRegExp("\\s+"));
    if(list.size() == 2 && list.at(0) == EVENT_NAME)
    {
        this->command = cmd;
        return true;
    }
    else
    {
        return false;
    }

}

bool ClickEvent::exeCommand(bool &reslt, QString &discription)
{
    //需求 执行 点击 事件， 并将执行结果返回
    QStringList list = command.split(QRegExp("\\s+"));
    QString btnName = list.at(1);
    PIX pix;
    BaseInfo *bp = BaseInfo::GetInstance();
    if(bp->getButtonPix(btnName, pix))
    {
        int sx,sy; //  分辨率
        if(bp->getResolution(sx,sy))
        {
            mouse_event(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, pix.x * 65535 / sx, pix.y * 65535 / sy,0,0);
            mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
            Sleep(100);
            mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
            
            return true;
        }
        else
        {
            discription = "配置文件中，未找到屏幕分辨率信息";
            return false;
        }
    }
    else
    {
        discription = "   配置文件中，未找到 此按钮的 位置信息";
        return false;
    }
}

3.继承抽象事件基类的观察者2：判断事件

#ifndef JUDGEEVENT_H
#define JUDGEEVENT_H
#include "IEvent.h"

class JudgeEvent : public IEvent
{
private:
    const QString EVENT_NAME = "期望";
    QString command;
public:
    JudgeEvent();
    //这两个函数必须是和继承的父类的暴露的虚函数同名同参数
    bool setCommand(QString cmd);
    bool exeCommand(bool &reslt, QString &discription);
};

#endif // JUDGEEVENT_H

bool JudgeEvent::setCommand(QString cmd)
{
    // cmd   格式为：“期望 显示框 值 等于 1005.6”

    if(cmd.isEmpty())
        return false;

    QStringList list = cmd.split(QRegExp("\\s+"));
    if(list.size() == 5 && list.at(0) == EVENT_NAME)
    {
        this->command = cmd;
        return true;
    }
    else
    {
        return false;
    }
}

bool JudgeEvent::exeCommand(bool &reslt, QString &discription)
{
    //需求 执行 点击 事件， 并将执行结果返回
    QStringList list = command.split(QRegExp("\\s+"));
    QString btnName = list.at(BTN_NAME);
    double expectValue = list.at(EXPECT_VALUE).toDouble();
    AREA area;
    QString filePath = "C:\\Users\\cf\\Desktop\\Qt5screen.jpg";
    QString disc;
    double value;
    BaseInfo *bp = BaseInfo::GetInstance();
    cvIdentify* cv = cvIdentify::GetInstance();
    if(bp->getShowArea(btnName, area))
    {
        //截屏
        if(cv->getScreenshotPath(area,filePath,disc))
        {//数字识别
            if(cv->getNumberIdentify(filePath, value))
            {
                if (value == expectValue)
                {
                    qDebug() << "expect = "<< (QString::number(value, 10, 5));
                    discription = "执行结果与用例期望值一致的";
                    reslt = true;
                    return true;
                    
                }
                else
                {
                    qDebug() << "unexpect = " << (QString::number(value, 10, 5));
                    discription = "执行结果与用例期望值不一致的";
                    reslt = false;
                    return true;
                }

            }
            else
            {
                discription = "识别失败";
                return false;
            }
        }
        else
        {
            discription = "截取数字失败";
            return false;
        }

        //discription = "";
        //return true;
    }
    else
    {
        discription = "配置文件中，未找到此显示框的位置信息";
        return false;
    }
}

4.写一个将两个观察者类绑定到执行器类中

#ifndef EXECUTOR_H
#define EXECUTOR_H
#include <QList>
#include <QString>
#include "IEvent.h"

class Executor
{
private:
    QList<IEvent* > IEvents;

public:
    Executor();
    void attach(IEvent* ievent);
    void detach(IEvent* ievent);
    bool exeCmd(QString cmd, bool &rel, QString &des);
};

#endif // EXECUTOR_H

#include "executor.h"
#include <Windows.h>
Executor::Executor()
{

}

void Executor::attach(IEvent *ievent)
{
    IEvents.push_back(ievent);
}

void Executor::detach(IEvent *ievent)
{
    IEvents.removeOne(ievent);
}

// 返回 命令是否 成功执行
// cmd 要执行的 命令
// rel  标记执行结果是否正确
// dis 输出结果描述
bool Executor::exeCmd(QString cmd, bool &rel, QString &des)
{
    foreach(auto event , IEvents)
    {
        if(event->setCommand(cmd))
        {
            Sleep(500);
            return event->exeCommand(rel,des);
        }
    }

    // 没有找到对应 事件
   //des = " 未能找到 此命令的执行程序";
    return false;
}

5.程序运行时线程中的执行函数，实现了观察者模式

void executorThread::test(const QStringList& fileName, const QVector<QStandardItem*> m_box)
{
    //qDebug() << QString("my object thread id:") << QThread::currentThreadId();
	//注册执行器的事件对象
	if (!m_box.isEmpty())
	{//这里将两个观察者绑定到执行类，根据程序运行时观察者的不同，执行不同的操作
		Executor* exep = new Executor();
		exep->attach(new ClickEvent());
		exep->attach(new JudgeEvent());
        int executCount = 0;
        int passCount = 0;
        
		for (int i = 0; i < fileName.size(); ++i)
		{   
            QList<QPair<int, QString> > stepList;
            if (importCmdFromDat(fileName.at(i), stepList))
            {
                emit sig_showExample(stepList);

                if (m_box.at(i)->checkState())
                {
                    
                    bool eveOk; // 事件是否 正常执行
                    bool resOk = true; // 结果是否 正确
                    QString exeDis; // 结果的具体描述
                    foreach(auto step, stepList)
                    {   
                        QMutexLocker locker(&m_lock);

                        if (isStop)
                        {
                            return;
                        }
                        resOk = true;
                        exeDis.clear();
                        eveOk = exep->exeCmd(step.second, resOk, exeDis);
                        emit sig_showResult(stepList,step, eveOk,exeDis);
                        // 对执行结果 处理， 打印，   保存
                        // todo
                    }
                    executCount++;
                    if (resOk)
                    {
                        passCount++;
                    }
                    emit sig_identifyResult(passCount,executCount,i,resOk);
                    //isStop = true;
                }
            }
		}
	}
}
Rookie_yao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
观察者模式（C++实现）
今日的积累只为来日的爆发！
05-07 485
观察者模式：定义了一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象,在它的状态发生变化时,会通知所有的观察者. 优点： ①观察者和被观察者是抽象耦合的。 ②建立一套触发机制。 缺点： ①如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 ②如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 ③观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。 .
C++ 观察者模式
CodeHouse的博客
11-10 417
#include <iostream> #include <list> using namespace std; //观察者抽象类 class Observer { public: Observer(){;} virtual void doSometing(void* parg)=0; }; class User1:public Observer { public: virtual void doSometing(void* parg) { cout<<
C++观察者模式
最新发布
xy18990的博客
06-24 515
观察者（Observer）模式 定义如下：是一种对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
C++实现观察者(Observer)模式
weixin_30955617的博客
04-24 124
观察者(Observer)模式，是常见的模式之一。比如一份报纸，有很多订户。订阅者并不知道报纸何时会送来，他只知道自己订了这份报纸。订阅者在这里担任着观察者的角色，而报社则是被观察者。 报纸一旦印刷完毕，就应该及时送到订户手中，如果将报社看作一个对象，则报纸便是观察者（订户）和被观察者（报社）之间的纽带。观察者需要维护一个与报纸相关的变量或函数，在这个具体问题中，这个变量就是订户...
C++ | 观察者模式
ThinPikachu的博客
03-21 684
目录 一.观察者模式 二.代码实现 一.观察者模式 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决：...
用C++ 实现设计模式之观察者模式
12-22
在C++中实现观察者模式，通常包括以下几个关键组件： 1. **主题（Subject）**：主题是被观察的对象，它可以是任何具有可变状态的类。在这个例子中，`Subject`被抽象为`Blog`类，它维护了一个观察者列表`m_observers...
C++ 实现观察者模式小例子
09-02
在这个"C++ 实现观察者模式小例子"中，我们看到它被应用到了显示器和报警器这两个组件上，它们根据泵的温度和压力来展示信息或触发警报。 首先，我们需要理解观察者模式的基本结构。在这个模式中，有三个主要角色：...
c++观察者模式距离说明
08-24
在 C++ 中，观察者模式可以通过使用继承和多态来实现。下面是一个简单的示例代码： ```cpp class Subject { private: set*> observers; public: void attach(Observer* observer) { observers.insert(observer);...
观察者模式及c++实现
12-22
观察者模式概念：定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，全部依赖于它的对象都得到通知并自己主动更新。“Define a one-to-many dependency between objects so that when one object ...
【C++】—— 观察者模式
m0_56069910的博客
03-12 843
观察者模式详解
[C++]观察者模式
就是那个党伟
04-12 287
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 C++代码如下： // 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // // 参考大话设计模式 #include <iostream> #include <vector> using...
【C++实现】观察者模式
jhao的博客
10-03 1175
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。
c++-观察者模式的实现
qq_34179431的博客
07-08 120
#include <iostream> #include <unordered_set> #include <memory> using namespace std; class Observer; class Subject; class Subject { private: unordered_set<shared_ptr<Observer>> obs; protected: char buff[1024]{}; p
c++实现观察者模式
08-25
这样，就完成了C++实现观察者模式的步骤。通过创建具体的观察者对象并将其添加到主题对象中，当主题状态发生变化时，观察者对象会相应地进行更新。<span class="em">1</span><span class="em">2</span><span class=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值