सदस्य समारोह विरासत में नहीं मिला है?

Question

यह मेरा कोड

class B { 
public: 
    virtual void insert(int t, int p) = 0; 

    void insert(int t) { 
    insert(t, 0); 
    } 
}; 

class D : public B { 
public: 
    void insert(int t, int p) { } 

}; 

int main() { 
    D d; 
    d.insert(1); 
} 

जो संकलन नहीं होगा। निश्चित रूप से, अगर मैं मुख्य रूप से डी.बी :: डालने (1) कहूंगा, लेकिन यह गलत क्यों है? धन्यवाद।

Answer 1

मुझे पूरा यकीन है कि आपने डी में फ़ंक्शन "डालने" को फिर से परिभाषित किया है, जिसे वह कहा जाता है। कक्षा "डी" में "डालने" फ़ंक्शन को एक के बजाय दो पैरामीटर की आवश्यकता होती है। डी.बी :: डालने (1) करके, आप बी

Answer 2

में "डालने" को कॉल कर रहे हैं क्योंकि इस मामले में बेस क्लास फ़ंक्शन ओवरलोड रिज़ॉल्यूशन में शामिल नहीं हैं। इसी तरह की स्थिति आंतरिक दायरे में घोषित कार्यों के साथ है - वे बाह्य दायरे में घोषित कार्यों को अधिभारित नहीं करते हैं (नीचे उदाहरण देखें)। आप कल्पना कर सकते हैं कि व्युत्पन्न वर्ग का दायरा बेस क्लास स्कोप के अंदर घोंसला है।

एक बार संकलक D::insert उम्मीदवार पाया गया है कि यह बेस क्लास में आगे नहीं देखेगा। यदि D::insert नहीं थे तो संकलक कॉल करने के लिए insert विधि के लिए बेस क्लास देखेंगे। आप के साथ आधार वर्ग से insert फ़ंक्शन नाम शुरू करने से इसे ठीक कर सकते हैं:

using B::insert; 

इस व्युत्पन्न वर्ग में सभी B::insert अतिभारित कार्यों का परिचय देंगे। कैसे अधिक भार कार्यों के लिए

d.B::insert(1) 

---

नमूना कोड अन्य संदर्भों में एक ही तरह से:: या के रूप में आप कहते हैं, आप स्पष्ट रूप से आधार वर्ग विधि कॉल कर सकते हैं

namespace Outer { 
    void foo(double d) { 
    std::cout << "Outer::foo(double d)\n"; 
    } 
    namespace Inner { 
    //using Outer::foo; // uncomment to see "Outer::foo(double d)" in output 
    void foo(int n) { 
     std::cout << "Inner::foo(int n)\n"; 
    } 
    void callMe() { 
     foo(1.1); 
    } 
    } 
} 

int main() { 
    Outer::Inner::callMe(); // Outputes: Inner::foo(int n) 
} 

या:

void foo(std::string s) { 
    std::cout << "foo(std::string s)\n"; 
} 

void foo(double d) { 
    std::cout << "foo(double d)\n"; 
} 

void foo(int n) { 
    std::cout << "foo(int n)\n"; 
} 

int main() { 
    void foo(int d); // comment out to see foo(double d) in output 
    foo(1.1); // outputs: "foo(int n)", foo(double d) is hidden 
    //foo("hello"); // ups, it wont compile - name lookup in c++ happens before type checking 
        // commenting out `void foo(int d);` above will fix this. 
}