C++ 对象间通讯机制 框架实现

 // SignalSlot.h: interface for the CSignalSlot class.
 //
 //////////////////////////////////////////////////////////////////////
 
 #if !defined(AFX_SIGNALSLOT_H__A686E4F2_5477_4D5E_9A1F_03883EEBAB1E__INCLUDED_)
 #define AFX_SIGNALSLOT_H__A686E4F2_5477_4D5E_9A1F_03883EEBAB1E__INCLUDED_
 
 #include <Afxtempl.h>
 
 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000
 
 // //
 //--------------------------------------------------------------------------------------------
 // 静态slot接口函数类型指针定义
 typedef int (__cdecl *SS_STAIC_SLOTFUNC)(void *pSelf,int slot_F,void *pSrc,void *pDes);
 
 // 数据结构定义
 struct FuncItem
 {
     bool is_use;  //是否使用
     int signal_F;
     int slot_F;
 };
 
 struct SSItem
 {
     bool is_use;  //是否使用
 
     void* signal_pSelf;
     void* slot_pSelf;
 
     void* slot_pFunc;
     CArray<FuncItem,FuncItem>*pFuncArray;
 };
 
 //----------------------------------------------------------------------------------------------------------------------
 /*
 宏定义1: 信号槽类注册
 说明: 信号槽(接收方)类定义需要使用该宏声明
 在类定义最开始位置声明，结尾不需要冒号。例子如下所示:
 class CTest
 {
     SS_REGISTER(CTest)
 public:
     ...
 }
 
 参数: ClassName 为类名称
 宏展开: 定义了一个公有静态函数:
         SS_STATIC_SLOT: 函数名称
         pSelf: 类对象指针
         slot_F: 槽函数ID (成员函数指针转换得到)
         pSrc: 信号发送方输入参数void通用指针
         pDes: 返回参数内存指针(由调用方提供)
 */
 #define SS_REGISTER(ClassName) \
 public: static int _SS_STATIC_SLOT_(void *pSelf,int slot_F,void *pSrc,void *pDes)\
 {\
     typedef    int(ClassName::*SLOTFUNC)(void*pSrc,void*pDes=NULL);\
     SLOTFUNC  slot_Func;\
     int TEMP = (int)(&slot_Func);\
     *((int*)(TEMP)) = slot_F;\
     int res = (((ClassName*)(pSelf))->*slot_Func)(pSrc,pDes);\
     return res;\
 }
 
 // 宏定义2: 信号函数定义
 #define SS_SIGNAL(ClassName,FuncName) \
 int FuncName(void*pSrc,void*pDes=NULL)\
 {\
     typedef int(ClassName::*SLOTFUNC)(void*,void*);\
     SLOTFUNC pfunc = &ClassName::FuncName;\
     int funcID = *((int*)((int)(&pfunc)));\
     return CSignalSlot::SignalSS(this,funcID,pSrc,pDes);\
 }
 
 // 宏定义3: 初始化连接
 #define SS_INITE(signalSelf,slotSelf,res) \
 *res = CSignalSlot::IniteSS(signalSelf,slotSelf,(slotSelf)->_SS_STATIC_SLOT_);
 
 // 宏定义4: 解除对象连接
 #define SS_CLOSE(signalSelf,slotSelf,res) \
 *res = CSignalSlot::CloseSS(signalSelf,slotSelf);
 
 // 宏定义5: 连接功能函数
 #define SS_CONNECT(signalClassName,signalSelf,signalFunc,slotClassName,slotSelf,slotFunc,res) \
 {\
   typedef int(signalClassName::*SIGNAL_PF)(void*,void*);\
   typedef int(slotClassName::*SLOT_PF)(void*,void*);\
   SIGNAL_PF Signal_F = &signalClassName::signalFunc;\
   SLOT_PF slot_F = &slotClassName::slotFunc;\
   *res = CSignalSlot::ConnectSS(signalSelf,*((int*)((int)(&Signal_F))),slotSelf,*((int*)((int)(&slot_F))));\
 }
 
 // 宏定义6: 断开功能连接
 #define SS_DISCONNECT(signalClassName,signalSelf,signalFunc,slotClassName,slotSelf,slotFunc,res) \
 {\
     typedef int(signalClassName::*SIGNAL_PF)(void*,void*);\
     typedef int(slotClassName::*SLOT_PF)(void*,void*);\
     SIGNAL_PF Signal_F = &signalClassName::signalFunc;\
     SLOT_PF slot_F = &slotClassName::slotFunc;\
     *res = CSignalSlot::DisConnectSS(signalSelf,*((int*)((int)(&Signal_F))),slotSelf,*((int*)((int)(&slot_F))));\
 }
 
 // 宏定义7: 初始化连接(3与5的功能组合)
 #define SS_INICONNECT(signalClassName,signalSelf,signalFunc,slotClassName,slotSelf,slotFunc,res) \
 SS_INITE(signalSelf,slotSelf,res)\
 if(*res!=-)\
 SS_CONNECT(signalClassName,signalSelf,signalFunc,slotClassName,slotSelf,slotFunc,res);
 //------------------------------------------------------------------------------------------------------------------------------
 
 class CSignalSlot
 {
 public:
     static int DisConnectSS(void* signal_pSelf,int signal_F,void* slot_pSelf,int slot_F);
     static int CloseSS(void *signal_pSelf,void*slot_pSelf);
     static int IniteSS(void* signal_pSelf,void* slot_pSelf,SS_STAIC_SLOTFUNC slot_pFunc);
     static int SignalSS(void *signal_pSelf,int signal_F,void *pSrc,void *pDes=NULL);
     static int ConnectSS(void* signal_pSelf,int signal_F,void* slot_pSelf,int slot_F);
     CSignalSlot();
     virtual ~CSignalSlot();
 private:
     static void CloseFuncArray(CArray<FuncItem,FuncItem>*pFuncArray);
     static CArray<SSItem,SSItem>m_SSArray;
     static int m_loopback;
 };
 
 #endif // !defined(AFX_SIGNALSLOT_H__A686E4F2_5477_4D5E_9A1F_03883EEBAB1E__INCLUDED_)

 // SignalSlot.cpp: implementation of the CSignalSlot class.
 //
 //////////////////////////////////////////////////////////////////////
 
 #include "stdafx.h"
 #include "SignalSlot.h"
 
 #ifdef _DEBUG
 #undef THIS_FILE
 static char THIS_FILE[]=__FILE__;
 #define new DEBUG_NEW
 #endif
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
 CArray<SSItem,SSItem> CSignalSlot::m_SSArray;
 int CSignalSlot::m_loopback = ;
 
 CSignalSlot::CSignalSlot()
 {
 
 }
 
 CSignalSlot::~CSignalSlot()
 {
 
 }
 
 //初始化对象连接  建立非对称连接  signal对象可以往slot对象发消息   一条单向通信链路定义为一个连接项
 // 返回值:1  成功    0 已存在该连接     -1 添加失败
 int CSignalSlot::IniteSS(void* signal_pSelf,void* slot_pSelf,SS_STAIC_SLOTFUNC slot_pFunc)
 {
     int len = CSignalSlot::m_SSArray.GetSize();
     SSItem tItem;
     int nPos = -;
     // 扫描是否已存在该连接(同时记录下第一个位置内存项记录)
     for(int i=;i<len;i++)
     {
         tItem = CSignalSlot::m_SSArray.GetAt(i);
         if(true==tItem.is_use)
         {
             if(signal_pSelf==tItem.signal_pSelf && slot_pSelf==tItem.slot_pSelf)
             {
                 return ; // 已存在该连接
             }
         }
         else
         {
             if(-==nPos)
             {
                 nPos = i;// 记住第一个扫描到的位置用内存项位置
             }
         }
     }
 
     //增加新连接
     if(nPos!=-)// 占用空闲位置项
     {
         tItem = CSignalSlot::m_SSArray.GetAt(nPos);
         tItem.is_use = TRUE;
         tItem.signal_pSelf = signal_pSelf;
         tItem.slot_pSelf = slot_pSelf;
         tItem.slot_pFunc = slot_pFunc;
 
         CSignalSlot::m_SSArray.SetAt(nPos,tItem);
         return ;
     }else //新增位置项
     {
         tItem.is_use = TRUE;
         tItem.signal_pSelf = signal_pSelf;
         tItem.slot_pSelf = slot_pSelf;
         tItem.slot_pFunc = slot_pFunc;
         tItem.pFuncArray = new CArray<FuncItem,FuncItem>;
         CSignalSlot::m_SSArray.Add(tItem);
         return ;
     }
 }
 
 // 信号|槽连接: <signal对象+成员函数ID,slot对象+成员函数>作为一个连接项
 // 返回值：1:成功    0:已存在该连接项     -1:添加失败
 int CSignalSlot::ConnectSS(void* signal_pSelf,int signal_F,void* slot_pSelf,int slot_F)
 {
     int len = CSignalSlot::m_SSArray.GetSize();
     SSItem sItem;
     FuncItem fItem;
     int nPos = -;
     for (int i=;i<len;i++)
     {
         sItem = CSignalSlot::m_SSArray.GetAt(i);
         if(signal_pSelf==sItem.signal_pSelf && slot_pSelf==sItem.slot_pSelf && true==sItem.is_use)
         {
             int sum = sItem.pFuncArray->GetSize();
             for(int k=;k<sum;k++)
             {
                 fItem= sItem.pFuncArray->GetAt(k);
                 if(true==fItem.is_use)
                 {
                     if(signal_F==fItem.signal_F && slot_F==fItem.slot_F)
                     {
                         return ;  //已存在该连接
                     }
                 }else
                 {
                     if(-==nPos)
                     {
                         nPos = k;
                     }
                 }
             }
             // 新增连接
             fItem.is_use = true;
             fItem.signal_F = signal_F;
             fItem.slot_F = slot_F;
             if(nPos!=-)
             {
                 sItem.pFuncArray->SetAt(nPos,fItem);
                 return ;
             }else
             {
                 sItem.pFuncArray->Add(fItem);
                 return ;
             }
         }
     }
 
     return -;   // 对象连接没有初始化
 }
 
 // 返回值: 调用槽的执行数目(每调用一个槽函数,返回值加1)
 int CSignalSlot::SignalSS(void *signal_pSelf,int signal_F,void *pSrc, void *pDes)
 {
     int res = ;
     int len  = CSignalSlot::m_SSArray.GetSize();
     for(int i=;i<len;i++)
     {
         SSItem ssitem = CSignalSlot::m_SSArray.GetAt(i);
         if(ssitem.is_use == true && signal_pSelf==ssitem.signal_pSelf) //找到对象连接
         {
             int sum = ssitem.pFuncArray->GetSize();
             for(int k=;k<sum;k++)
             {
                 FuncItem fitem = ssitem.pFuncArray->GetAt(k);
                 if(fitem.is_use==true && signal_F==fitem.signal_F)  //找到信号|槽连接
                 {
                     ////////////////////////////////////////////////////////////////////////////
                     if(CSignalSlot::m_loopback>)    //判断是否出现回环(避免信号函数的嵌套调用)
                     {
                         CSignalSlot::m_loopback = ; //清除嵌套计数
                         return ;  // 中断返回
                     }
                     CSignalSlot::m_loopback += ;
                     /////////////////////////////////////////////////////////////////////////////
 
                     SS_STAIC_SLOTFUNC tempFunc = (SS_STAIC_SLOTFUNC)ssitem.slot_pFunc;
                     tempFunc(ssitem.slot_pSelf,fitem.slot_F,pSrc,pDes); //通过静态槽接口函数发起调用
                     res+=;
                 }
             }
         }
     }
 
     CSignalSlot::m_loopback=; //清除嵌套计数
     return res;
 }
 
 // 关闭删除对象连接(单向)
 // 返回值:>0 成功    0 已不存在该连接     -1 删除失败
 int CSignalSlot::CloseSS(void *signal_pSelf, void *slot_pSelf)
 {
     int len = CSignalSlot::m_SSArray.GetSize();
     SSItem sItem;
     int res = ;
     for(int i=;i<len;i++)
     {
         sItem = CSignalSlot::m_SSArray.GetAt(i);
         if(false==sItem.is_use)
         {
             continue;
         }
         if(NULL==signal_pSelf)
         {
             if(slot_pSelf==sItem.slot_pSelf)
             {
                 sItem.is_use = false;
                 CSignalSlot::CloseFuncArray(sItem.pFuncArray);
                 res+=;
             }
         }else if(NULL==slot_pSelf)
         {
             if(signal_pSelf==sItem.signal_pSelf)
             {
                 sItem.is_use = false;
                 CSignalSlot::CloseFuncArray(sItem.pFuncArray);
                 res+=;
             }
         }else if(signal_pSelf==sItem.signal_pSelf && slot_pSelf==sItem.slot_pSelf)
         {
             sItem.is_use = false;
             CSignalSlot::CloseFuncArray(sItem.pFuncArray);
             res+=;
             break;
         }
     }
     return res;
 }
 
 // 删除信号槽连接
 // 返回值:1 成功    0 已不存在该连接   -1 删除失败
 int CSignalSlot::DisConnectSS(void *signal_pSelf, int signal_F, void *slot_pSelf, int slot_F)
 {
     int len = CSignalSlot::m_SSArray.GetSize();
     SSItem sItem;
     for (int i=;i<len;i++)
     {
         sItem = CSignalSlot::m_SSArray.GetAt(i);
         if(signal_pSelf==sItem.signal_pSelf && slot_pSelf==sItem.slot_pSelf &&true==sItem.is_use)
         {
             int sum = sItem.pFuncArray->GetSize();
             FuncItem item;
             for(int k=;k<sum;k++)
             {
                 item = sItem.pFuncArray->GetAt(k);
                 if(signal_F==item.signal_F && slot_F==item.slot_F)
                 {
                     item = sItem.pFuncArray->GetAt(k);
                     item.is_use = false;
                     sItem.pFuncArray->SetAt(k,item);
                     return ;  //删除连接
                 }
             }
         }
     }
 
     return ;   // 对象连接没有初始化
 }
 
 void CSignalSlot::CloseFuncArray(CArray<FuncItem,FuncItem>*pFuncArray)
 {
      int sum = pFuncArray->GetSize();
      FuncItem item;
      for(int k=;k<sum;k++)
      {
          item = pFuncArray->GetAt(k);
          item.is_use = false;
          pFuncArray->SetAt(k,item);
      }
 }