Określanie, czy klasa pochodna zastępuje metodę z klasy bazowej

Question

class B { 
virtual int foo(); 
}; 

class D : public B { 
virtual int foo() { cout<<"D\n"; } 
}; 

int B::foo() 
{ 
    /* how do i tell if this->foo() is overridden by a subclass, or if it will */ 
    /* simply recurse into B::foo()? */ 
    this->foo(); 
} 

main() 
{ 
D d; 
d.B::foo(); 
} 

Answer 1

Odpowiedź: nie można.

Zostałabym rozwinięta, gdyby było coś do rozszerzenia.

Answer 2

Najbezpieczniejszym sposobem jest nie przesłonięcie foo() w ogóle, ale pozwalają na nadpisanie funkcji OnFoo(), która jest wywoływana z baseclass, jeśli nie możesz ufać swoim programistom. MFC robi to dużo, aby zapewnić pewne domyślne zachowanie (zamiast chronić się przed powtarzaniem).

Następnie, również na poziomie statycznym, wszystko, co implementuje OnFoo(), jest łatwo zauważalne dzięki "Znajdź w plikach".

E.g. (Nie testowane na składni/kompilacji i nie THREADSAFE)

class B 
{ 
public: 
    B() 
    { 
     m_bInFoo=false; 
    } 

    int foo() 
    { 
     if(!m_bInFoo) 
     { 
      m_bInFoo=true; 

      int nRet = OnFoo(); 

      m_bInFoo=false; 

      return nRet; 
     } 

     return 0;// probably throw exception 
    } 

protected: 
    // inherited classes override OnFoo(), and never call OnFoo(); 
    virtual int OnFoo(){ return 0 }; 

private: 
    bool m_bInFoo; 
} 

Answer 3

Nienawidzę nawet zapewniając tym .. ale tutaj jest

int B::foo() 
{ 
std::cout << "B" << std::endl; 
if (typeid (*this) != typeid(B)) 
    this->foo(); 
return 0; 
} 

Edit

Chcę udowodnić, że to działa w MSVC++ 2010.

#include "stdafx.h" 
#include <iostream> 

class B { 
public: 
virtual int foo(); 
}; 

class D : public B { 
public: 
virtual int foo() { 
    std::cout<<"D\n"; return 0; 
} 
}; 

int B::foo() 
{ 
std::cout << "B" << std::endl; 

/* how do i tell if this->foo() is overridden by a subclass, or if it will */ 
/* simply recurse into B::foo()? */ 
if (typeid (*this) != typeid(B)) 
    this->foo(); 

return 0; 
} 


int main(int argc, _TCHAR* argv[]) 
{ 
D d; 
d.B::foo(); 

B b; 
b.foo(); 
return 0; 
} 

Ou tput

B 
D 
B 

Dowód, że nie zawsze będzie działać

Zmień D do tego i nie będzie już pracować

class D : public B { }; 

Answer 4

Jednym ze sposobów jest, aby foo()czystą funkcję wirtualną w B, i również go definiują. W ten sposób upewnisz się, że klasy pochodne muszą zdefiniować B zdefiniować foo(). Oto B,

class B 
{ 
public: 
     virtual int foo() = 0; //pure virtual function 
}; 

//pure virtual function also has a default implementation! 
int B::foo() 
{ 
     std::cout << "B" << std::endl; 
     this->foo(); //this will call the overridden foo() in the derived class! 
     return 0; 
} 

Jeśli klasa pochodzi od B nie realizuje foo(), to nie można nawet utworzyć instancję tej klasy pochodnej!

Zobacz pełny kod pracujący w ideone: http://www.ideone.com/m8O2s

Nawiasem mówiąc, moja osobista opinia byłby taki projekt zajęć jest zły na początek. Co jeśli zadzwonisz pod numer B::foo() z klasy pochodnej foo()? Rekurencyjny?

Answer 5

Jak inni podkreślili, nie ma niezawodnego sposobu, aby to zrobić. Zachęcam do przemyślenia swojego projektu ...