• Una funzione virtuale C++ è una funzione membro della classe base che viene ridefinita in una classe derivata. Viene dichiarato utilizzando la parola chiave virtual.
• Viene utilizzato per indicare al compilatore di eseguire il collegamento dinamico o l'associazione tardiva sulla funzione.
• È necessario utilizzare il singolo puntatore per fare riferimento a tutti gli oggetti delle diverse classi. Creiamo quindi il puntatore alla classe base che fa riferimento a tutti gli oggetti derivati. Ma, quando il puntatore della classe base contiene l'indirizzo dell'oggetto della classe derivata, esegue sempre la funzione della classe base. Questo problema può essere risolto solo utilizzando la funzione 'virtuale'.
• Un 'virtuale' è una parola chiave che precede la normale dichiarazione di una funzione.
• Quando la funzione viene resa virtuale, C++ determina quale funzione deve essere invocata in fase di esecuzione in base al tipo di oggetto puntato dal puntatore della classe base.

Associazione tardiva o collegamento dinamico

Nella chiamata di funzione di associazione tardiva viene risolta durante il runtime. Pertanto il compilatore determina il tipo di oggetto in fase di esecuzione e quindi associa la chiamata di funzione.

Regole della funzione virtuale

jsp javatpoint

• Le funzioni virtuali devono essere membri di una classe.
• Le funzioni virtuali non possono essere membri statici.
• Sono accessibili tramite puntatori a oggetti.
• Possono essere amici di un'altra classe.
• Una funzione virtuale deve essere definita nella classe base, anche se non viene utilizzata.
• I prototipi di una funzione virtuale della classe base e di tutte le classi derivate devono essere identici. Se le due funzioni hanno lo stesso nome ma prototipi diversi, C++ le considererà come funzioni sovraccaricate.
• Non possiamo avere un costruttore virtuale, ma possiamo avere un distruttore virtuale
• Considera la situazione in cui non utilizziamo la parola chiave virtuale.

 #include using namespace std; class A { int x=5; public: void display() { std::cout &lt;&lt; &apos;Value of x is : &apos; &lt;&lt; x&lt;<std::endl; } }; class b: public a { int y="10;" public: void display() std::cout << 'value of is : ' <<y<<std::endl; main() *a; b b; a->display(); return 0; } </std::endl;>

Produzione:

 Value of x is : 5 

Nell'esempio precedente, * a è il puntatore della classe base. Il puntatore può accedere solo ai membri della classe base ma non ai membri della classe derivata. Sebbene il C++ consenta al puntatore base di puntare a qualsiasi oggetto derivato dalla classe base, non può accedere direttamente ai membri della classe derivata. Pertanto, è necessaria una funzione virtuale che consenta al puntatore base di accedere ai membri della classe derivata.

Esempio di funzione virtuale C++

Vediamo il semplice esempio di funzione virtuale C++ utilizzata per invocare la classe derivata in un programma.

 #include { public: virtual void display() { cout &lt;&lt; &apos;Base class is invoked&apos;&lt;<endl; } }; class b:public a { public: void display() cout << 'derived is invoked'<<endl; int main() a* a; pointer of base b b; object derived a->display(); //Late Binding occurs } </endl;>

Produzione:

 Derived Class is invoked 

Pura funzione virtuale

• Una funzione virtuale non viene utilizzata per eseguire alcuna attività. Serve solo come segnaposto.
• Quando la funzione non ha una definizione, tale funzione è conosciuta come ' fare niente ' funzione.
• IL ' fare niente ' è conosciuta come a pura funzione virtuale . Una funzione virtuale pura è una funzione dichiarata nella classe base che non ha alcuna definizione relativa alla classe base.
• Una classe contenente la funzione virtuale pura non può essere utilizzata per dichiarare i propri oggetti, tali classi sono note come classi base astratte.
• L'obiettivo principale della classe base è fornire i tratti alle classi derivate e creare il puntatore base utilizzato per ottenere il polimorfismo di runtime.

La funzione virtuale pura può essere definita come:

 virtual void display() = 0; 

Vediamo un semplice esempio:

libero contro libero

 #include using namespace std; class Base { public: virtual void show() = 0; }; class Derived : public Base { public: void show() { std::cout &lt;&lt; &apos;Derived class is derived from the base class.&apos; <show(); return 0; } < pre> <p> <strong>Output:</strong> </p> <pre> Derived class is derived from the base class. </pre> <p>In the above example, the base class contains the pure virtual function. Therefore, the base class is an abstract base class. We cannot create the object of the base class.</p></show();>

Nell'esempio precedente, la classe base contiene la funzione virtuale pura. Pertanto, la classe base è una classe base astratta. Non possiamo creare l'oggetto della classe base.