Sovraccarico di una funzione virtuale in una classe figlia

Question

Sto testando solo con parole chiave virtuali e concetti di ereditarietà in C++. Ho scritto un piccolo programma:

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

Quello che ho fatto qui è che ho sovraccaricato una funzione virtuale nella classe genitore in classe bambino! Non è questa la cosa giusta da fare?

sto ottenendo gli errori di compilazione, come di seguito:

"temp10.cc", line 45: Error: Too many arguments in call to "cna_MO::print()".

Answer 1

volta sovraccaricate una funzione dalla classe base nella classe derivata tutte le funzioni con lo stesso nome nella classe Base vengono nascosti in classe derivata.

Dopo aver aggiunto la funzione cna_bsc::print(int a) alla classe derivata, la funzione cna_MO::::print() non è più visibile agli utenti della classe Derivata. Questo è noto come nascondiglio della funzione.

Soluzione: Al fine di rendere la funzione nascosta visibile in classe derivata, è necessario aggiungere:

using cna_MO::print; 

nella sezione public della classe derivata cna_bsc.

Buona Lettura:

What's the meaning of, Warning: Derived::f(char) hides Base::f(double)?

Answer 2

È perché la funzione di stampa nella classe bambino prende un parametro e l'originale non lo fa.

a cna_MO (classe genitore):

virtual void print() 

a cna_bsc (classe figlia):

void print(int a) 

Fondamentalmente stampa del bambino non dovrebbe prendere un argomento int:

void print() 

MODIFICA:

Forse la cosa migliore sarebbe fare passare l'int opzionale?

esempio:

a cna_MO (classe genitore):

virtual void print(int a=-1) { 
    if (a == -1) { 
     // Do something for default param 
    } else { 
     cout << a; 
    } 
} 

a cna_bsc (classe figlia):

void print(int a=-1) 

quindi se a == -1 probabilmente si può supporre, non hanno passato nulla.

Il trucco è che sia il genitore che il bambino hanno bisogno dello stesso metodo siganture, che significa lo stesso tipo di ritorno e gli stessi tipi di argomento.

Answer 3

Quando si ha una funzione con lo stesso nome e diversi parametri nella classe derivata come quella della classe base, tale funzione sarà nascosta. È possibile trovare maggiori informazioni here ..

È possibile richiamare la funzione specifica nascosto chiamando come Base::hiddenFun();

Answer 4

che non possono lavorare a causa dato un cna_MO *, si può vedere a tempo di compilazione che l'oggetto appuntito non lo fa (necessariamente) hanno il sovraccarico int. Se in realtà puntava a un oggetto di classe base, _mo->print(5); non avrebbe davvero nulla da chiamare. Inoltre, può esistere un numero infinito di classi derivate (non ancora implementate) che non devono supportare questa chiamata.

1. Ogni classe derivata deve avere print(int) - dichiararlo nella classe base.

2. Ogni classe derivata non deve avere print(int)-cna_Mo funziona solo con cna_bsc, in modo che il membro dovrebbe essere cna_bsc* _mo.

Answer 5

Idealmente la vostra stampa che prende un int dovrebbe avere un nome diverso, ma dato che si desidera entrambe le funzioni per essere chiamato di stampa, si dovrebbe fare tutti e due non virtuale e fare li chiamano funzioni virtuali protette.

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

Answer 6

se proprio deve fare in questo modo, vale a dire hanno un puntatore a una classe e inizializzare come una classe derivata, non c'è altra scelta che lanciare sempre il puntatore al tipo corretto quando lo si utilizza. In questo caso, ((cna_bsc*)_mo)->print(5);