web-dev-qa-db-ger.com

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 parent und eine Klasse namens child, die von parent 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 das machen?

c++oopinheritance
544
IaCoder

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, es handelt sich um private).

Wenn es in der abgeleiteten Klasse eine Funktion mit derselben Signatur gibt, können Sie sie durch Hinzufügen des Namens der Basisklasse und zwei Doppelpunkten base_class::foo(...) disambiguieren. Sie sollten beachten, dass C++ im Gegensatz zu Java und C # nicht ​​ein Schlüsselwort für "die Basisklasse" (super oder 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'
    }
};

Übrigens können Sie nicht zweimal direkt von derselben Klasse ableiten, da es nicht möglich ist, eine der Basisklassen über die andere zu verweisen.

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

Wenn Sie eine übergeordnete Klasse mit dem Namen Parent und eine untergeordnete Klasse mit dem Namen Child angeben, 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 Parent der tatsächliche Name der Klasse und kein Schlüsselwort ist.

178
Greg Hewgill

Wenn Ihre Basisklasse Base heißt und Ihre Funktion FooBar() heißt, können Sie sie direkt mit Base::FooBar() aufrufen.

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

void ChildOfBase::FooBar()
{
  Base::FooBar();
}
30
Andrew Rollings

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

MSDN: Hiermit 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)
   }
};
23
Andrey

Wenn der Zugriffsmodifikator der Elementfunktion der Basisklasse als OR public geschützt ist, können Sie die Elementfunktion der Basisklasse von der abgeleiteten Klasse aufrufen. Der Aufruf der nicht-virtuellen Basisklasse und der virtuellen Mitgliedsfunktion von der abgeleiteten Mitgliedsfunktion kann erfolgen. Bitte beachten Sie 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
4
Ajay yadav

Rufen Sie die übergeordnete Methode mit dem übergeordneten Operator für die Bereichsauflösung 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
    }
};
2
Dean P