Contenuto

• 
  Tabella di comparazione:
• Definizione di sovraccarico
• Implementazione del sovraccarico in C ++
• Definizione di Override
• Implementazione di Override in C ++
• Somiglianze
• Conclusione

Nel 'sovraccarico'Ridefiniamo le funzioni sovraccaricate con lo stesso nome di funzione ma con numero e tipo di parametri diversi. Nel 'sovrascrivendo"Il prototipo della funzione sostituita è lo stesso in tutto il programma, ma la funzione da sovrascrivere è preceduta dalla parola chiave" virtuale "nella classe base ed è ridefinita dalla classe derivata senza alcuna parola chiave.

Il polimorfismo è una delle caratteristiche cruciali di OOP. Significa semplicemente "usare un nome per più moduli". Il polimorfismo può essere implementato usando "sovraccarico di funzioni", "sovraccarico dell'operatore" e "funzione virtuale". Entrambi, "sovraccarico" e "override" implica il concetto di polimorfismo. Qui, il "sovraccarico" è il polimorfismo del tempo di compilazione e il "superamento" è il polimorfismo del tempo di esecuzione. Studiando ulteriormente, se parliamo della principale differenza tra "sovraccarico" e "prevalenza".

Inoltre, studiamo la differenza tra sovraccarico e override con l'aiuto di una tabella comparativa.

1. Tabella di comparazione
2. Definizione
3. Differenze chiave
4. Somiglianze
5. Conclusione

Tabella di comparazione:

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 il sovraccarico.	La funzione da sovrascrivere è preceduta dalla parola chiave virtual, nella classe base.
Fattore distintivo	Il numero o il tipo di parametro differisce, determinando la chiamata della versione della funzione.	Quale funzione di classe viene chiamata dal puntatore, è determinata da, indirizzo di quale oggetto di classe è assegnato a quel puntatore.
Definire il modello	Le funzioni vengono 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 con la parola chiave out.
Tempo di realizzazione	Tempo di compilazione.	Tempo di esecuzione.
Funzione di costruzione / virtuale	I costruttori possono essere sovraccarichi.	La funzione virtuale può essere ignorata.
Distruttore	Il distruttore non può essere sovraccaricato.	Il distruttore può essere ignorato.
Rilegatura	Il sovraccarico consente di eseguire l'associazione anticipata.	L'override si riferisce all'associazione tardiva.

Definizione di sovraccarico

Il polimorfismo in fase di compilazione è chiamato "sovraccarico". Dato che il sovraccarico è generato da un concetto di polimorfismo, fornisce "un'interfaccia comune per più metodi". Ciò significa che se una funzione è sovraccarica, contiene lo stesso nome di funzione mentre viene ridefinita.

Le funzioni di sovraccarico differiscono per quanto riguarda, diverso "numero o tipo di parametro", rende una funzione di sovraccarico distinta da un'altra. In questo modo, il compilatore riconosce quale funzione di sovraccarico viene chiamata. Le funzioni sovraccaricate più comunemente sono "costruttori". "Copia costruttore" è una sorta di "sovraccarico costruttore".

Implementazione del sovraccarico in C ++

sovraccarico di classe {int a, b; public: int load (int x) {// funzione first load () a = x; restituire a; } int load (int x, int y) {// second load () funzione a = x; b = y; ritorna a * b; }}; int main () {sovraccarico O1; O1.load (20); // prima chiamata di funzione load () O1.load (20,40); // second load () function call}

Qui il caricamento della funzione () del sovraccarico di classe è stato sovraccaricato. Le due funzioni sovraccaricate della classe possono essere distinte in modo tale che la prima funzione load () accetti solo un singolo parametro intero, mentre la seconda funzione load () accetta due parametri interi. Quando l'oggetto del sovraccarico di classe chiama la funzione load () con un singolo parametro, viene chiamata la prima funzione load (). Quando l'oggetto chiama la funzione load () passando due parametri, viene chiamata la seconda funzione load ().

Definizione di Override

Il polimorfismo raggiunto durante il runtime si chiama "override". Si ottiene utilizzando "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 override 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 di oggetto puntato da un puntatore" mediante il quale viene eseguita la chiamata di funzione.

Implementazione di Override in C ++

class base {public: virtual void funct () {// funzione virtuale della classe di base cout << "Questa è una classe di base funct ()"; }}; class deriv1: public base {public: void funct () {// funzione virtuale della classe base ridefinita nella classe deriv1 cout << "Questa è una classe derivata funct ()"; }}; class deriv2: public base {public: void funct () {// funzione virtuale della classe base ridefinita nella classe deriv2 cout << "Questa è una classe derivata funct ()"; }}; int main () {base * p, b; derivato1 d1; derivato2 d2; * P = & b; p-> funz (); // chiama alla classe base funct (). * P = & d1; p-> funz (); // chiama a deriv1 class funct (). * P = & d2; p-> funz (); // chiama a deriv2 class funct (). ritorna 0; }

Qui esiste una singola classe di base che viene 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 parola chiave. In main (), la classe base crea una variabile puntatore "p" e un oggetto "b"; La classe "derivata1" crea un oggetto d1 e la classe derivata crea un oggetto d2 ".

Ora, inizialmente l'indirizzo dell'oggetto "b" della classe base viene 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 derivato "d1" viene assegnato al puntatore "p", ancora una volta dà la chiamata a funct (); qui viene eseguita la funzione funct () della classe derivata1. Infine, il puntatore "p" viene assegnato all'oggetto della classe derivata2. Quindi "p" chiama la funzione funct () che esegue la funzione funct () della classe derivata2.

Se la classe derivata1 / derivata2 non avesse ridefinito funct (), sarebbe stata chiamata la funzione funct () della classe base, poiché le funzioni virtuali sono "gerarchiche".

1. Il prototipo di una funzione che viene sovraccaricata differisce a causa del tipo e del numero di parametri passati alla funzione sovraccaricata. D'altra parte, il prototipo della funzione sostituita non cambia perché una funzione sostituita esegue un'azione diversa per classe diversa a cui appartiene ma con lo stesso tipo e numero di parametro.
2. Il nome della funzione sovraccaricata non precede alcuna parola chiave, mentre il nome di una funzione sostituita precede il keyord "Virtual" solo nella classe base.
3. La funzione di sovraccarico invocata dipende dal tipo o dal numero di parametro che viene passato alla funzione. La funzione sovrascritta di quale classe viene invocata dipende da quale indirizzo dell'oggetto della classe è assegnato al puntatore, che ha invocato la funzione.
4. La funzione sovraccaricata da richiamare viene risolta durante il tempo di compilazione. La funzione ignorata da invocare viene risolta durante il runtime.
5. I costruttori possono essere sovraccaricati ma non possono essere ignorati.
6. I distruttori non possono essere sovraccaricati, ma possono essere sostituiti.
7. Il sovraccarico ottiene l'associazione anticipata quando la funzione sovraccarica che verrà invocata viene risolta durante il tempo di compilazione. L'override ottiene l'associazione tardiva poiché la funzione sovrascritta che verrà invocata viene risolta durante il runtime.

Somiglianze

1. Entrambi vengono applicati alle funzioni membro di una classe.
2. Il polimorfismo è il concetto alla base di entrambi.
3. Il nome della funzione rimane lo stesso mentre applichiamo il sovraccarico e l'override alle funzioni.

Conclusione

Il sovraccarico e l'override sembrano simili, ma non è così. 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 sovrascritti.