¿Cómo llamar a una función de clase primaria desde una función de clase derivada?

¿Cómo llamo a la función padre desde una clase derivada usando C ++? Por ejemplo, tengo una clase llamada parent, y una clase llamada childque se deriva de padre. Dentro de cada clase hay una printfunción. En la definición de la función de impresión del niño, me gustaría llamar a la función de impresión de los padres. ¿Cómo haría para hacer esto?

Me arriesgaré a decir lo obvio: llama a la función, si está definida en la clase base, está automáticamente disponible en la clase derivada (a menos que sea private).

Si hay una función con la misma firma en la clase derivada, puede desambiguarla agregando el nombre de la clase base seguido de dos puntos base_class::foo(...). Debe tener en cuenta que, a diferencia de Java y C #, C ++ no tiene una palabra clave para "la clase base" ( supero base) ya que C ++ admite la herencia múltiple, lo que puede generar ambigüedad.

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

Por cierto, no puede derivar directamente de la misma clase dos veces, ya que no habrá forma de referirse a una de las clases base sobre la otra.

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

Dada la clase principal llamada Parenty la clase secundaria nombrada Child, puede hacer algo como esto:

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

Tenga en cuenta que Parentes el nombre real de la clase y no una palabra clave.

Si se llama a su clase base y se llama a Basesu función FooBar(), puede llamarla directamente usandoBase::FooBar()

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

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

En MSVC hay una palabra clave específica de Microsoft para eso: __super

MSDN: le permite declarar explícitamente que está llamando a una implementación de clase base para una función que está anulando.

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

Si el modificador de acceso de la función miembro de la clase base está protegido O público, puede llamar a la función miembro de la clase base desde la clase derivada. Se puede realizar una llamada a la función miembro no virtual y virtual de la clase base desde la función miembro derivada. Por favor, consulte el 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;
}

Salida:

$ 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

Llame al método principal con el operador de resolución de alcance principal.

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

Ejemplo de referencia