c++ - व्युत्पन्न वर्ग फ़ंक्शन से अभिभावक वर्ग फ़ंक्शन को कैसे कॉल करें?




oop inheritance (4)

मैं सी ++ का उपयोग कर व्युत्पन्न वर्ग से अभिभावक फ़ंक्शन को कैसे कॉल करूं? उदाहरण के लिए, मेरे पास parent नामक एक वर्ग है, और एक वर्ग जिसे child कहा जाता है जो माता-पिता से लिया गया है। प्रत्येक वर्ग के भीतर एक print फ़ंक्शन होता है। बच्चे के प्रिंट फ़ंक्शन की परिभाषा में मैं माता-पिता प्रिंट फ़ंक्शन पर कॉल करना चाहता हूं। मैं ऐसा कैसे कर पाऊंगा?


बच्चे के नाम पर Parent और बाल वर्ग नामित अभिभावक वर्ग को देखते हुए,

आप ऐसा कुछ कर सकते हैं:

void Child::print(int x) {
    Parent::print(x);
}

मैं स्पष्ट बताए जाने का जोखिम उठाऊंगा: आप फ़ंक्शन को कॉल करते हैं, यदि इसे बेस क्लास में परिभाषित किया गया है तो यह व्युत्पन्न कक्षा में स्वचालित रूप से उपलब्ध है (जब तक कि यह private न हो)।

यदि व्युत्पन्न कक्षा में एक ही हस्ताक्षर के साथ कोई फ़ंक्शन है, तो आप बेस क्लास के नाम को दो कॉलन base_class::foo(...) द्वारा जोड़कर इसे base_class::foo(...) । आपको ध्यान रखना चाहिए कि जावा और सी # के विपरीत, सी ++ में "बेस क्लास" ( super या base ) के लिए कोई कीवर्ड नहीं है क्योंकि सी ++ एकाधिक विरासत का समर्थन करता है जो अस्पष्टता का कारण बन सकता है।

class left {
public:
    void foo();
};

class right {
public:
    void foo();
};

class bottom : public left, public right {
public:
    void foo()
    {
        //base::foo();// ambiguous
        left::foo();
        right::foo();

        // and when foo() is not called for 'this':
        bottom b;
        b.left::foo();  // calls b.foo() from 'left'
        b.right::foo();  // call b.foo() from 'right'
    }
};

संयोग से, आप एक ही कक्षा से सीधे दो बार नहीं प्राप्त कर सकते हैं क्योंकि दूसरे के आधारभूत वर्गों में से किसी एक को संदर्भित करने का कोई तरीका नहीं होगा।

class bottom : public left, public left { // Illegal
};

यदि बेस क्लास सदस्य फ़ंक्शन का एक्सेस संशोधक सुरक्षित है या सार्वजनिक है, तो आप व्युत्पन्न कक्षा से बेस क्लास के कॉल सदस्य फ़ंक्शन कर सकते हैं। व्युत्पन्न सदस्य फ़ंक्शन से बेस क्लास गैर वर्चुअल और आभासी सदस्य फ़ंक्शन को कॉल किया जा सकता है। कृपया कार्यक्रम देखें।

#include<iostream>
using namespace std;

class Parent
{
  protected:
    virtual void fun(int i)
    {
      cout<<"Parent::fun functionality write here"<<endl;
    }
    void fun1(int i)
    {
      cout<<"Parent::fun1 functionality write here"<<endl;
    }
    void fun2()
    {

      cout<<"Parent::fun3 functionality write here"<<endl;
    }

};

class Child:public Parent
{
  public:
    virtual void fun(int i)
    {
      cout<<"Child::fun partial functionality write here"<<endl;
      Parent::fun(++i);
      Parent::fun2();
    }
    void fun1(int i)
    {
      cout<<"Child::fun1 partial functionality write here"<<endl;
      Parent::fun1(++i);
    }

};
int main()
{
   Child d1;
   d1.fun(1);
   d1.fun1(2);
   return 0;
}

आउटपुट:

$ g++ base_function_call_from_derived.cpp
$ ./a.out 
Child::fun partial functionality write here
Parent::fun functionality write here
Parent::fun3 functionality write here
Child::fun1 partial functionality write here
Parent::fun1 functionality write here

एमएसवीसी में इसके लिए एक माइक्रोसॉफ्ट विशिष्ट कीवर्ड है: __super

एमएसडीएन: आपको स्पष्ट रूप से यह बताने की अनुमति देता है कि आप उस फ़ंक्शन के लिए बेस-क्लास कार्यान्वयन को कॉल कर रहे हैं जिसे आप ओवरराइड कर रहे हैं।

// deriv_super.cpp
// compile with: /c
struct B1 {
   void mf(int) {}
};

struct B2 {
   void mf(short) {}

   void mf(char) {}
};

struct D : B1, B2 {
   void mf(short) {
      __super::mf(1);   // Calls B1::mf(int)
      __super::mf('s');   // Calls B2::mf(char)
   }
};




inheritance