C++中建立对象间消息连接的一种系统方法

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量303 收藏 1
点赞数 1
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87255144/article/details/142437873
版权

成员函数RemoveCallback用来删除注册在事件对象上的回调函数。它的三个重载版本依次为：

void CallBack::RemoveCallBack(char *event,CallBackFunction cbf,CallBack *p);
void CallBack::RemoveCallBack(char *event,CallBackStaticFunction cbsf);
void CallBack::RemoveCallBack(char *event);

其中，event,cbf,cbsf,p等参数和成员函数AddCallBack中各参数一样。第一个RemoveCallBack用于删除注册在事件event上某回调对象的一个成员函数。第二个RemoveCallBack用于删除注册在事件event上的某普通函数或某回调类的一个静态成员函数。第三个RemoveCallBack用于删除注册在事件event上的全部回调函数。

二、CallBack类的使用方法

使用CallBack类，可按以下步骤进行：

1．确定程序中哪些对象间存在关系，需要建立消息连接。并确定在各特定消息连接关系中，哪个对象是事件对象，哪个对象是回调对象。

2．事件对象类和回调对象类都必须从CallBack类继承，以获得回调支持。

3．为事件对象注册回调数据。包括：事件名，回调函数名，指向回调对象的指针。

4．当你感兴趣的事件发生时，在事件对象类引发事件的成员函数中调用CallCallBack函数。

下面是一个具体的例子。通过它你会对Callback类的使用方法有进一步的了解。

//测试程序文件：test.cpp 
#include"callback.h"
//“扬声器”类 
class Speaker:public CallBack
{
    private:
        int volume;
    public:
        Speaker(int v): volume(v) {}
               void IncreaseVolume(int v) //增加音量成员函数
        {
            volume += v;
            if(volume > 20){ //“音量大于20”事件发生了
//调用注册在两事件上的回调函数
                CallCallBack("音量改变了");
                CallCallBack("音量大于20", &volume);
            }
        }
        void DecreaseVolume(int v) //降低音量成员函数
        {
            volume -= v;
            if(volume < 5){ //“音量小于5”事件发生了
//调用注册在两事件上的回调函数
CallCallBack("音量改变了");
                CallCallBack("音量小于5", &volume);
            }
        }
};
  //“耳朵”类 
class Ear : public CallBack
{
public: 
      static void Response(CallData callData) //对“音量改变”的反应
      {
          cout<<"音量改变了."<<endl;
      }
      void HighVoiceResponse(CallData callData)//对高音的反应
      {
          cout<<”喂！太吵了！现在音量是："<<*((int *)callData)<<endl;
      }
      void LowVoiceResponse(CallData callData)// 对低音的反应
      {
          cout<<"啊！我听不清了。现在音量是："<<*((int *)callData)<<endl;
      }
};
void main(void) 
{
      Speaker s(10); //现在音量为10
      Ear e;
    //为事件对象s注册回调函数
      s.AddCallBack("音量大于20”,(CallBackFunction)&Ear::HighVoiceResponse,&e);
      s.AddCallBack("音量小于5”,(CallBackFunction)&Ear::LowVoiceResponse,&e);
      s.AddCallBack("音量改变了",(CallBackStaticFunction)&Ear::Response);
   s.IncreaseVolume(12);//将音量增加12，现在音量位22
      s.DecreaseVolume(20);//将音量减少20，现在音量位2
}

运行结果：

音量改变了.

喂！太吵了！现在音量是：22

音量改变了.

啊！我听不清了。现在音量是：2

在上例中，扬声器对象s为事件对象，耳朵对象e为回调对象。。s上被注册了三个事件：“音量改变了”，“音量大于20”，“音量小于5”。 回调函数分别为：Ear::Response， Ear::HighVoiceResponse，Ear::LowVoiceResponse。当扬声器s通过其成员函数IncreaseVolume和 DecreaseVolume改变音量时，回调对象e会自动作出反应。可见，通过使用CallBack类，在对象间建立消息连接已变为一项很简单和优美的工作。

附：完整程序（感兴趣的可以试一下）

//回调类的类结构:callback.h
#ifndef _CALLBACK_H
#define _CALLBACK_H
#include<stdlib.h>
#include<string.h>
#include<iostream.h>
#define CALLBACKLIST_INIT_SIZE 10
#define CALLBACKLIST_INCREMENT 5
class CallBack;
typedef void *CallData;//回调数据指针类型定义
typedef void (CallBack::*CallBackFunction)(CallData); //指向回调成员函数的指针
typedef void (*CallBackStaticFunction)(CallData); //指向静态成员函数或普通函数的指针类型定义
  class EventRecord{ 
    private:
        char *eventName;       //回调事件名称
        CallBack *pointerToCBO;//指向回调对象的指针
        //指向成员函数的指针和指向静态成员函数（或普通函数）指针的共用体
        union{
            CallBackFunction pointerToCBF;
CallBackStaticFunction pointerToCBSF;
        };
      public:
        EventRecord(void); //事件记录类的缺省构造函数
//构造包含成员函数的事件记录
EventRecord(char *ename,CallBack *pCBO,CallBackFunction pCBF);
//构造包含静态成员函数或普通函数的事件记录
EventRecord(char *ename,CallBackStaticFunction pCBSF);
          ~EventRecord(void);//析构事件记录
        void operator = (const EventRecord& er);//重载赋值运算符
        //判断当前事件记录的事件名是否为ename
 int operator == (char *ename) const;
        //判断当前事件记录是否和指定事件记录相等
int operator == (const EventRecord& er) const;
       void Flush(void);       //将当前事件记录清空
        int IsEmpty(void) const;//判断事件记录是否为空（即事件名是否为空）
          friend class CallBack;  //让CallBack类能访问EventRecord的私有成员；
};
  class CallBack { 
    private:
        EventRecord *callBackList; //回调事件表
        int curpos;                //当前事件记录位置
        int lastpos;               //回调表中最后一空闲位置
        int size;                  //回调表的大小
          void MoveFirst(void) { curpos = 0; }//将当前记录置为第一条记录
        void MoveNext(void) //将下一条记录置为当前记录
{
            if(curpos == lastpos) return;
            curpos++;
}
        //判断回调表是否被遍历完   
int EndOfList(void) const { return curpos == lastpos; }
    public:
        CallBack(void);//构造函数
        CallBack(const CallBack& cb);//拷贝构造函数
        ~CallBack(void);//析构函数
        void operator = (const CallBack& cb);// 重载赋值运算符
       //将回调对象的成员函数、静态成员函数（或普通函数）
//注册为事件对象的回调函数
  void AddCallBack(char *event,CallBackFunction cbf,CallBack *p);
        void AddCallBack(char *event,CallBackStaticFunction cbsf);
          //删除注册在指定事件上的回调函数
        void RemoveCallBack(char *event,CallBackFunction cbf,CallBack *p);
        void RemoveCallBack(char *event,CallBackStaticFunction cbsf);
        void RemoveCallBack(char *event);// 删除某事件的全部记录
          //执行注册在某一事件上的所有回调函数
        void CallCallBack(char *event, CallData calldata = NULL);
};
#endif


//回调类的实现:callback.cpp 
#include"callback.h"
//EventRecord类的实现
EventRecord::EventRecord(void)
{
    eventName = NULL;
    pointerToCBO = NULL;
    //因为sizeof(CallBackFunction) > sizeof(CallBackStaticFunction)
    pointerToCBF = NULL;
}
EventRecord::EventRecord(char *ename, CallBack *pCBO, CallBackFunction pCBF)
                 :pointerToCBO(pCBO), pointerToCBF(pCBF)
{
    eventName = strdup(ename);
}
EventRecord::EventRecord(char *ename, CallBackStaticFunction pCBSF)
  :pointerToCBO(NULL), pointerToCBSF(pCBSF)
{
    eventName = strdup(ename);
}
  EventRecord::~EventRecord(void) 
{
    if(eventName) delete eventName;
}
  void EventRecord::operator = (const EventRecord& er) 
{
    if(er.eventName)
        eventName = strdup(er.eventName);
    else
        eventName = NULL;
    pointerToCBO = er.pointerToCBO;
    pointerToCBF = er.pointerToCBF;
}
  int EventRecord::operator == (char *ename) const 
{
    if((eventName == NULL)||ename == NULL)
        return eventName == ename;
    else
        return strcmp(eventName,ename) == 0;
}
int EventRecord::operator == (const EventRecord& er) const
{
    return (er == eventName) /*er和eventname不能交换位置*/
          &&(pointerToCBO == er.pointerToCBO)
          &&(pointerToCBO ?
            (pointerToCBF == er.pointerToCBF):
            (pointerToCBSF == er.pointerToCBSF));
}
void EventRecord::Flush(void) 
{
    if(eventName){
      delete eventName;
      eventName = NULL;
    }
    pointerToCBO = NULL;
    pointerToCBF = NULL;
}
int EventRecord::IsEmpty(void) const
{
    if(eventName == NULL)
        return 1;
    else
        return 0;
}
  //Callback类的实现 
CallBack::CallBack(void)
{
//按初始尺寸为回调表分配内存空间
callBackList = new EventRecord[CALLBACKLIST_INIT_SIZE];
    if(!callBackList){
        cerr<<"CallBack: memory allocation error."<<endl;
        exit(1);
    }
    size = CALLBACKLIST_INIT_SIZE;
    lastpos = 0;
    curpos = 0;
}
  CallBack::CallBack(const CallBack& cb): curpos(cb.curpos),lastpos(cb.lastpos),size(cb.size) 
{
    callBackList = new EventRecord[size];
    if(!callBackList){
        cerr<<"CallBack: memory allocation error."<<endl;
        exit(1);
    }
    //一一复制各条事件记录
for(int i = 0; i < size; i++) callBackList[i] = cb.callBackList[i];
}
  void CallBack::operator = (const CallBack& cb) 
{
    curpos = cb.curpos;
    lastpos = cb.lastpos;
    size = cb.size;
      delete [] callBackList;//删除旧的回调表
    callBackList = new EventRecord[size];//重新分配内存空间
    if(!callBackList){
        cerr<<"CallBack: memory allocation error."<<endl;
        exit(1);
    }
    //一一复制各条事件记录
    for(int i = 0; i < size; i++) callBackList[i] = cb.callBackList[i];
}
  CallBack::~CallBack(void) 
{
    delete [] callBackList;
}
  void CallBack::AddCallBack(char *event, CallBackFunction pCBF, CallBack *pCBO) 
{
    //如事件名为空，退出
    if( (event == NULL)?1:(strlen(event) == 0)) return;
    //寻找因删除事件记录而产生的第一个空闲位置，并填写新事件记录
    for(int start=0;start<lastpos;start++)
        if(callBackList[start].IsEmpty()){
            callBackList[start] = EventRecord(event,pCBO,pCBF);
            break;
}
    if(start < lastpos) return; //确实存在空闲位置
    //没有空闲位置，在回调表后追加新记录
    if(lastpos == size) //回调表已满，需“伸长”
    {
        EventRecord *tempList = callBackList;//暂存旧回调表指针
        //以一定的步长“伸长”回调表
callBackList = new EventRecord[size + CALLBACKLIST_INCREMENT];
        if(!callBackList){
            cerr<<"CallBack: memory allocation error."<<endl;
            exit(1);
        }
        //复制旧回调表中的记录
        for(int i = 0; i < size; i++) callBackList[i] = tempList[i];
        delete [] tempList;//删除旧回调表
        size += CALLBACKLIST_INCREMENT;//记下新回调表的尺寸
    }
   //构造新的事件记录并将其填入回调表中
    callBackList[lastpos] = EventRecord(event,pCBO,pCBF);
    lastpos++;
}
  void CallBack::AddCallBack(char *event,CallBackStaticFunction pCBSF) 
{
    if( (event == NULL)?1:(strlen(event) == 0)) return;
    for(int start=0;start<lastpos;start++)
        if(callBackList[start].IsEmpty()){
            callBackList[start] = EventRecord(event,pCBSF);
            break;
        }
    if(start < lastpos) return; //a hole is found
      if(lastpos == size) //event list is insufficient
    {
        EventRecord *tempList = callBackList;
        callBackList = new EventRecord[size + CALLBACKLIST_INCREMENT];
  
        if(!callBackList){
            cerr<<"CallBack: memory allocation error."<<endl;
            exit(1);
        }
          for(int i = 0; i < size; i++) callBackList[i] = tempList[i];
        delete [] tempList;
        size += CALLBACKLIST_INCREMENT;
    }
  
callBackList[lastpos] = EventRecord(event,pCBSF)；
lastpos++;
}
  
//删除注册在指定事件上的成员函数
void CallBack::RemoveCallBack(char *event, CallBackFunction pCBF, CallBack *pCBO)
{
    if( (event == NULL)?1:(strlen(event) == 0)) return;
    EventRecord er(event,pCBO,pCBF);
  
    for(int i = 0; i < lastpos; i++)
    if(callBackList[i] == er) callBackList[i].Flush();
}
  
//删除注册在指定事件上的静态成员函数或普通函数
void CallBack::RemoveCallBack(char *event,CallBackStaticFunction pCBSF)
{
    if( (event == NULL)?1:(strlen(event) == 0)) return;
    EventRecord er(event,pCBSF);
  
    for(int i = 0; i < lastpos; i++)
2401_87255144
关注
c++ 操作mysql数据库_C++连接mysql数据库的两种方法
weixin_29384935的博客
01-20 1997
现在正做一个接口，通过不同的连接字符串操作不同的数据库。要用到mysql数据库，以前没用过这个数据库，用access和sql server比较多。通过网上的一些资料和自己的摸索，大致清楚了C++连接mysql的方法。可以通过2种方法实现。***种方法是利用ADO连接，第二种方法是利用mysql自己的api函数进行连接。***种方法可以实现我当前的需求，通过连接不同的字符串来连接不同的数据库。暂时只...
c++ 学习之 多线程（一） thread对象的创建
weixin_45074185的博客
02-17 1166
c++ 学习之 多线程（一） 前言 在之前的c++标准中，并没有提供对于多线程的支持，所以在应用中的开发需就要依赖操作系统提供的多线程接口，或者应用第三方的多线程库。这样一来，代码的移植性和开发的成本就存在了问题。c++ 11 标准提供了多线程的支持，增加的多线程代码的可移植性，大大降低了开发成本，以前依赖于平台或操作系统来开发多线程，现在有了统一致的实现。 正文 那么通过什么来创建一个线程呢？我...
C++中建立对象间消息连接的一种系统方法——回调函数
taozhiying520的博客
05-25 900
C++中建立对象间消息连接的一种系统方法——回调函数 作者:项飞 用过C++进行过面向对象程序设计的用户都知道，程序中的对象很少单独存在。不考虑对象间的相互作用几乎是不可能的。所以，标识对象间的关系或建立对象间的消息连接是面向对象程序设计的一项重要任务。本文着重从C++程序设计的角度，提出一种建立对象间消息连接的实用方法。如果你想详细了解面向对象程序设计技术，请参阅有关专著。大家都知道对象是数
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 66万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
C++ 10：对象池
小柒的秃头之路
07-22 2039
提前保存大量的资源，以备不时之需以及重复使用，池化技术应用广泛，如内存池，线程池，连接池（网络链接池，数据库链接池）等等。由于在实际应用当做分配内存、创建进程、线程都会设计到一些系统调用，系统调用需要导致程序从用户态切换到内核态，是非常耗时的操作。因此，当程序中需要频繁的进行内存申请释放，进程、线程创建销毁等操作时，通常会使用内存池、进程池、线程池技术来提升程序的性能。池化对连接或线程的复用，并对复用的数量、时间等进行控制，从而使得系统的性能和资源消耗达到最优状态。不完美转发完美转发。.........
C++入门——面向对象
beilizhang的博客
07-18 2297
面向对象 面向对象与面向过程，即对象 面向对象把数据即对数据的操作方法放在一起，作为一个相互依存的整体，即对象。对同类对象抽象出其共性，即类，类中的大多数数据都只能被本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。抽象流程由用户在使用中决定 面向过程是一个以事件为中心的开发方法，就是自顶向下顺序执行，逐步求精，其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构，各模块之间的关系也比较简单，在功能上相互独立，每一模块内部都是由顺序、选择和循环三
C++ 类对象初始化
鲸落博客
05-01 1113
当创建一个类的实例时，如果没有定义构造函数，系统会自动生成一个无参构造函数，并自动初始化成员变量。内置类型的变量（如int、double、指针等）会被初始化为一个未定义的值，而自定义类型的变量（如类、结构体）会调用默认构造函数进行初始化。
（七）C++与QML混合编程---在QML中使用C++对象
bureau123的博客
04-25 2978
QML中使用C++类 Qt提供了两种在QML中使用C++对象的方式： 在C++中实现一个类，注册为QML环境的一个类型，在QML环境中使用该类创建对象。 在C++中构造一个对象，将这个对象设置为QML的上下文属性，在QML环境中直接使用该属性。 定义可以导出的C++类 要想将一个类或对象导出到QML中，必须满足下面两个条件： 从QObject或QOjbect的派生类继承 使用Q_OBJECT宏 这两个条件也是使用QT信号槽的前提，就是为了让一个类能够进入QT的元对象系统中，只有使用元对象系统，一个类
C++的MQTT开发：使用Paho的C++接口实现消息发布、订阅、连接RabbitMQ
BigBookX's Blog
06-02 4224
具体的MQTT应用程序可能会有不同的需求和限制。如果应用程序需要在发送消息之间有较长的时间间隔，或者需要处理长时间的非活动状态，那么可以考虑在一段时间后断开连接，并在需要时重新连接。您可以参考paho的官方文档和示例代码来进一步了解和掌握paho的cpp接口的使用。本示例代码仅提供了一个基本的框架，需要根据自己的需求进行更多的自定义和错误处理。是异步的客户端实现，它使用了异步操作和回调函数来处理发送和接收消息，不会阻塞当前线程。提供了更强大的功能和更好的并发性能，但它需要更多的代码和处理异步回调函数。
使用libssh2建立安全的SSH连接：C++开发者的综合指南
Lion_Long的博客
12-01 4003
本文是一篇关于使用libssh2库建立安全SSH连接的综合指南。文章首先介绍了libssh2库的基本概念和用途，然后详细介绍了使用该库建立SSH连接的准备工作。接着，文章给出了建立SSH连接的步骤，包括初始化libssh2库、连接到远程主机等。最后，文章还提供了文件传输的示例，包括上传文件到远程主机和下载文件到本地主机的操作。
C++中建立对象间消息连接的系统方法
12-09
本文提出了一种建立对象间消息连接的系统方法，该方法可以实现在C++程序设计中建立对象间的消息连接。这种方法可以使程序设计更加灵活和可扩展。 知识点： 1. 面向对象程序设计中对象之间的关系或消息连接的重要性...
C++连接mysql数据库的两种方法小结
08-19
首先，一种是使用ActiveX数据对象（ADO）连接，另一种是使用MySQL提供的API函数进行连接。 描述中概述了文章的内容，强调了示例代码的详尽性和学习价值，同时指出这两种方法对应于连接不同数据库的场景需求。特别...
C++连接mysql数据库的两种方法.docx
11-04
在 C++ 中连接 mysql 数据库有两种方法，一种是利用 ADO 连接，另一种是利用 mysql 自己的 API 函数进行连接。下面我们将详细介绍这两种方法。 第一种方法：利用 ADO 连接 ADO（ActiveX Data Objects）是 ...
ModbusTCP连接C++源码
04-26
ModbusTCP是Modbus协议的一种变体，它在标准的TCP/IP协议之上建立，使得Modbus通信能够跨越局域网和互联网，提高了通信的可靠性和距离范围。在C++中实现ModbusTCP连接，通常需要对TCP/IP协议栈有深入理解，并掌握...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 987
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1004
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 482
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 553
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值