funzioni virtuali imperativi e nascondere

Question

ho questo codice:

class Event{}; 
class CustomEvent:public Event{}; 

class Handler 
{ 
    public: 
     virtual void inform(Event e){} 
}; 

class CustomHandler : public Handler 
{ 
    public: 
    void inform(CustomEvent e){}   

}; 

CustomEvent cEvent; 
Handler* handler = new CustomHandler; 

//this calls Handler::inform(Event), not CustomHandler::(CustomEvent) , as I expected 
handler->inform(cEvent); 

Se cambio il codice a questo:

class Handler 
{ 
    public: 
     virtual void inform(Event e){} 
     virtual void inform(CustomEvent e){} 

}; 

class CustomHandler : public Handler 
{ 
    public: 
    void inform(CustomEvent e){}   

}; 

CustomEvent cEvent; 
Handler* handler = new CustomHandler; 

//this calls CustomHandler::(CustomEvent) 
handler->inform(cEvent); 

ho letto che questo sia collegato con la funzione preponderante e nascondere, ma ancora doesn' t comprendere il comportamento in questo codice.

Answer 1

sovraccarico funzione non è basato sulla runtime tipo degli argomenti (che per il vostro argomento Ecco CustomHandler*) ma piuttosto sulla loro statica tipo (che qui è Handler*, come questo è ciò che handler viene dichiarato come) .

Le funzioni virtuali consentono di effettuare chiamate di funzione in base al tipo di runtime di un oggetto (quello su cui si chiama la funzione). L'invio di chiamate in base al tipo di runtime di più oggetti è denominato invio multiplo; in questa istanza stiamo parlando del caso più comune di double dispatch. Se vuoi questo tipo di funzionalità dovrai implementare il doppio invio o usare una libreria che lo faccia per te.

Il Visitor pattern è un modo abbastanza comune di eseguire l'implementazione; vedi anche Difference betwen Visitor pattern & Double Dispatch.

Infine, è possibile trovare una buona discussione di Visitatore che include un codice di esempio (scorrere verso il basso) here.