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


Comment puis-je appeler la fonction parent à partir d'une classe dérivée en utilisant C ++? Par exemple, j'ai une classe appelée parentet une classe appelée child qui est dérivé du parent. Dans chaque classe il y a un print fonction. Dans la définition de la fonction d'impression de l'enfant, je voudrais appeler la fonction d'impression des parents. Comment ferais-je cela?


466
2017-12-10 19:35


origine


Réponses:


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 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 points base_class::foo(...). Vous devriez noter que contrairement à Java et C #, C ++ fait ne pas avoir un mot-clé pour "la classe de base" (super ou base) depuis que le C ++ prend en charge héritage multiple ce qui peut conduire à l'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'
    }
};

Incidemment, 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
};

606
2017-12-10 19:57



Étant donné la classe parent nommée Parent et classe enfant nommée Child, vous pouvez faire quelque chose comme ça:

class Parent {
public:
    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 que Parent est le nom réel de la classe et non un mot-clé.


160
2017-12-10 19:37



Si votre classe de base est appelée Baseet votre fonction est appelée FooBar() vous pouvez l'appeler directement en utilisant Base::FooBar()

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

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

27
2017-12-10 19:40



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


17
2018-05-26 18:51



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 de membre virtuel et virtuel de la classe de base à partir de la fonction de membre dérivée peut être effectué. S'il vous plaît se 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;
}

Sortie:

$ 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

3
2017-12-25 07:46



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


-11
2018-06-02 14:07