Perché utilizzare le funzioni virtuali?

Question

Eventuali duplicati:
Can someone explain C++ Virtual Methods?

Ho una domanda per quanto riguarda alle funzioni virtuali del C++.

Perché e quando utilizziamo funzioni virtuali? Qualcuno può darmi un'implementazione in tempo reale o l'uso di funzioni virtuali?

Answer 1

Si utilizzano funzioni virtuali quando si desidera eseguire l'override di un determinato comportamento (metodo di lettura) per la classe derivata anziché quella implementata per la classe base e si desidera farlo in fase di esecuzione tramite un puntatore alla classe di base .

L'esempio classico è quando si ha una classe di base denominata Shape e concrete forme (classi) che ne derivano. Ogni classe concreta esegue l'override (implementa un metodo virtuale) chiamato Draw().

La gerarchia di classi è come segue:

Il seguente frammento illustra l'utilizzo dell'esempio; crea una serie di puntatori di classe Shape in cui ognuno punta a un oggetto di classe derivata distinto. In fase di esecuzione, il richiamo del metodo Draw() determina la chiamata del metodo sottoposto a override da quella classe derivata e il particolare Shape viene disegnato (o reso).

Shape *basep[] = { &line_obj, &tri_obj, 
        &rect_obj, &cir_obj}; 
for (i = 0; i < NO_PICTURES; i++) 
    basep[i] -> Draw(); 

Il programma sopra utilizza solo il puntatore alla classe base per memorizzare gli indirizzi degli oggetti classe derivata. Questo fornisce un accoppiamento lasco perché il programma non ha bisogno di cambiare drasticamente se si aggiunge ogni volta che una nuova classe derivata concreta di shape. La ragione è che vi sono segmenti di codice minimi che utilizzano effettivamente (dipendono) sul Shape tipo concreto.

Quanto sopra è un buon esempio del Open Closed Principle dei famosi principi di progettazione SOLID.

Answer 2

Si utilizzerà una funzione virtuale per implementare il "polimorfismo", in particolare dove si dispone di un oggetto, non si conosce l'effettivo tipo sottostante, ma si sa quale operazione si desidera eseguire su di esso e l'implementazione di questo (come lo fa) si differenzia a seconda del tipo che hai effettivamente.

In sostanza quello che viene comunemente chiamato il "principio di sostituzione di liskov", dal nome Barbara Liskov che ha parlato di questo intorno 1983.

Dove è necessario utilizzare le decisioni di esecuzione dinamici in cui, in corrispondenza del punto è chiamato il codice invocando la funzione , non sai quali tipi possono passare attraverso di esso, ora o in futuro, questo è un buon modello da usare.

Tuttavia, non è l'unico modo. Esistono tutti i tipi di "callback" che possono richiedere un "blob" di dati e potresti avere tabelle di callback dipendenti da un blocco di intestazione nei dati che arrivano, ad es. un processore di messaggi. Per questo non c'è bisogno di usare una funzione virtuale, infatti quello che probabilmente usereste è l'ordinamento di come una v-table è implementata solo con una voce (ad esempio una classe con una sola funzione virtuale).

Answer 3

Pensate classe di animali, e che ne derivano sono gatto, cane e mucca.Classe animale ha un

virtual void SaySomething() 
{ 
    cout << "Something"; 
} 

funzione.

Invece di stampare "Qualcosa", il cane dovrebbe dire "Abbaio", il gatto dovrebbe dire "Meow". In questo esempio vedi che a is a Dog, ma ci sono delle volte in cui hai un puntatore di animale e non sai quale animale sia. Non vuoi sapere quale animale sia, vuoi solo che l'animale dica qualcosa. Quindi chiami semplicemente funzione virtuale e i gatti diranno "miagolare" e i cani diranno "abbaia".

Ovviamente, la funzione SaySomething avrebbe dovuto essere pura virtuale per evitare possibili errori.

Answer 4

Si utilizzano le funzioni virtuali quando è necessario gestire oggetti diversi nello stesso modo. Si chiama polimorfismo. Immaginiamo di avere una certa classe di base - qualcosa come forma classica:

class Shape 
    { 
     public: 
      virtual void draw() = 0; 
      virtual ~Shape() {} 
    }; 

    class Rectange: public Shape 
    { 
     public: 
      void draw() { // draw rectangle here } 
    }; 


    class Circle: public Shape 
    { 
     public: 
      void draw() { // draw circle here } 
    }; 

Ora si può avere vettore di diverse forme:

vector<Shape*> shapes; 
    shapes.push_back(new Rectangle()); 
    shapes.push_back(new Circle()); 

E si può trarre tutte le forme in questo modo:

for(vector<Shape*>::iterator i = shapes.begin(); i != shapes.end(); i++) 
    { 
      (*i)->draw(); 
    } 

In questo modo si disegnano forme diverse con un metodo virtuale: draw(). La versione corretta del metodo viene selezionata in base alle informazioni di runtime sul tipo di oggetto dietro il puntatore.

Avviso Quando si utilizzano le funzioni virtuali si possono dichiarare come puro virtuale (come in Forma di classe, solo luogo "= 0" dopo che il metodo proto). In questo caso non sarai in grado di creare istanze di oggetti con pura funzione virtuale e si chiamerà Classe astratta.

Notare anche "virtuale" prima del distruttore. Nel caso in cui pianifichi il lavoro con gli oggetti tramite puntatori alle loro classi base dovresti dichiarare il distruttore virtuale, quindi quando chiami "cancella" per il puntatore della classe base, verrà chiamata tutta la catena di distruttori e non ci saranno perdite di memoria.