with - use of virtual function in c++




क्या मैं बेस क्लास के आभासी फ़ंक्शन को कॉल कर सकता हूं यदि मैं इसे ओवरराइड कर रहा हूं? (5)

इसे देखो...

#include <stdio.h>

class Base {
public:
   virtual void gogo(int a) { printf(" Base :: gogo (int) \n"); };    
   virtual void gogo1(int a) { printf(" Base :: gogo1 (int) \n"); };
   void gogo2(int a) { printf(" Base :: gogo2 (int) \n"); };    
   void gogo3(int a) { printf(" Base :: gogo3 (int) \n"); };
};

class Derived : protected Base {
public:
   virtual void gogo(int a) { printf(" Derived :: gogo (int) \n"); };
   void gogo1(int a) { printf(" Derived :: gogo1 (int) \n"); };
   virtual void gogo2(int a) { printf(" Derived :: gogo2 (int) \n"); };
   void gogo3(int a) { printf(" Derived :: gogo3 (int) \n"); };       
};

int main() {
   std::cout << "Derived" << std::endl;
   auto obj = new Derived ;
   obj->gogo(7);
   obj->gogo1(7);
   obj->gogo2(7);
   obj->gogo3(7);
   std::cout << "Base" << std::endl;
   auto base = (Base*)obj;
   base->gogo(7);
   base->gogo1(7);
   base->gogo2(7);
   base->gogo3(7);

   std::string s;
   std::cout << "press any key to exit" << std::endl;
   std::cin >> s;
   return 0;
}

उत्पादन

Derived
 Derived :: gogo (int)
 Derived :: gogo1 (int)
 Derived :: gogo2 (int)
 Derived :: gogo3 (int)
Base
 Derived :: gogo (int)
 Derived :: gogo1 (int)
 Base :: gogo2 (int)
 Base :: gogo3 (int)
press any key to exit

सबसे अच्छा तरीका बेस :: फ़ंक्शन का उपयोग @sth के रूप में कर रहा है

मान लें कि मेरे पास कक्षाएं Foo और Bar इस तरह स्थापित हैं:

class Foo
{
public:
    int x;

    virtual void printStuff()
    {
        std::cout << x << std::endl;
    }
};

class Bar : public Foo
{
public:
    int y;

    void printStuff()
    {
        // I would like to call Foo.printStuff() here...
        std::cout << y << std::endl;
    }
};

कोड में एनोटेटेड के रूप में, मैं बेस क्लास के फ़ंक्शन को कॉल करने में सक्षम होना चाहता हूं जिसे मैं ओवरराइड कर रहा हूं। जावा में super.funcname() वाक्यविन्यास है। क्या यह सी ++ में संभव है?


कभी-कभी आपको बेस क्लास 'कार्यान्वयन को कॉल करने की आवश्यकता होती है, जब आप व्युत्पन्न फ़ंक्शन में नहीं होते हैं ... यह अभी भी काम करता है:

struct Base
{
    virtual int Foo()
    {
        return -1;
    }
};

struct Derived : public Base
{
    virtual int Foo()
    {
        return -2;
    }
};

int main(int argc, char* argv[])
{
    Base *x = new Derived;

    ASSERT(-2 == x->Foo());

    //syntax is trippy but it works
    ASSERT(-1 == x->Base::Foo());

    return 0;
}

यदि आप अपनी कक्षा से बेस क्लास के फ़ंक्शन को कॉल करना चाहते हैं तो आप बेस क्लास नाम (जैसे Foo :: printStuff () ) के साथ ओवरराइड फ़ंक्शन के अंदर कॉल कर सकते हैं।

कोड यहाँ जाता है

#include <iostream>
using namespace std;

class Foo
{
public:
    int x;

    virtual void printStuff()
    {
         cout<<"Base Foo printStuff called"<<endl;
    }
};

class Bar : public Foo
{
public:
    int y;

    void printStuff()
    {
        cout<<"derived Bar printStuff called"<<endl;
        Foo::printStuff();/////also called the base class method
    }
};

int main()
{
    Bar *b=new Bar;
    b->printStuff();
}

फिर आप रनटाइम पर निर्धारित कर सकते हैं जो उस वर्ग (व्युत्पन्न या आधार) के ऑब्जेक्ट का उपयोग करके कॉल करने के लिए काम करता है। लेकिन इसके लिए बेस क्लास पर आपके फ़ंक्शन को आभासी के रूप में चिह्नित किया जाना चाहिए।

नीचे कोड

#include <iostream>
using namespace std;

class Foo
{
public:
    int x;

    virtual void printStuff()
    {
         cout<<"Base Foo printStuff called"<<endl;
    }
};

class Bar : public Foo
{
public:
    int y;

    void printStuff()
    {
        cout<<"derived Bar printStuff called"<<endl;
    }
};

int main()
{

    Foo *foo=new Foo;
    foo->printStuff();/////this call the base function
    foo=new Bar;
    foo->printStuff();
}

सी ++ वाक्यविन्यास इस तरह है:

class Bar : public Foo {
  // ...

  void printStuff() {
    Foo::printStuff(); // calls base class' function
  }
};

हाँ,

class Bar : public Foo
{
    ...

    void printStuff()
    {
        Foo::printStuff();
    }
};

यह जावा में super जैसा ही है, सिवाय इसके कि जब आप एकाधिक विरासत प्राप्त करते हैं तो यह विभिन्न अड्डों से कार्यान्वयन को कॉल करने की अनुमति देता है।

class Foo {
public:
    virtual void foo() {
        ...
    }
};

class Baz {
public:
    virtual void foo() {
        ...
    }
};

class Bar : public Foo, public Baz {
public:
    virtual void foo() {
        // Choose one, or even call both if you need to.
        Foo::foo();
        Baz::foo();
    }
};




override