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

Comment dois-je appeler la fonction parent à partir 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 à partir de parent. Au sein de
chaque classe il y a un print fonction. Dans la définition de l'enfant, la fonction imprimer de je voudrais faire un appel aux parents de la fonction d'impression. Comment pourrais-je aller sur le faire?

  • Toutes les solutions ci-dessus sont en supposant que votre fonction d'impression est une méthode statique. Est-ce le cas? Si la méthode n'est pas statique, puis les solutions ci-dessus ne sont pas pertinents.
  • hhafez, vous vous trompez de la base::fonction() syntaxe ressemble à la méthode statique la syntaxe d'appel, mais il fonctionne pour les méthodes d'instance dans ce contexte.
  • Je ne voudrais pas utiliser le MSVC __super car il est la plate-forme. Bien que votre code peut ne pas fonctionner sur une autre plate-forme, j'utiliserais d'autres suggestions, car ils le font comme la langue voulue.
  • Double Possible de puis-je appeler une classe de base virtuelle de la fonction si je suis remplaçant?
  • Le antipattern où les classes dérivées doivent toujours appeler le parent de la classe de fonctions Call super
InformationsquelleAutor IaCoder | 2008-12-10
  1. 684

    Je vais prendre le risque d'énoncer une évidence: Vous appelez la fonction, si elle est définie dans la classe de base, il est automatiquement disponible dans la classe dérivée (à moins qu'il private).

    Si il existe une fonction avec la même signature dans la classe dérivée, vous pouvez lever l'ambiguïté en ajoutant la base du nom de la classe suivi de deux-points base_class::foo(...). Vous devriez noter que, contrairement à Java et C#, C++ ne pas un mot clé pour "la classe de base" (super ou base) depuis C++ prend en charge l'héritage multiple 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'
    }
};

    D'ailleurs, vous ne peut pas dériver directement à partir de la même classe que deux fois depuis qu'il n'y aura aucun moyen de se référer à l'une des classes de base sur les autres.

    class bottom : public left, public left { //Illegal
};
    • Pourquoi voudriez-vous hériter de la même classe deux fois ?
    • dans le classique de la programmation orientée objet il ne fait pas beaucoup de sens, mais dans la programmation générique template<class A, class B> class C: public A, public B {}; peut provenir de deux types de la même, pour des raisons, selon la façon dont votre code est utilisé (qui fait que A et B à la même), peut-être deux ou trois couche d'abstraction manière de quelqu'un pas au courant de ce que vous avez fait.
    • Je pense qu'il est utile d'ajouter, que cela va appeler le parent de la classe de méthode, même si elle n'est pas directement mis en œuvre dans la classe parente, mais est mis en œuvre dans l'une des classes parent dans la chaîne d'héritage.
    • que faire si le parent méthode utilise ce?
    • si la classe de base utilise ensuite, il fonctionne normalement pour les méthodes ordinaires et supprime dynamique invocation pour virtual méthodes.
    • Sur une note, il m'a rendu fou quand j'ai essayé de mettre ça dans un fichier cpp. J'avais "using namespace std'. 'gauche' est défini quelque part dans cet espace de noms. L'exemple ne serait pas de la compilation m'a rendu fou 🙂 . Puis j'ai changé "de gauche" à la "Gauche". Excellent exemple par la manière.
    • Et c'est pourquoi vous n'êtes pas censé utiliser using namespace std.
    • +1 pour dire You should note that unlike Java and C#, C++ does not have a keyword for "the base class".
    • Vous pouvez ajouter typedef left super; dans votre classe, si vous voulez, alors vous pouvez vous référer à super::foo();. Et puisque vous ne peut pas dériver de la même classe deux fois directement, vous devez le faire indirectement struct left1 : left{}; struct left2 : left{}; class bottom : public left1, public left2 { ... }; mais vous êtes probablement mieux d'utiliser la composition plutôt que de l'héritage.
    • ce qui va se passer si toto est une fonction virtuelle dans les deux classes de base ?

    InformationsquelleAutor Motti
  2. 174

    Donné parent classe nommée Parent et de l'enfant classe 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);
}

    Noter que Parent est la classe du nom réel et pas un mot-clé.

    • Bien sûr, ce ne serait utile que si la base d'appels ont été intercalés avec d'autres logiques, sinon il n'y aurait aucune raison de substitution de la fonction, donc c'est peut-être un peu aussi pour le point 😉
    • en fait, son utilité, même si la base d'appel n'a pas été intercalés avec d'autres logiques. Disons que la classe parente assez bien fait tout ce que vous voulez, mais expose une méthode foo (), vous ne voulez pas que les utilisateurs de l'enfant à l'utiliser, soit parce foo() est sans enfant ou les appelants externes à l'enfant vis jusqu'à ce que l'enfant est en train de faire. Donc, l'enfant peut utiliser parent::foo() dans certaines situations, mais de fournir une implémentation de foo afin qu'ils se cachent parent foo() est appelée.
    • Semble intéressant, mais désolé, je ne suis pas le saisissant encore. Est foo() ici analogue à print() ou une fonction distincte? Et voulez-vous dire par l'utilisation de private héritage pour masquer les détails hérité de la base, et de fournir public l'occultation des fonctions pour les choses que vous ne souhaitez exposer?
    • Oui, foo() était analogue à print(). Permettez-moi de revenir en arrière à l'aide de print() car je pense que cela aurait plus de sens dans ce contexte. Disons que quelqu'un a créé une classe qui a effectué une série d'opérations sur un type de données particulier, ont exposé certains des accesseurs, et a eu un print(obj&) méthode. J'ai besoin d'une nouvelle classe qui travaille sur array-of-obj mais tout le reste est le même. Composition les résultats dans beaucoup de code dupliqué. L'héritage minimise que, dans print(array-of-obj&) boucle d'appel print(obj&), mais ne veulent pas les clients à appeler print(obj&) parce que ne fait pas sens pour eux de le faire
    • Cette perspective repose sur l'hypothèse que je ne peux pas refactoriser les parties communes de l'original de la classe parent ou que cela est incroyablement coûteux. Privé de l'héritage pourrait fonctionner, mais alors vous perdez le public accesseurs qui vous ont été en s'appuyant sur la - et serait donc besoin de dupliquer le code.
    InformationsquelleAutor Greg Hewgill
  3. 30

    Si votre classe de base est appelé Base, et 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();
}
    InformationsquelleAutor Andrew Rollings
  4. 22

    Dans MSVC Microsoft a un mot-clé spécifique pour que: __super

    MSDN:
    Vous permet de préciser explicitement que vous appelez une classe de base de la mise en œuvre d'une fonction qui vous sont prépondérantes. 

    //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)
   }
};
    • Cela fonctionne si les fonctions sont virtuel trop. Astuce sympa.
    • Eh, je préfère typdefing la société mère, quelque chose comme super.
    • Je ne vais pas essayer de justifier l'utilisation de __super; je l'ai mentionné ici comme une alternative de la suggestion. Les développeurs doivent connaître leurs compilateur et de comprendre les avantages et les inconvénients de ses capacités.
    • Je préfère décourager quiconque de l'utiliser, car elle entrave gravement la portabilité du code.
    • Je ne suis pas d'accord avec Andrey: les Développeurs doivent connaître les normes et ne devrait pas besoin de s'embêter avec les fonctions du compilateur, si l'on considère l'écriture de logiciels qui est principalement compilateur indépendant, ce qui je pense est une bonne idée de toute façon parce que tôt ou tard, dans les grands projets de plusieurs compilateurs sont de toute façon utilisé.
    • Je préfère ni l'un ni l'parce que le C++ n'est pas Java, et ce n'est pas vraiment difficile de se rappeler le nom de la mère, et en plus c'est obligatoire si vous utilisez MI.
    • "les Développeurs doivent connaître leurs compilateur" ce raisonnement, et l'inclusion de caractéristiques non standard, est ce qui a conduit à IE6...
    • C'est une très mauvaise idée, toujours essayer d'éviter de compilateur caractéristiques spécifiques, ou c'est vraiment nécessaire, les utiliser à l'intérieur de #définit où yoou peut gérer le standard et non standard.
    • Je vais aller à l'encontre des commentaires et de voter en faveur de __super. C'est agréable et simple, et pour les 99,9% de code qui est SAIN d'esprit et ne pas utiliser l'héritage multiple, il n'y a pas de problème avec elle. Spécifiant explicitement la classe de base a donné lieu à de multiples difficile à diagnostiquer horribles bugs dans notre base de code tout au long des années, où les gens se retrouvent accidentellement allant directement à partir de Level3->Niveau 1 et le saut de l'Level2 classe dans le milieu; __super empêche cela. Aussi code portable, c'est un bon point, mais pas tout le code se soucie d'être portable
    • exactement pour que le code avec seulement un héritage __super n'est pas d'ajouter des fonctionnalités, parce que vous pouvez mettre le nom que la classe explicitement (ou obtenir l'habitude de faire typedef Parent super juste après la déclaration de classe si vous souhaitez écrire super): c'est le but principal est de l'envoi de l'appel de fonction à l'un des deux super-classes lorsqu'une méthode pourrait être dans l'un ou l'autre (c'est à dire, mixin scénario). Sacrifier la conformité à la norme peut être justifiée si vous l'avez explicitement besoin de cette fonctionnalité, pas pour les paresseux.
    • eh bien, toujours faire appel à Level2 méthodes de Niveau 3 et vous serez amende

    InformationsquelleAutor Andrey
  5. 4

    Si modificateur d'accès de la classe de base de la fonction publique OU protégée, vous pouvez faire appel de la fonction membre de la classe de base de la classe dérivée.
    Appel à la classe de base non-virtuelle et de la fonction membre virtuelle à partir des dérivées de la fonction de membre peut être faite.
    Veuillez consulter le 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;
}

    De 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
    InformationsquelleAutor Ajay yadav
  6. 2

    Appel de la méthode parent avec le parent de l'opérateur de résolution de portée.

    Parent::methode()

    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
    }
};
    InformationsquelleAutor Dean P
  7. -13
    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.

    • Pourriez vous s'il vous plaît modifier dans une explication du pourquoi/comment ce code répond à la question? Code-seules réponses sont découragés, car ils ne sont pas aussi facile à apprendre que le code avec une explication. Sans une explication, il prend beaucoup plus de temps et d'efforts pour comprendre ce qui était fait, les modifications apportées au code, ou si le code est utile. L'explication est important à la fois pour les personnes qui tentent d'apprendre à partir de la réponse et de ceux de l'évaluation de la réponse pour voir si elle est valide, ou d'une valeur allant jusqu'à droit de vote.
    • Cette réponse, c'est sur les classes imbriquées alors que la question portait sur les classes dérivées (même si les mots "parent" et "enfant" sont un peu missleading) et, par conséquent, ne répond pas à la question.
    InformationsquelleAutor user2170324