Továbbá összehasonlító táblázat segítségével vizsgáljuk a túlterhelés és a felülbírálás közötti különbséget.
Összehasonlító táblázat:
| Az összehasonlítás alapja | A túlterhelés | nyomós |
|---|---|---|
| Prototípus | A prototípus különbözik, mivel a paraméterek száma vagy típusa eltérő lehet. | A prototípus minden aspektusának azonosnak kell lennie. |
| Kulcsszó | Nincs kulcsszó a túlterhelés során. | A felülbírálandó függvényt a „virtuális” kulcsszó követi az alaposztályban. |
| Megkülönböztető tényező | A paraméterek száma vagy típusa különbözik attól, ami meghatározza a függvény verziót. | Melyik osztály funkcióját a mutató hívja meg, melyik osztály címét hozzárendeli az adott mutatóhoz. |
| Minta meghatározása | A függvényt ugyanazzal a névvel definiáljuk, de a paraméterek száma és típusa eltérő. | A függvényt definiáljuk, amelyet a kulcskategóriában egy „virtuális” kulcsszó követ, és újból definiálva származtatott osztályból a kulcsszó nélkül. |
| A teljesítés ideje | Fordítási idő. | Futtatási idő. |
| Konstruktor / virtuális funkció | A konstruktorok túlterhelhetők. | A virtuális funkció felülbírálható. |
| Pusztító | A destruktort nem lehet túlterhelni. | A romboló felülbírálható. |
| Kötés | A túlterhelés korai kötést eredményez. | A felülbírálás késedelmes kötést jelent. |
A túlterhelés meghatározása
A fordítási idő polimorfizmusát „túlterhelésnek” nevezzük. Mivel a túlterhelés a polimorfizmus fogalmából származik, „egy közös felületet biztosít több módszerhez”. Ez azt jelenti, hogy ha egy függvény túlterhelt, akkor ugyanaz a függvénynév szerepel, amíg újra definiálják.
A túlterhelt függvények különböznek a különböző „számok vagy paraméterek” típusától függően, és egy túlterhelt funkciót különböztet meg a másiktól. Ily módon a fordító felismeri, hogy melyik túlterhelt funkciót hívják. A leggyakrabban túlterhelt funkciók „konstruktorok”. A „Másolatot készítő” egyfajta „kivitelező túlterhelés”.
A túlterhelés megvalósítása C ++-ban
osztály túlterhelés {int a, b; nyilvános: int load (int x) {// első terhelés () függvény a = x; vissza a; } int terhelés (int x, int y) {// második terhelés () függvény a = x; b = y; vissza a * b; }}; int main () {O1 túlterhelés; O1.load (20); // első terhelés () függvényhívás O1.load (20, 40); // második terhelés () függvényhívás} Itt az osztály túlterhelés funkcióterhelése () túlterhelt. Az osztály két túlterhelt funkcióját úgy lehet megkülönböztetni, hogy az első terhelés () függvény csak egyetlen egész paramétert fogad el, míg a második terhelési () függvény két egész szám paramétert fogad el. Amikor az osztály túlterhelés tárgya egyetlen paraméterrel hívja a terhelés () függvényt, az első terhelés () függvényt hívják. Ha az objektum hívja a terhelés () függvényt két paraméteren át, a második terhelés () függvényt hívják.
A felülbírálás meghatározása
A futásidő alatt elért polimorfizmust „felülírónak” nevezik. Ez az „öröklés” és a „virtuális funkciók” segítségével valósítható meg. A felülbírálandó függvényt egy „virtuális” kulcsszó előzi meg egy bázisosztályban, és újra definiálják egy származtatott osztályban kulcsszó nélkül.
A felülbírálás esetén az egyik legfontosabb dolog, hogy a felülbírált funkció prototípusa nem változhat, míg a származtatott osztály újra definiálja azt. Ha a felülbírált függvény hívást kap, a C ++ határozza meg, hogy a függvény melyik verzióját hívják meg a mutató által kijelölt objektum típusa alapján, amellyel a függvényhívás megtörténik.
A felülbírálás végrehajtása a C ++-ban
class base {public: virtual void funct () {// bázisosztály virtuális funkciója << "Ez egy alaposztály funkciója ()"; }}; osztályból származtatott1: public base {public: void funct () {// az alaposztály virtuális függvénye, amely újból lett meghatározva a származtatott 1 osztályú cout-ban << "Ez egy származtatott1 osztály funkciója ()"; }}; osztályból származtatott2: nyilvános bázis {public: void funct () {// az alaposztály virtuális funkciója, amelyet újból definiált a származtatott 2 osztályban funct (); // hívás származtatott1 osztályfüggvényre (). * P = & D2; p-> funct (); // hívás származtatott 2 osztályfüggvényre (). vissza 0; } Itt van egy bázisosztály, amely nyilvánosan örökölt két származtatott osztályból. A virtuális függvényt egy „virtuális” kulcsszóval határozza meg, és mindkét származtatott osztály kulcsszó nélkül újradefiniálja azt. A fő () esetében az alaposztály egy „p” mutatót és egy „b” objektumot hoz létre; A „származtatott1” osztály létrehoz egy d1 objektumot, és a kapott 2 osztály létrehoz egy d2 'objektumot.
Most kezdetben a 'b' alaposztály objektum címe a 'p' bázisosztály mutatójához van hozzárendelve. A „p” hívja a függvény függvényt (), így az alaposztály függvénye. Ekkor a 'd1' származtatott1 osztályobjektum címét a 'p' mutatóhoz rendeli, ismét meghívást ad a (); itt az eredő1 osztály függvénye () végrehajtódik. Végül a 'p' mutató hozzárendelve van a származtatott 2 osztály objektumához. Ezután a 'p' hívja a függvény függvényt (), amely a (2) függvény () függvényét hajtja végre.
Ha a származtatott1 / származtatott2 osztály nem definiálta újra a (z) függvényt, akkor az alaposztály függvénye () lett volna hívva, mivel a virtuális függvény hierarchikus.
Főbb különbségek a túlterhelés és a felülbírálás között
- A túlterhelt függvény prototípusa a túlterhelt funkcióhoz továbbított paraméter típusától és számától függ. Másrészről a felülbírált függvény prototípusa nem változik, mert egy felülbírált funkció különböző műveleteket hajt végre különböző osztályokhoz, de ugyanolyan típusú és számú paraméterrel rendelkezik.
- A túlterhelt függvény neve nem előz meg semmilyen kulcsszót, míg a felülbírált függvény neve csak a „virtuális” kulccsal kezdődik csak az alaposztályban.
- A túlterhelt függvény függ a függvényhez továbbított paraméter típusától vagy számától. A felülvizsgált függvény, amelyik osztályát meghívja, attól függ, hogy melyik osztály objektum címe van hozzárendelve a mutatóhoz.
- Melyik túlterhelt függvényt kell meghívni a fordítási idő alatt. Melyik felülbírálható funkciót kell megoldani a futás közben.
- A konstruktorok túlterhelhetők, de nem felülírhatók.
- A megsemmisítők nem túlterhelhetők, de felülbírálhatók.
- A túlterhelés korai kötést ér el, amellyel a túlterhelt függvényt lekérdezzük a fordítási idő alatt. A felülbírálás késedelmes kötést ér el, mivel a felülbírált függvényt a futás közben megoldjuk.
Hasonlóságok
- Mindkettőt egy osztály tagfüggvényeire alkalmazzák.
- A polimorfizmus az alapfogalom mindkettőjük mögött.
- A függvény neve ugyanaz marad, miközben túlterhelést alkalmazunk, és felülbíráljuk a funkciókat.
Következtetés
A túlterhelés és a felülbírálás hasonlónak tűnik, de ez nem így van. A függvények túlterhelhetők, de bármely osztály nem tudja tovább meghatározni a túlterhelt funkciót a jövőben. A virtuális funkciót nem lehet túlterhelni; csak felülbírálhatók.
