Como chamar uma função de classe pai da função de classe derivada?

Como chamo a função pai de uma classe derivada usando C ++? Por exemplo, eu tenho uma classe chamada parente uma classe chamada childderivada do pai. Dentro de cada classe há uma printfunção. Na definição da função de impressão da criança, gostaria de fazer uma chamada para a função de impressão dos pais. Como eu faria isso?

Eu correrei o risco de declarar o óbvio: você chama a função, se definida na classe base, está automaticamente disponível na classe derivada (a menos que seja private).

Se houver uma função com a mesma assinatura na classe derivada, você pode desambiguá-la adicionando o nome da classe base seguido por dois pontos base_class::foo(...). Observe que, diferentemente de Java e C #, o C ++ não possui uma palavra-chave para "a classe base" ( superou base), pois o C ++ suporta herança múltipla, o que pode levar à ambiguidade.

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

Aliás, você não pode derivar diretamente da mesma classe duas vezes, pois não haverá como se referir a uma das classes base sobre a outra.

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

Dada a classe pai nomeada Parente a classe filho nomeada Child, você pode fazer algo assim:

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

Observe que Parenté o nome real da classe e não uma palavra-chave.

Se sua classe base é chamada Basee sua função é chamada, FooBar()você pode chamá-la diretamente usandoBase::FooBar()

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

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

No MSVC, existe uma palavra-chave específica da Microsoft para isso: __super

MSDN: permite declarar explicitamente que você está chamando uma implementação de classe base para uma função que você está substituindo.

// 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 o modificador de acesso da função de membro da classe base estiver protegido OU público, você poderá chamar a função de membro da classe base da classe derivada. É possível chamar a função de membro não virtual e virtual de classe base da função de membro derivada. Por favor, consulte o programa.

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

Resultado:

$ 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

Chame o método pai com o operador de resolução de escopo pai.

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

Exemplo de referência.