Diferència entre sobrecàrrega de funcions i sobreposició en C ++
Content
Gràfic de comparació:- Definició de sobrecàrrega
- Implementació de sobrecàrregues en C ++
- Definició de Overriding
- Implantació de Overriding en C ++
- Semblances
- Conclusió
A "sobrecàrrega"Redefinim les funcions sobrecarregades amb el mateix nom de funció però, diferent número i tipus de paràmetres. A "imperatiu"El prototip de funció anul·lada és el mateix en tot el programa, però, la funció que es pot substituir està precedida de la paraula clau" virtual "de la classe base i la redefineix la classe derivada sense cap paraula clau.
El polimorfisme és una de les característiques crucials de l'OPA. Simplement significa "utilitzar un nom per a diversos formularis". El polimorfisme es pot implementar mitjançant "sobrecàrrega de funcions", "sobrecàrrega d'operadors" i "funció virtual". Tots dos, la "sobrecàrrega" i la "superació" impliquen el concepte de polimorfisme. Aquí, la "sobrecàrrega" és recopilar el polimorfisme i "sobreposar" és el polimorfisme en temps d'execució. Estudiar més si parlem de la diferència important en la "sobrecàrrega" i la "superació".
A més, estudiem la diferència entre sobrecàrrega i sobreposició amb l'ajut d'un gràfic de comparació.
- Gràfic de comparació
- Definició
- Diferències claus
- Semblances
- Conclusió
Gràfic de comparació:
| Bases per a la comparació | Sobrecàrrega | Imperatiu |
|---|---|---|
| Prototip | El prototip difereix perquè el nombre o el tipus de paràmetre poden diferir. | Tots els aspectes del prototip han de ser els mateixos. |
| Paraula clau | No s’ha aplicat cap paraula clau durant la sobrecàrrega. | La funció que cal superar és precedida per la paraula clau virtual, a la classe base. |
| Factor diferenciador | Difereix el nombre o el tipus de paràmetre que determina la versió de la funció. | A quina funció de classes està cridant el punter, es determina per, l'adreça de quin objecte de les classes s'assigna a aquest punter. |
| Patró de definició | La funció es redefineix amb el mateix nom, però el número i el tipus de paràmetre són diferents. | La funció està definida, precedida per una paraula clau virtual a la classe principal i redefinida per classe derivada amb paraula clau fora. |
| Temps de realització | Compila el temps. | Temps d’execució. |
| Funció constructor / virtual | Els constructors es poden sobrecarregar. | La funció virtual es pot substituir. |
| Destructor | No es pot sobrecarregar el destructor. | Es pot anul·lar el destructor. |
| Enquadernació | La sobrecàrrega aconsegueix unió precoç. | El sobreposició es refereix a la vinculació tardana. |
Definició de sobrecàrrega
El polimorfisme en temps de compilació s'anomena "sobrecàrrega". Com que la sobrecàrrega es genera a partir d'un concepte de polimorfisme, proporciona "una interfície comuna per a diversos mètodes". Això vol dir que si una funció es sobrecarrega, contindrà el mateix nom de funció mentre es redefineix.
Les funcions sobrecarregades difereixen pel que fa a, segons el número o tipus de paràmetre o paràmetres, fa que una funció sobrecàrrega sigui diferent de l’altra. D’aquesta manera, el compilador reconeix quina funció s’està carregant sobrecàrrega. Les funcions sobrecarregades més sovint són "constructors". El "constructor de còpia" és un tipus de "sobrecàrrega del constructor".
Implementació de sobrecàrregues en C ++
sobrecàrrega de classe {int a, b; public: int load (int x) {// primera càrrega () funció a = x; tornar a; } int load (int x, int y) {// segona càrrega () funció a = x; b = y; retorna a * b; }}; int principal () {sobrecàrrega O1; O1.load (20); // primera funció de càrrega () trucada O1.load (20,40); // segona trucada de càrrega () funció}
Aquí la sobrecàrrega de funcions () de sobrecàrrega de classe s'ha sobrecarregat. Les dues funcions sobrecarregades de la classe es poden distingir de manera que la primera funció de càrrega () accepta només un paràmetre sencer, mentre que la segona funció de càrrega () accepta dos paràmetres enters. Quan l’objecte de la sobrecàrrega de classe crida la funció load () amb un únic paràmetre, s’anomena primera funció load (). Quan l’objecte truca a la funció de càrrega () que passa dos paràmetres, s’anomena segona funció load ().
Definició de Overriding
El polimorfisme aconseguit durant el temps d'execució s'anomena "majoritat". S'aconsegueix mitjançant "herència" i "funcions virtuals". La funció que cal substituir està precedida de la paraula clau "virtual" d'una classe base i es redefineix en una classe derivada sense cap paraula clau.
Una de les coses més importants a recordar en cas de superació és que el prototip de la funció anul·lada no ha de canviar mentre la classe derivada la redefineixi. Quan es dóna una trucada a una funció anul·lada, C ++ determina quina versió de la funció s'anomena en funció del "tipus d'objecte apuntat per un punter" mitjançant el qual es fa la trucada de funció.
Implantació de Overriding en C ++
class base {public: virtual void function () {// funció virtual de base class cout << "Aquesta és una funció de classes base ()"; }}; class deriv1: public base {public: void function () {// funció virtual de la classe base redefinida a la classe derivada cout << "Aquesta és una classe derivada de les funcions ()"; }}; class deriv2: public base {public: void function () {// funció virtual de la classe base redefinida en deriv2 class cout << "Aquesta és una funció derivada de les classes2 ()"; }}; int principal () {base * p, b; derivat1 d1; derivat2 d2; * p = & b; p-> funct (); // trucar a la funció de classe base (). * p = & d1; p-> funct (); // trucar a la funció derivada de la classe1 (). * p = & d2; p-> funct (); // trucar a la funció derivada de la classe2 (). retornar 0; }
Aquí, hi ha una única classe base que s'hereta públicament per dues classes derivades. Una funció virtual es defineix en una classe base amb una paraula clau "virtual", i la redefineix les dues classes derivades sense paraula clau. A principal (), la classe base crea una variable de punter "p" i un objecte "b"; La classe derivada 1 crea un objecte d1 i la classe derivada crea un objecte d2.
Ara, inicialment l'adreça de l'objecte "b" de la classe base s'assigna al punter de la classe base "p". "P" fa una trucada a la funció function (), per la qual cosa s'anomena una funció de la classe base.Aleshores l'adreça de l'objecte de la classe derivada "d1" s'assigna al punter "p", torna a donar trucada a func (); aquí s'executa la funció func () de la classe derivada1. Finalment, el punter "p" s'assigna a l'objecte de la classe deriv2. A continuació, "p" truca a function function () que executa la funció func () de la classe derivada2.
Si la classe deriv1 / derivada2 no redefinís la funció (), s'hauria anomenat a la funció () de la classe base, ja que la funció virtual és "jeràrquica".
- El prototip d'una funció que està en sobrecàrrega és diferent a causa del tipus i nombre de paràmetres que es passen a la funció sobrecarregada. D'altra banda, el prototip de la funció anul·lada no canvia perquè una funció anul·lada realitzi diferents accions per a la classe diferent a la qual pertany, però amb el mateix tipus i nombre de paràmetre.
- El nom de funció sobrecarregat no precedeix cap paraula clau mentre que, el nom d'una funció anul·lada precedeix amb la clau "Virtual" només en la classe base.
- La funció sobrecarregada que s'invoca depèn del tipus o nombre de paràmetres que es passin a la funció. La funció anul·lada de la qual s’invoca la classe depèn de quina és l’adreça d’objecte de la classe que s’assigna al punter, que va invocar la funció.
- La funció sobrecàrrega que cal invocar es resol durant el temps de compilació. Quina funció anul·lada a invocar es resol durant el temps d'execució.
- Es pot sobrecarregar els constructors, però no es pot anul·lar.
- Els destructors no es poden sobrecarregar, però es poden anul·lar.
- La sobrecàrrega aconsegueix un enllaç precoç ja que la funció de sobrecàrrega que s’invocarà es resol durant el temps de compilació. El reemplaçament aconsegueix la vinculació tardana, ja que la funció invocada que s'invertirà es resol durant el temps d'execució.
Semblances
- Totes dues s'apliquen a les funcions de membres d'una classe.
- El polimorfisme és el concepte bàsic que hi ha darrere d’ambdues.
- El nom de la funció continua sent el mateix mentre apliquem sobrecàrregues i sobreimpressions a les funcions.
Conclusió
La sobrecàrrega i la sobrevalorització semblen similars, però aquest no és el cas. Les funcions es poden sobrecarregar, però, qualsevol classe no pot tornar a redefinir la funció sobrecarregada en el futur. No es pot sobrecarregar una funció virtual; només es poden anul·lar.
