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

// 15 // 16 
//--------------------------------------------------------------------------------------------
// 静态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!=-1)
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 = 0;

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 = -1;
    // 扫描是否已存在该连接(同时记录下第一个位置内存项记录)
    for(int i=0;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 0; // 已存在该连接
            }
        }
        else
        {
            if(-1==nPos)
            {
                nPos = i;// 记住第一个扫描到的位置用内存项位置
            }
        }
    }
    
    //增加新连接
    if(nPos!=-1)// 占用空闲位置项
    {
        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 1;
    }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 1;
    }
}

// 信号|槽连接: <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 = -1;
    for (int i=0;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=0;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 0;  //已存在该连接
                    }
                }else
                {
                    if(-1==nPos)
                    {
                        nPos = k;
                    }
                }
            }
            // 新增连接
            fItem.is_use = true;
            fItem.signal_F = signal_F;
            fItem.slot_F = slot_F;
            if(nPos!=-1)
            {
                sItem.pFuncArray->SetAt(nPos,fItem);
                return 1;
            }else
            {
                sItem.pFuncArray->Add(fItem);
                return 1;
            }
        }
    }

    return -1;   // 对象连接没有初始化
}

// 返回值: 调用槽的执行数目(每调用一个槽函数,返回值加1)
int CSignalSlot::SignalSS(void *signal_pSelf,int signal_F,void *pSrc, void *pDes)
{
    int res = 0;
    int len  = CSignalSlot::m_SSArray.GetSize();
    for(int i=0;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=0;k<sum;k++)
            {
                FuncItem fitem = ssitem.pFuncArray->GetAt(k);
                if(fitem.is_use==true && signal_F==fitem.signal_F)  //找到信号|槽连接
                {
                    ////////////////////////////////////////////////////////////////////////////
                    if(CSignalSlot::m_loopback>0)    //判断是否出现回环(避免信号函数的嵌套调用)
                    {
                        CSignalSlot::m_loopback = 0; //清除嵌套计数    
                        return 0;  // 中断返回
                    }
                    CSignalSlot::m_loopback += 1;
                    /////////////////////////////////////////////////////////////////////////////

                    SS_STAIC_SLOTFUNC tempFunc = (SS_STAIC_SLOTFUNC)ssitem.slot_pFunc;
                    tempFunc(ssitem.slot_pSelf,fitem.slot_F,pSrc,pDes); //通过静态槽接口函数发起调用
                    res+=1;
                }
            }
        }
    }

    CSignalSlot::m_loopback=0; //清除嵌套计数
    return res;
}

// 关闭删除对象连接(单向)
// 返回值:>0 成功    0 已不存在该连接     -1 删除失败
int CSignalSlot::CloseSS(void *signal_pSelf, void *slot_pSelf)
{
    int len = CSignalSlot::m_SSArray.GetSize();
    SSItem sItem;
    int res = 0;
    for(int i=0;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+=1;
            }
        }else if(NULL==slot_pSelf)
        {
            if(signal_pSelf==sItem.signal_pSelf)
            {
                sItem.is_use = false;
                CSignalSlot::CloseFuncArray(sItem.pFuncArray);
                res+=1;
            }
        }else if(signal_pSelf==sItem.signal_pSelf && slot_pSelf==sItem.slot_pSelf)
        {
            sItem.is_use = false;
            CSignalSlot::CloseFuncArray(sItem.pFuncArray);
            res+=1;
            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=0;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=0;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 1;  //删除连接
                }
            }
        }
    }

    return 0;   // 对象连接没有初始化
}


void CSignalSlot::CloseFuncArray(CArray<FuncItem,FuncItem>*pFuncArray)
{
     int sum = pFuncArray->GetSize();
     FuncItem item;
     for(int k=0;k<sum;k++)
     {
         item = pFuncArray->GetAt(k);
         item.is_use = false;
         pFuncArray->SetAt(k,item);
     }
}