यह निर्धारित करना कि कोई व्युत्पन्न वर्ग बेस क्लास

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

उत्तर से कोई विधि ओवरराइड करता है उत्तर: आप नहीं कर सकते हैं।

यदि विस्तार करने के लिए कुछ भी था तो मैं विस्तार करूँगा।

Answer 2

सबसे सुरक्षित तरीका foo() को ओवरराइड नहीं कर रहा है, लेकिन बेसफैस से कॉल किए जाने वाले ऑनफू() फ़ंक्शन को ओवरराइड करने की अनुमति दें, यदि आप अपने प्रोग्रामर पर भरोसा नहीं कर सकते हैं। एमएफसी कुछ डिफ़ॉल्ट व्यवहार सुनिश्चित करने के लिए बहुत कुछ करता है (पुनरावृत्ति के खिलाफ सुरक्षा के बजाय)।

फिर, एक स्थिर स्तर पर, ऑनफू() को लागू करने वाली कुछ भी आसानी से 'फाइलों में खोजें' के साथ देखी जाती है।

उदा। ..

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

मैं भी इस प्रदान करने से नफरत है (वाक्य रचना/संकलन और नहीं threadsafe के लिए परीक्षण नहीं) लेकिन यहाँ यह

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

संपादित

है मैं साबित होता है कि यह काम करता है चाहता हूँ एमएसवीसी ++ 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 

सबूत यह हमेशा इस को

डी बदलें काम नहीं करेगा और यह काम नहीं करेगा अब

class D : public B { }; 

Answer 4

एक दृष्टिकोण foo()शुद्ध आभासी समारोह बनाने के लिए हैB, और भी इसे परिभाषित करता है। इस तरह आप सुनिश्चित करते हैं कि Bके व्युत्पन्न वर्गfoo() को परिभाषित करना चाहिए। यहाँ बी,

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; 
} 

बी के एक व्युत्पन्न वर्ग foo() को लागू नहीं करता है, तो आप भी इस तरह के व्युत्पन्न वर्ग का उदाहरण नहीं बना पा रहा है!

ideone पर पूरा काम कर कोड देखें: http://www.ideone.com/m8O2s

वैसे, मेरी निजी राय हो सकता है, वर्गों में से इस तरह के डिजाइन के साथ शुरू करने के लिए बुरा है। क्या होगा यदि आप derive class foo() से B::foo() पर कॉल करते हैं? पुनरावर्ती?

Answer 5

जैसा कि अन्य ने बताया है, ऐसा करने का कोई विश्वसनीय तरीका नहीं है। मैं आपको अपने डिजाइन पर पुनर्विचार करने का आग्रह करता हूं ...