Wie rufe ich eine übergeordnete Klassenfunktion aus einer abgeleiteten Klassenfunktion auf?

Wie rufe ich die übergeordnete Funktion aus einer abgeleiteten Klasse mit C ++ auf? Zum Beispiel habe ich eine Klasse namens parentund eine Klasse namens, childdie vom Elternteil abgeleitet ist. Innerhalb jeder Klasse gibt es eine printFunktion. Bei der Definition der Druckfunktion des Kindes möchte ich die Druckfunktion der Eltern anrufen. Wie würde ich das machen?

Ich gehe das Risiko ein, das Offensichtliche zu sagen: Sie rufen die Funktion auf, wenn sie in der Basisklasse definiert ist, ist sie automatisch in der abgeleiteten Klasse verfügbar (sofern dies nicht der Fall ist private).

Wenn die abgeleitete Klasse eine Funktion mit derselben Signatur enthält, können Sie sie eindeutig unterscheiden, indem Sie den Namen der Basisklasse gefolgt von zwei Doppelpunkten hinzufügen base_class::foo(...). Sie sollten beachten, dass C ++ im Gegensatz zu Java und C # kein Schlüsselwort für "die Basisklasse" ( superoder base) hat, da C ++ Mehrfachvererbung unterstützt, was zu Mehrdeutigkeiten führen kann.

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

Im Übrigen können Sie nicht zweimal direkt von derselben Klasse ableiten, da es keine Möglichkeit gibt, auf eine der Basisklassen über die andere zu verweisen.

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

Wenn die übergeordnete Klasse Parentund die untergeordnete Klasse benannt sind Child, können Sie Folgendes tun:

class Parent {
public:
    virtual void print(int x);
}

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

void Parent::print(int x) {
    // some default behavior
}

void Child::print(int x) {
    // use Parent's print method; implicitly passes 'this' to Parent::print
    Parent::print(x);
}

Beachten Sie, dass dies Parentder tatsächliche Name der Klasse und kein Schlüsselwort ist.

Wenn Ihre Basisklasse aufgerufen Basewird und Ihre Funktion aufgerufen wird FooBar(), können Sie sie direkt mit aufrufenBase::FooBar()

void Base::FooBar()
{
   printf("in Base\n");
}

void ChildOfBase::FooBar()
{
  Base::FooBar();
}

In MSVC gibt es dafür ein Microsoft-spezifisches Schlüsselwort: __super

MSDN: Hier können Sie explizit angeben, dass Sie eine Basisklassenimplementierung für eine Funktion aufrufen, die Sie überschreiben.

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

Wenn der Zugriffsmodifikator der Basisklassenmitgliedsfunktion geschützt ODER öffentlich ist, können Sie die Mitgliedsfunktion der Basisklasse aus der abgeleiteten Klasse aufrufen. Der Aufruf der nicht-virtuellen und virtuellen Elementfunktion der Basisklasse von der abgeleiteten Elementfunktion kann erfolgen. Bitte beziehen Sie sich auf das Programm.

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

Ausgabe:

$ 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

Rufen Sie die übergeordnete Methode mit dem übergeordneten Bereichsauflösungsoperator auf.

Parent :: method ()

class Primate {
public:
    void whatAmI(){
        cout << "I am of Primate order";
    }
};

class Human : public Primate{
public:
    void whatAmI(){
        cout << "I am of Human species";
    }
    void whatIsMyOrder(){
        Primate::whatAmI(); // <-- SCOPE RESOLUTION OPERATOR
    }
};

struct a{
 int x;

 struct son{
  a* _parent;
  void test(){
   _parent->x=1; //success
  }
 }_son;

 }_a;

int main(){
 _a._son._parent=&_a;
 _a._son.test();
}

Referenzbeispiel.