Determinar si una clase derivada anula un método de una clase base

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

Respuesta: no se puede.

Expandiría si hubiera algo para expandir.

Answer 2

La forma más segura es no anular foo() en absoluto, pero permitir la anulación de una función OnFoo() que se llama desde la clase base si no puede confiar en sus programadores. MFC hace mucho de esto para garantizar un comportamiento predeterminado (en lugar de proteger contra la recurrencia).

Luego, también en un nivel estático, todo lo que implementa OnFoo() se detecta fácilmente con un 'Buscar en archivos'.

E.g. (No probado para la sintaxis/compilación y no-hilo)

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

siquiera me gusta la prestación de este .. pero aquí es

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

Editar

Quiero demostrar que funciona en 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 

prueba no siempre funcionará

Cambio D para esto y no va a funcionar más

class D : public B { }; 

Answer 4

Un enfoque es hacer foo()función virtual pura en B, y también lo definen. De esta manera, asegúrese de que las clases derivadas de Bdeben definir foo(). Aquí es 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; 
} 

Si una clase derivada de B no implementa foo(), entonces ni siquiera se puede crear una instancia de esa clase derivada!

ver el código completo de trabajo en Ideone: http://www.ideone.com/m8O2s

Por cierto, mi opinión personal sería, como el diseño de las clases es malo para empezar. ¿Qué sucede si llama al B::foo() desde la clase derivada foo()? Recursivo?

Answer 5

Como han señalado otros, no hay una manera confiable de hacerlo. Le insto a que reconsidere su diseño ...