（C++）如何指向子類中的方法？

Question

我有一個基類Base，它有方法runUserMethod(void * pointer_to_method)。

class Base { 
    int runUserMethod(METHTYPE pointer_to_method) { 
     // do some stuff before 
     int retval = pointer_to_method(); 
     // do some stuff after 
     return retval; 
    } 
}; 

現在，我想在某種程度上，它是能夠運行由Base一個子類實現的任何方法，但這種方法遵循一些標準簽名以實現runUserMethod，如int <methodname> (void)

例如，假設用戶創建像類UserClass：

class UserClass : public Base { 
    int user_method (void); 
}; 

我應該METHTYPE是，這樣我可以做到以下幾點？

Base * b = new UserClass(); 
int retval = b->runUserMethod(&UserClass::user_method); 

此外，它會工作嗎？有沒有更好的方法來做到這一點？基本上，我試圖做的是攔截調用子類的方法調用，或多或少透明的方式給用戶。

Answer 1

你可以嘗試製作runUserMethod模板方法。另外，爲了安全地從基礎施法這派生你應該多態使用的dynamic_cast所以基地類必須類（通過添加例如虛擬析構函數）：

class Base { 
public: 

    template <class T> 
    int runUserMethod(int (T::* pointer_to_method)()) { 
     T* p = dynamic_cast<T*> (this); 
     if (p == NULL) throw std::runtime_error("cast error"); 


     // do some stuff before 
     int retval = (p->*pointer_to_method)(); 
     // do some stuff after 
     return retval; 
    } 

    virtual ~Base() {}; 
}; 

函數的用法是一樣的您的代碼示例：

Base* b = new UserClass; 
int r = b->runUserMethod(&User::user_method); 

函數參數和返回值類型也可以做成模板參數，使runUserMethod接受其他函數簽名：

class Base { 
public: 

    // 0 arguments 
    template <class T, class R> 
    int runUserMethod(R (T::* pointer_to_method)()) { 
     T* p = dynamic_cast<T*> (this); 
     if (p == NULL) throw std::runtime_error("cast error"); 

     // do some stuff before 
     R retval = (p->*pointer_to_method)(); 
     // do some stuff after 
     return retval; 
    } 

    // 1 argument 
    template <class T, class R, class ARG1> 
    int runUserMethod(R (T::* pointer_to_method)(ARG1), ARG1 arg1) { 
     T* p = dynamic_cast<T*> (this); 
     if (p == NULL) throw std::runtime_error("cast error"); 

     // do some stuff before 
     R retval = (p->*pointer_to_method)(arg1); 
     // do some stuff after 
     return retval; 
    } 

    // 2 arguments 
    // [...] 

    virtual ~Base() {}; 
}; 

下面這樣的代碼也將工作：

class UserClass : public Base { 
public: 
    int user_method1 (void) {return 0;} 
    float user_method2 (void) {return 0.0f;} 
    int user_method3 (int x) {return 0;} 
}; 

int main(int argc, char* argv[]) { 
    Base* b = new UserClass; 
    int r1 = b->runUserMethod(&UserClass::user_method1); 
    float r2 = b->runUserMethod(&UserClass::user_method2); 
    int r3 = b->runUserMethod(&UserClass::user_method3, 2); 
} 

Answer 2

這可以通過使用std::function和std::bind來完成：

struct Base 
{ 
    typedef std::function<int()> METHTYPE; 

    int runUserMethod(METHTYPE pointer_to_method) 
    { 
     return pointer_to_method(); 
    } 
}; 

UserObject b; 
auto func_object = std::bind(&UserObject::user_method, std::ref(b)); 

int retval = b.runUserMethod(func_object); 

Answer 3

如果改變更真實可行的狀態，你的例子中，你將看到的問題：

int retval  = (this->*methptr)(); 

撇開醜陋的語法，問題是您需要將具有類型Base *的「this」指針傳遞給方法調用，但您應該將指針傳遞給派生類的方法
因此，您需要使runUserMethod知道派生類SS（可能是模板）或強制轉換指針衍生方法指向與風險的基礎方法的問題：

class Derived1 : public Base ... 
class Derived2 : public Base ... 
Derived2 d2; 
d2.runUserMethod(static_cast<METHTYPE>(&Derived1::func)); // problem Derived2 * will be passed to Deriived1 method and there is no easy way to detect that 

因此，使用的std ::綁定會更安全。你不必從基地繼承（我不知道你的情況是否好）