web-dev-qa-db-fra.com

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

Comment appeler la fonction parent d'une classe dérivée à l'aide de C++? Par exemple, j'ai une classe appelée parent et une classe appelée child qui est dérivée de parent. Dans chaque classe, il existe une fonction print. Dans la définition de la fonction d'impression de l'enfant, j'aimerais appeler la fonction d'impression des parents. Comment pourrais-je m'y prendre?

c++oopinheritance
532
IaCoder

Je vais prendre le risque de dire ce qui est évident: vous appelez la fonction. Si elle est définie dans la classe de base, elle est automatiquement disponible dans la classe dérivée (à moins que ce soit privatename__).

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(...). Notez que contrairement à Java et à C #, C++ n'a pas un mot clé pour "la classe de base" (superou basename__) car C++ prend en charge 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'
    }
};

Incidemment, vous ne pouvez pas dériver directement deux fois de la même classe 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
};
676
Motti

Étant donné la classe parent nommée Parent et 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 que Parent est le nom réel de la classe et non un mot clé.

173
Greg Hewgill

Si votre classe de base s'appelle Base et que votre fonction s'appelle FooBar(), vous pouvez l'appeler directement à l'aide de Base::FooBar().

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

void ChildOfBase::FooBar()
{
  Base::FooBar();
}
30
Andrew Rollings

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 substituez.

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

Si le modificateur d'accès de la fonction membre de la classe de base est protégé OR 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 virtuel et virtuel de la classe de base à partir de la fonction 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
4
Ajay yadav

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
    }
};
1
Dean P