從C++派生類的基類中調用未定義的成員函數是否安全？

Question

我在閱讀有關委派，我想能夠在基類內調用任何函數傳遞作爲參數取決於事件，所以如果例如我有一個解析器對象，並且我想從另一個對象分配什麼方法來調用依賴找到什麼標記。我做了波紋管，它可以工作，但我不確定它是否是正確的方式，或者它是否像便攜式一樣。

class base{ 
public: 
    typedef void (base::*methodPTR)(); 
    methodPTR pfn; 

    void setMethod(methodPTR fn) 
    { 
     pfn = fn; 
    } 
    void run(){ 
     if(pfn) (this->*pfn)(); 
    } 
}; 

class a : public base { 
public: 
}; 

class b : public base 
{ 
    a ob; 
public: 
    void init() 
    { 
      //this function fn is not define neither in object "a" or "base" 
      //but still I can assign arbitrary member function just like I wanted 
     ob.setMethod(static_cast<base::methodPTR>(&b::fn)); 
    } 

    void fn() 
    { 
     cout << "from class b!" << endl; 
    } 

    void test() 
    { 
     ob.run(); 
    } 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    b x; 
    x.init(); 
    x.test(); 

    return 0; 
} 

Answer 1

做你正在做的是安全的，只要你相信，你永遠不會調用對象，這不是真正的指針所來自的類型（即一個你不上成員指針在base上撥打a::x）。

Answer 2

試試這個問題的模板解決方案，在這個例子中我確定使用正確的對象來調用正確的函數。 如果我們有地圖對象和回調，並且可能會根據某些條件調用它們，我們可以使用它。

//store objects vs callbacks 
    //you could replace int in map with some condition or key to invoke a callback 
#include <iostream> 
#include <map> 

using namespace std; 

template<class T> 
class A { 
    protected: 
    void (T::*curr_f)(); 
    private: 
    static std::map<int, std::map<T*,void (T::*)() > > callBacks; 
    public: 

    virtual void set(void (T::*f)()) { 
    curr_f = f; 
    cout<<"Set in A"<<endl; 
    T* obj = new T(); 
    static int x = 0; 
    callBacks[++x][obj] = f; 
    //  (obj->*curr_f)(); 
    } 

    virtual void new_function() {cout<<"in A"<<endl;}; 

    static void run() 
    { 
    for(typename std::map<int,std::map<T*,void (T::*)() > >::iterator itr = A<T>::callBacks.begin(); 
     itr != A<T>::callBacks.end(); ++itr) 
    { 
     for(typename std::map<T*,void (T::*)() >::iterator itr2 = itr->second.begin(); 
      itr2 != itr->second.end(); ++itr2) 
     { 
     ((itr2->first)->*(itr2->second))(); 
     } 
    } 
    } 

}; 

template<class T> 
std::map<int, std::map<T*,void (T::*)() > > A<T>::callBacks; 

class B :public A<B> { 

    public: 
    void func() { 
     set(&B::new_function); 
    }; 
    void new_function() {cout<<"in B"<<endl;}; 

}; 

class C:public A<C> { 

    public: 
    void func() { 
     set(&C::new_function); 
    }; 
    void new_function() {cout<<"in C"<<endl;}; 

}; 

int main() 
{ 

    B obj1; 
    C obj2; 
    obj1.func(); 
    obj2.func(); 
    A<B>::run(); 
    A<C>::run(); 
}