回調函數設計C++

Question

我想實現一個回調管理器，它可以註冊和執行不同類的回調，每個類都來自不同的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; 
} 

LF不使用模板化的回調經理，我怎麼能實現像SetFunPointer（EVENT_NAME，（基類）A :: testCallback）？

Answer 1

你可以看看這個問題using member-function pointers。

它歸結爲你需要的實例以及mem-func指針，你不能有一個通用的在任何地方使用。

Answer 2

謝謝你們。我設法用你的「指針」來想出一些東西。 :)

文件：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; 
} 


}; 

文件：main.cpp中