멤버 함수 포인터 및 상속

Question

이러한 문제를 해결해야합니다. 기본 클래스와 두 개의 상속 된 클래스가 있습니다. 기본 클래스는 함수 포인터를 매개 변수로 필요로하는 메서드를 포함합니다. 그러나 이러한 함수는 상속 된 클래스에서 정의됩니다.

오류 C2664 : 'CBase ::는 waitEvent'

class CBase; 

typedef bool (CBase::*FPredicate)(); 

class CBase 
{ 
public: 
    CBase() {} 
    ~CBase() {} 
protected: 
    //this method waits until 'predicate' is true or until 'timeout' ms. passed 
    //and returns true if 'predicate' is true eventually 
    bool WaitEvent(FPredicate predicate, int timeout) 
    { 
     bool result = false; 
     int time1 = GetTickCount(); 
     int time2; 

     bool isEnd = false; 
     while(!isEnd) 
     { 
      result = isEnd = (this->*predicate)();    

      time2 = GetTickCount(); 
      if(time2 - time1 > timeout && !isEnd) 
       isEnd = true; 
     } 
     return result; 
    } 
}; 

class CChildA : public CBase 
{ 
protected: 
    bool a1() {/*some work*/} 
    bool a2() {/*some work*/} 
    void a_main() 
    { 
     ... 
     WaitEvent(&CChildA::a1, 100); 
     ... 
     WaitEvent(&CChildA::a2, 100); 
     ... 
    } 
}; 

class CChildB : public CBase 
{ 
protected: 
    bool b1() {/*some work*/} 
    bool b2() {/*some work*/} 
    void b_main() 
    { 
     ... 
     WaitEvent(&CChildB::b1, 100); 
     ... 
     WaitEvent(&CChildB::b2, 100); 
     ... 
    } 
}; 

MSVC 2005 컴파일러는 waitEvent에 오류가 호출을 제공 부울 '에서 매개 변수 1 변환 할 수 없습니다 (__thiscall CChildA :: *) (무효) 'to'FPredicate '

질문 : 어떻게 작동 시키려면 코드를 변경해야합니까? WaitEvent 호출을 WaitEvent((FPredicate)(&CChildA::a1), 100)으로 다시 쓰는 것이 안전할까요?

이 경우 컴파일러는 오류는 표시하지 않지만 안전합니까? 아니면 문제를 푸는 더 좋은 방법이 있습니까?

미리 감사드립니다.

Answer 1

문제는 암시 적으로 전달 된 형식이 다른 것입니다. 어느 쪽을 캐스팅했는지는 다중 상속이있는 경우에는 실패 할 것입니다. 더 나은 &보다 강력한 솔루션에 서명을 변경하는 것입니다 :

이

template< typename T > 
bool WaitEvent(bool (T::*predicate)(), int timeout) { ... } 

Answer 2

당신은 그것이 올바른 유형의 구원의 자녀 객체와 그 기능 부재의 폐쇄를 할 수있는 템플릿 클래스를 사용하여 그것을 할 수 있습니다. 그리고 가상 함수를 사용하여 기본 클래스가 일반적인 다형성을 통해 호출하도록합니다.

소멸자를 호출하기 위해 shared_ptr에서도 비슷한 메커니즘이 사용됩니다. 참고 : http://channel9.msdn.com/Shows/Going+Deep/C9-Lectures-Stephan-T-Lavavej-Advanced-STL-1-of-n

#include <iostream> 

struct CPredicateBase 
{ 
     virtual ~CPredicateBase() {} 
     virtual bool operator()() = 0; 
}; 

template <class T> 
struct CPredicate : public CPredicateBase 
{ 
     bool (T::*func)(); 
     T* self; 

     CPredicate(T* self_, bool (T::*func_)()) 
     : func(func_), self(self_) {} 

     bool operator()() { return (self->*func)(); } 
}; 

class CBase 
{ 
public: 

     bool WaitEvent(CPredicateBase& predicate, int imeout) 
     { 
       /// just to show the call 
       bool b = predicate(); 
       std::cout << "WaitEvent called predicate() => " << b << std::endl; 
       return b; 
     } 
}; 


class CChildA : public CBase 
{ 
public: 
     bool a1() { return false; } 
     bool a2() { return true; } 

     void a_main() 
     { 
       std::cout << "CChildA::a_main()" << std::endl; 
       CPredicate<CChildA> caller1(this, &CChildA::a1); 
       bool ra1 = WaitEvent(caller1, 100); 
       CPredicate<CChildA> caller2(this, &CChildA::a2); 
       bool ra2 = WaitEvent(caller2, 100); 
     } 
}; 

class CChildB : public CBase 
{ 
public: 
     bool b1() { return false; } 
     bool b2() { return true; } 

     void b_main() 
     { 
       std::cout << "CChildB::b_main()" << std::endl; 
       CPredicate<CChildB> caller1(this, &CChildB::b1); 
       bool rb1 = WaitEvent(caller1, 100); 
       CPredicate<CChildB> caller2(this, &CChildB::b2); 
       bool rb2 = WaitEvent(caller2, 100); 
     } 
}; 

int main(int argc, char const* argv[]) 
{ 
     CChildA cA; 
     CChildB cB; 

     cA.a_main(); 
     cB.b_main(); 

     return 0; 
}