Surcharge d'une fonction virtuelle dans une classe enfant

Je suis juste tester avec mot-clé virtuel et concepts héritage en c++.
J'ai écrit un petit programme:

#include<stdio.h>
#include<iostream>

using namespace std;

class cna_MO
{
  public:
    virtual void print()
    {
        cout << "cna_MO" << endl;
    }
};

class cna_bsc:public cna_MO
{
  public:
    void print()
    {
        cna_MO::print();
    }

    void print(int a)
    {
        cout << "cna_BSC" << endl;
    }
};

class cna_Mo
{
    cna_MO *_mo;

  public:
    cna_Mo()
    {
        _mo = new cna_bsc;
    }

    virtual void print(int a)
    {
        cout << "cna_Mo with arg" << endl;
        _mo->print(5);
    }

    virtual void print()
    {
        cout << "cna_Mo" << endl;
        _mo->print();
    }
};

int main()
{
    cna_Mo valid_mo;
    cout << "old case is started" << endl;
    valid_mo.print();
    cout << "new case is started" << endl;
    valid_mo.print(5);
    return 0;
}

Ce que j'ai fait ici est que j'ai surchargé d'une fonction virtuelle dans la classe parent de l'enfant de la classe! Ce n'est pas la bonne chose à faire?

J'obtiens les erreurs de compilation, comme ci-dessous:

"temp10.cc", la ligne 45: Erreur: Trop d'arguments dans l'appel à "cna_MO::print()".

source d'informationauteur Vijay

c++inheritance virtual

23

Une fois que vous surcharger une fonction de la classe de Base dans la classe Dérivée de toutes les fonctions avec le même nom dans la classe de Base se cachent dans la classe Dérivée.

Une fois que vous avez ajouté la fonction cna_bsc::print(int a) de votre classe dérivée de la fonction cna_MO::::print() n'est plus visible pour les utilisateurs de la classe Dérivée. Ceci est connu comme la fonction de masquage.

Solution:
Afin de rendre la fonction cachée visible dans la classe dérivée, Vous devez ajouter:
```
using cna_MO::print;
```
dans le public section de votre classe dérivée de cna_bsc.

Bonne Lecture:

Quel est le sens de l'Avertissement: Dérivé::f(char) cache de la Base::f(double)?
0

Lorsque vous avez une fonction avec le même nom et des paramètres différents dans la classe dérivée de celle de la classe de base, alors que la fonction sera caché. Vous pouvez trouver plus d'info ici..

Vous pouvez appeler le caché de la fonction en appelant comme Base::hiddenFun();
0

C'est parce que la fonction d'impression dans la classe enfant prend un paramètre et l'original ne l'est pas.

dans cna_MO (classe mère):
```
virtual void print()
```
dans cna_bsc (enfant de la classe):
```
void print(int a)
```
Fondamentalement de l'enfant d'impression ne devrait pas prendre d'argument int:
```
void print()
```
EDIT:

Peut-être que le mieux serait de faire passer l'int option ?

par exemple:

dans cna_MO (classe mère):
```
virtual void print(int a=-1) {
    if (a == -1) {
        //Do something for default param
    } else {
        cout << a;
    }
}
```
dans cna_bsc (enfant de la classe):
```
void print(int a=-1)
```
donc si a == -1 vous pouvez probablement prendre, ils n'ont pas passer n'importe quoi.

Le truc, c'est que à la fois le parent et l'enfant ont besoin de la même méthode siganture, le sens même type de retour et les mêmes types d'arguments.

Idéalement, votre impression qui prend un int doit avoir un nom différent, mais étant donné que vous souhaitez à la fois des fonctions d'être appelé d'impression, vous devez faire les deux non-virtuel et de faire appel protégés des fonctions virtuelles.

class cna_MO 
{   
    public:     
     void print() { doPrint(); }

    protected:
     virtual void doPrint()
      {         cout << "cna_MO" << endl;     
      } 
};  


class cna_bsc:public cna_MO 
{   
    protected:     
       virtual void doPrint()  
                  //although with implementation no need to override it
       {         
            cna_MO::print();     
       } 

    public:
     void print(int a)    
      {
          doPrintInt( a );
      }

    protected:
      virtual void doPrintInt( int )
      {
        cout << "cna_BSC" << endl;     
      } 
 };

0

Si vous DEVEZ VRAIMENT le faire comme cela, c'est à dire un pointeur vers une classe et l'initialisation d'une classe dérivée, il n'y a pas de choix mais toujours fonte le pointeur vers le type correct lorsque vous l'utilisez. Dans ce cas, ((cna_bsc*)_mo)->print(5);
0

Qui ne peuvent pas travailler, parce qu'étant donné un cna_MO *vous pouvez voir au moment de la compilation que l'objet pointé n'est pas (nécessairement) ont l'int de surcharge. Si elle a effectivement fait remarquer à un de la classe de base de l'objet, _mo->print(5); aurait vraiment rien d'appel. Il peut aussi y avoir un nombre infini de (non encore implémenté) les classes dérivées qui n'ont pas à soutenir cet appel.
1. Chaque classe dérivée doit avoir print(int) - déclarer dans la classe de base.
2. Chaque classe dérivée n'a pas besoin d'avoir print(int) - cna_Mo ne fonctionne qu'avec cna_bscde sorte que le membre doit être cna_bsc* _mo.

Vous devez vous connecter pour publier un commentaire.