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

Question 1

Wie rufe ich die übergeordnete Funktion aus einer abgeleiteten Klasse mit C++ auf? Zum Beispiel habe ich eine Klasse namens parentund eine Klasse namens child die vom Elternteil abgeleitet ist. Innerhalb jeder Klasse gibt es eine print Funktion. In der Definition der Druckfunktion des Kindes möchte ich die Druckfunktion der Eltern aufrufen. Wie würde ich vorgehen?

Question 2

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 (es sei denn, sie ist private).

Wenn es eine Funktion mit derselben Signatur in der abgeleiteten Klasse gibt, können Sie sie eindeutig machen, indem Sie den Namen der Basisklasse gefolgt von zwei Doppelpunkten hinzufügen base_class::foo(...). Beachten Sie, dass C++ dies im Gegensatz zu Java und C# tut nicht ein Schlüsselwort für “die Basisklasse” haben (super oder base), da C++ unterstützt Mehrfachvererbung was zu Unklarheiten 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'
    }
};

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

Question 3

Bei einer übergeordneten Klasse mit dem Namen Parent und eine untergeordnete Klasse namens Childkönnen Sie so etwas 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 Parent ist der tatsächliche Name der Klasse und kein Schlüsselwort.

Question 4

Wenn Ihre Basisklasse aufgerufen wird Baseund Ihre Funktion wird aufgerufen FooBar() Sie können es direkt mit aufrufen Base::FooBar()

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

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

Question 5

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

MSDN: Ermöglicht es Ihnen, explizit anzugeben, 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)
   }
};

Question 6

Rufen Sie die übergeordnete Methode mit dem Auflösungsoperator für den übergeordneten Bereich auf.

Eltern::methode()

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

Question 7

Wenn der Zugriffsmodifikator der Elementfunktion der Basisklasse geschützt ODER öffentlich ist, können Sie die Elementfunktion 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

Question 8

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.