Comment appeler une fonction de classe parent à partir d'une fonction de classe dérivée?

Comment appeler la fonction parent à partir d'une classe dérivée à l'aide de C ++? Par exemple, j'ai une classe appelée parentet une classe appelée childqui est dérivée du parent. Dans chaque classe, il y a une printfonction. Dans la définition de la fonction d'impression de l'enfant, je voudrais appeler la fonction d'impression des parents. Comment pourrais-je procéder?

Je prendrai le risque de dire l'évidence: vous appelez la fonction, si elle est définie dans la classe de base, elle est automatiquement disponible dans la classe dérivée (sauf si elle l'est private).

S'il existe une fonction avec la même signature dans la classe dérivée, vous pouvez la désambiguïser en ajoutant le nom de la classe de base suivi de deux deux-points base_class::foo(...). Vous devez noter que contrairement à Java et C #, C ++ n'a pas de mot-clé pour "la classe de base" ( superou base) car C ++ prend en charge l' héritage multiple, ce qui peut conduire à une ambiguïté.

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

Par ailleurs, vous ne pouvez pas dériver directement de la même classe deux fois car il n'y aura aucun moyen de faire référence à l'une des classes de base par rapport à l'autre.

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

Étant donné la classe parent nommée Parentet la classe enfant nommée Child, vous pouvez faire quelque chose comme ceci:

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

Notez qu'il Parents'agit du nom réel de la classe et non d'un mot clé.

Si votre classe de base est appelée Baseet que votre fonction est appelée, FooBar()vous pouvez l'appeler directement à l'aide deBase::FooBar()

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

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

Dans MSVC, il existe un mot clé spécifique à Microsoft pour cela: __super

MSDN: vous permet d'indiquer explicitement que vous appelez une implémentation de classe de base pour une fonction que vous remplacez.

// 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 le modificateur d'accès de la fonction membre de la classe de base est protégé OU public, vous pouvez appeler la fonction membre de la classe de base à partir de la classe dérivée. L'appel à la fonction membre non virtuelle et virtuelle de la classe de base à partir de la fonction membre dérivée peut être effectué. Veuillez vous référer au programme.

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

Production:

$ 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

Appelez la méthode parent avec l'opérateur de résolution d'étendue parent.

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

Exemple de référence.