Inoltre, studiamo la differenza tra sovraccarico e override con l'aiuto di un grafico di confronto.
Grafico comparativo:
| Base per il confronto | Sovraccarico | Override |
|---|---|---|
| Prototipo | Il prototipo differisce in quanto il numero o il tipo di parametro possono differire. | Tutti gli aspetti del prototipo devono essere uguali. |
| Parola chiave | Nessuna parola chiave applicata durante l'overloading. | La funzione che deve essere sovrascritta è preceduta dalla parola chiave "virtuale", nella classe base. |
| Fattore distintivo | Numero o tipo di parametro diverso che determina la versione della funzione che viene chiamata. | La funzione di quale classe viene chiamata dal puntatore, è determinata da, indirizzo di quale oggetto della classe è assegnato a quel puntatore. |
| Definizione del modello | Le funzioni sono ridefinite con lo stesso nome, ma numero e tipo di parametro diversi. | La funzione è definita, preceduta da una parola chiave "virtuale" nella classe principale e ridefinita dalla classe derivata senza parola chiave. |
| Tempo di realizzazione | Compilare il tempo. | Tempo di esecuzione. |
| Costruttore / Funzione virtuale | I costruttori possono essere sovraccaricati. | La funzione virtuale può essere sovrascritta. |
| Distruttore | Il distruttore non può essere sovraccaricato. | Il distruttore può essere ignorato. |
| Rilegatura | Il sovraccarico raggiunge l'associazione anticipata. | Overriding fa riferimento al binding tardivo. |
Definizione di sovraccarico
Il polimorfismo in fase di compilazione è chiamato "sovraccarico". Poiché il sovraccarico è generato da un concetto di polimorfismo, fornisce "un'interfaccia comune per più metodi". Ciò significa che se una funzione è sovraccaricata, contiene lo stesso nome di funzione mentre viene ridefinita.
Le funzioni di overload sono diverse per quanto riguarda, "numero o tipo di parametro (i)" diverso, rende una funzione overload distinta da un'altra. In questo modo, il compilatore riconosce quale funzione di overload viene chiamata. Le funzioni più comunemente sovraccaricate sono "costruttori". 'Copia costruttore' è una sorta di "sovraccarico costruttore".
Implementazione dell'overloading in C ++
sovraccarico di classe {int a, b; public: int load (int x) {// first load () funzione a = x; return a; } int load (int x, int y) {// second load () function a = x; b = y; restituire un * b; }}; int main () {overload O1; O1.load (20); // funzione first load () chiamata O1.load (20, 40); // seconda funzione () chiamata di funzione} Qui la funzione load () del sovraccarico di classe è stata sovraccaricata. Le due funzioni sovraccaricate della classe possono essere distinte in modo che la prima funzione load () accetti solo un singolo parametro intero, mentre la seconda funzione load () accetta due parametri interi. Quando l'oggetto dell'overload di classe chiama la funzione load () con un singolo parametro, viene richiamata la funzione first load (). Quando la funzione load () delle chiamate oggetto passa due parametri, viene chiamata la seconda funzione load ().
Definizione di Overriding
Il polimorfismo raggiunto durante l'esecuzione è chiamato "override". È realizzato usando "ereditarietà" e "funzioni virtuali". La funzione da sovrascrivere è preceduta dalla parola chiave "virtuale" in una classe base e ridefinita in una classe derivata senza alcuna parola chiave.
Una delle cose più importanti da ricordare in caso di override è che il prototipo della funzione sovrascritta non deve cambiare mentre la classe derivata la ridefinisce. Quando una funzione sovrascritta riceve una chiamata, C ++ determina quale versione della funzione viene chiamata in base al "tipo dell'oggetto puntato da un puntatore" con cui viene eseguita la chiamata della funzione.
Implementazione di Overriding in C ++
class base {public: virtual void funct () {// funzione virtuale di base class cout << "Questa è una funzione di base della classe ()"; }}; class derived1: public base {public: void funct () {// funzione virtuale della classe base ridefinita in cout della classe derivata << "Questa è una funzione di una classe derivata ()"; }}; class derived2: public base {public: void funct () {// funzione virtuale della classe base ridefinita in cout della classe derivata2 funz (); // chiama alla funzione derivata1 funct (). * P = & d2; p-> funz (); // chiama a derivata2 classe funct (). ritorno 0; } Qui, c'è una singola classe base che è ereditata pubblicamente da due classi derivate. Una funzione virtuale è definita in una classe base con una parola chiave 'virtuale' ed è ridefinita da entrambe le classi derivate senza alcuna parola chiave. In main (), la classe base crea una variabile puntatore 'p' e un oggetto 'b'; la classe 'derived1' crea un oggetto d1 e la classe derivata2 crea un oggetto d2 '.
Ora, inizialmente l'indirizzo dell'oggetto della classe base 'b' è assegnato al puntatore della classe base 'p'. 'p' dà una chiamata alla funzione funct (), quindi viene chiamata una funzione della classe base. Quindi l'indirizzo dell'oggetto di classe derivata1 'd1' è assegnato al puntatore 'p', di nuovo dà la chiamata a funct (); qui viene eseguita la funzione funct () della classe derived1. Infine, il puntatore "p" è assegnato all'oggetto della classe derivata2. Quindi 'p' chiama function funct () che esegue la funzione func () della classe derivata2.
Se la classe derivata1 / derivata2 non ha ridefinito funct (), allora sarebbe stato chiamato il funct () della classe base, in quanto le funzioni virtuali sono "gerarchiche".
Differenze chiave tra sovraccarico e sovrascrittura
- Il prototipo di una funzione che viene sovraccaricata differisce a causa del tipo e del numero di parametri che vengono passati alla funzione sovraccaricata. D'altra parte, il prototipo della funzione sovrascritta non cambia poiché una funzione sovrascritta esegue un'azione diversa per una classe diversa a cui appartiene ma con lo stesso tipo e numero di parametri.
- Il nome della funzione sovraccarica non precede con nessuna parola chiave mentre il nome di una funzione sovrascritta precede con la chiave "Virtuale" solo nella classe base.
- La funzione sovraccaricata viene invocata dipende dal tipo o dal numero di parametri passati alla funzione. La funzione di override di quale classe è invocata dipende da, l'indirizzo dell'oggetto della classe è assegnato al puntatore, che ha invocato la funzione.
- Quale funzione sovraccaricata deve essere invocata viene risolta durante la compilazione. Quale funzione sottoposta a override da invocare viene risolta durante il runtime.
- I costruttori possono essere sovraccaricati ma non possono essere sovrascritti.
- I distruttori non possono essere sovraccaricati, ma possono essere ignorati.
- Il sovraccarico raggiunge l'associazione anticipata durante la quale la funzione di overload verrà invocata durante il periodo di compilazione. L'override consente di ottenere l'associazione tardiva in quanto la funzione sostituita da invocare viene risolta durante il runtime.
Analogie
- Entrambi sono applicati alle funzioni membro di una classe.
- Il polimorfismo è il concetto base dietro entrambi.
- Il nome della funzione rimane lo stesso mentre applichiamo l'overloading e l'override delle funzioni.
Conclusione
Il sovraccarico e l'override appaiono simili, ma non è questo il caso. Le funzioni possono essere sovraccaricate ma, qualsiasi classe non può ridefinire ulteriormente la funzione sovraccaricata in futuro. Una funzione virtuale non può essere sovraccaricata; possono solo essere ignorati.
