Come chiamare una funzione di classe genitore dalla funzione di classe derivata?

Come posso chiamare la funzione genitore da una classe derivata usando C ++? Ad esempio, ho una classe chiamata parente una classe chiamata childche deriva dal genitore. All'interno di ogni classe c'è una printfunzione. Nella definizione della funzione di stampa del bambino vorrei fare una chiamata alla funzione di stampa dei genitori. Come potrei fare per fare questo?

Prenderò il rischio di affermare l'ovvio: chiamate la funzione, se è definita nella classe base è automaticamente disponibile nella classe derivata (a meno che non sia private).

Se esiste una funzione con la stessa firma nella classe derivata, è possibile chiarirla aggiungendo il nome della classe base seguito da due due punti base_class::foo(...). Dovresti notare che, diversamente da Java e C #, C ++ non ha una parola chiave per "la classe base" ( supero base) poiché C ++ supporta l'ereditarietà multipla che può portare ad ambiguità.

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

Per inciso, non puoi derivare direttamente dalla stessa classe due volte poiché non ci sarà modo di fare riferimento a una delle classi di base sull'altra.

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

Data la classe genitore denominata Parente la classe figlio denominata Child, puoi fare qualcosa del genere:

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

Nota che Parentè il nome effettivo della classe e non una parola chiave.

Se viene chiamata la tua classe base Base tua funzione FooBar(), puoi chiamarla direttamente usandoBase::FooBar()

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

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

In MSVC esiste una parola chiave specifica per Microsoft: __super

MSDN: consente di dichiarare esplicitamente che si sta chiamando un'implementazione di classe base per una funzione che si sta sovrascrivendo.

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

Se il modificatore di accesso della funzione membro della classe base è protetto O pubblico, è possibile chiamare la funzione membro della classe base dalla classe derivata. È possibile effettuare la chiamata alla funzione membro non virtuale e virtuale della classe base dalla funzione membro derivata. Si prega di fare riferimento al programma.

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

Produzione:

$ 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

Chiamare il metodo parent con l'operatore di risoluzione dell'ambito parent.

Parent :: metodo ()

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

Esempio di riferimento