可视化回调函数设计C++

visual callback function design C++

本文关键字：C++ 函数 回调 可视化      更新时间：2023-10-16

>我正在尝试实现一个回调管理器，该回调管理器可以注册和执行来自不同类的回调，每个类都来自不同的DLL。

这些类中的每一个都派生自一个公共基类。我知道单个类如何使用如下所示的模板类来注册和调用自己的函数，但是如何将其应用于共享同一回调管理器的多个类？

任何帮助将不胜感激。

file: callbacktemplate.h
------------------------
#include <functional>
#include <string>
template <class cInstance>
class cCallBackManager
{
private:
    typedef void (cInstance::*tFunction)();
    typedef std::map<std::string, tFunction> funcMap;
     funcMap i_funcMap;
public:
    void SetFunPointer(std::string funcName, tFunction function)
    {
        i_funcMap.insert(std::pair<std::string, tFunction>(funcName, function));            
    }
    void GetFunPointer(cInstance& obj) //how to call this without knowing the type?
    {
        for (funcMap::iterator it = i_funcMap.begin();it!=i_funcMap.end(); ++it)
        {
            (obj.*(it->second))(); 
        }
    }
};

file:example.h
---------------
#include "callbacktemplate.h"
class A: public base
{
private:
    cCallBackManager<A> callback;
public:
     A()
     {
         callback.SetFunPointer<A>("eventA", &A::testcallback);
         callback.GetFunPointer(&this);   //how to generalize this so this can be called from the callback manager with the class object?
     };
     ~A(){};
     void testCallback();
};
class B: public base
{
private:
    cCallBackManager<B> callback;
public:
     B()
     {
         callback.SetFunPointer<B>("eventB", &B::testcallback);
     };
     ~B(){};
     void testCallback();
};
file: main.cpp
------------------
#include "derived.h"
int main()
{
 A a;
 B b;
 //create a callback manager to execute the callback?
 callbackmgr.execute() //execute all the callback
 return 0;
}

如果不使用模板化的回调管理器，我怎样才能实现像 SetFunPointer（EVENT_NAME， （Base Class）A：：testCallback）这样的东西？

谢谢大家。我设法用你的"指针"想出了一些东西。:)

文件： cCallBackInterface.h

template<class cClass>
class cCallBackInterface
{
public:
cCallBackInterface(){};
~cCallBackInterface(){};
typedef void (cClass::*Function)();
cCallBackInterface(cClass* obj, Function _Function)
{
    cInstance = obj;
    m_Function = _Function;
}
void execute()
{
     (cInstance->*m_Function)();
}
private:
cClass* cInstance;
Function m_Function;
};

文件： base.h

class BaseModel;
typedef cCallBackInterface<BaseModel> CallBackInterface;
typedef void(BaseModel::*basefn)();
class BaseModel 
{
public:
BaseModel(){};
~BaseModel(){};
}
};

class derived : public BaseModel
{
public:
derived(){};
~derived(){};
void dosomething()
{
    cout << "derived class is doing something." << endl;
}

};

文件：主.cpp

int main()
{  
derived a;
std::vector<CallBackInterface> callback;
callback.push_back(CallBackInterface(&a, (basefn)(&derived::Adosomething)));
for(int i = 0; i < callback.size(); i++)
    callback[i].execute();
return 0;
}

您可以查看有关使用成员函数指针的此问题。

归根结底，您需要实例以及mem-func指针，您不能在任何地方使用通用指针。

相关文章：