Tartalom

• 
  Összehasonlító táblázat:
• A túlterhelés meghatározása
• A túlterhelés megvalósítása a C ++ kategóriában
• A felülbírálás meghatározása
• A felülbírálás végrehajtása a C ++ programban
• Hasonlóságok
• Következtetés

Ban ben 'túlterhelés„Újradefiniáljuk a túlterhelt függvényeket ugyanazzal a funkciónévvel, de eltérő számú és típusú paraméterrel. Ban ben 'nyomósA felülbírált funkció prototípusa az egész programban azonos, de a felülbírálandó funkciót az alaposztályban a „virtuális” kulcsszó előzi meg, és a származtatott osztály újrafogalmazza kulcsszó nélkül.

A polimorfizmus az OOP egyik legfontosabb jellemzője. Ez egyszerűen azt jelenti, hogy „egy név több formában is felhasználható”. A polimorfizmus a 'funkció túlterhelés', 'operátor túlterhelés' és 'virtuális funkció' használatával valósítható meg. Mind a „túlterhelés”, mind a „felülbírálás” magában foglalja a polimorfizmus fogalmát. Itt a 'túlterhelés' az időpolimorfizmus fordítását, és az 'felülbírálás' futási idő polimorfizmusa. További tanulmány, ha a 'túlterhelés' és a 'felülbírálás' fő különbségéről beszélünk.

Ezenkívül egy összehasonlító diagram segítségével tanulmányozzuk a különbséget a túlterhelés és a túlterhelés között.

1. Összehasonlító táblázat
2. Meghatározás
3. Főbb különbségek
4. Hasonlóságok
5. Következtetés

Összehasonlító táblázat:

Az összehasonlítás alapja	A túlterhelés	nyomós
Prototípus	A prototípus eltér, mivel a paraméterek száma vagy típusa eltérhet.	A prototípus minden szempontjának azonosnak kell lennie.
Kulcsszó	A túlterhelés során nem alkalmaztak kulcsszót.	A felülbírálandó funkciót a virtuális kulcsszó előzi meg az alaposztályban.
Megkülönböztető tényező	A paraméter száma vagy típusa különbözik, ami meghatározza a funkció verziójának hívását.	Azt határozza meg, hogy melyik osztályfüggvényt hívja a mutató az, amelyik osztályhoz az objektumot hozzárendelte az adott mutatóhoz.
Minta meghatározása	A függvényt ugyanazzal a névvel definiáljuk, de a paraméter eltérő számával és típusával.	A függvényt meghatározza, egy virtuális kulcsszó előzi meg a fő osztályban, és a származtatott osztály újradefiniálja, kulcsszó nélkül.
A teljesítés ideje	Idő összeállítása.	Futási idő.
Kivitelező / virtuális funkció	A konstruktorok túlterhelhetők.	A virtuális funkció felülbírálható.
Pusztító	A pusztítót 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 a késői kötésre utal.

A túlterhelés meghatározása

A fordított idő polimorfizmust „túlterhelésnek” nevezzük. Mivel a túlterhelést a polimorfizmus fogalma generálja, ez „közös felületet biztosít több módszer számára”. Ez azt jelenti, hogy ha egy funkció túlterhelt, akkor ugyanazt a funkció nevét tartalmazza, amíg újradefiniálódik.

A túlterhelt funkciók különböznek egymástól, különböznek a „paraméter (ek) számától vagy típusától”, ez különbséget tesz az egyik túlterhelt funkciótól a másiktól. Ilyen módon a fordító felismeri, hogy melyik túlterhelt funkciót hívják. A leggyakrabban túlterhelt funkciók a „konstruktorok”. A „kivitelező” egyfajta „kivitelező túlterhelése”.

A túlterhelés megvalósítása a C ++ kategóriában

osztály túlterhelés {int a, b; public: int load (int x) {// első betöltés () függvény a = x; vissza a; } int betöltés (int x, int y) {// második betöltés () függvény a = x; b = y; visszatér a * b; }}; int main () {túlterhelés O1; O1.load (20); // első betöltés () funkcióhívás O1.load (20,40); // második betöltés () funkcióhívás}

Itt túlterhelték az osztályterhelés funkciót (). Az osztály két túlterhelt funkciója megkülönböztethető úgy, hogy az első load () függvény csak egyetlen egész paramétert fogad el, míg a második load () függvény két egész szám paramétert fogad el. Amikor az osztály túlterhelésének objektuma egyetlen paraméterrel meghívja a load () függvényt, akkor az első load () függvény meghívódik. Amikor az objektum betöltési () függvényt hív két paraméterrel, a második betöltési () függvény meghívódik.

A felülbírálás meghatározása

A futási idő alatt elért polimorfizmust „felülírónak” nevezzük. Ezt „öröklés” és „virtuális funkciók” használatával valósítják meg. A felülbírálandó funkciót egy alaposztályban a „virtuális” kulcsszó előzi meg, és egy származtatott osztályban újrafogalmazza kulcsszó nélkül.

Az egyik legfontosabb dolog, amelyet emlékezzünk a felülírásra, az, hogy a felülbírált funkció prototípusa nem változhat, míg a származtatott osztály újradefiniálja. Ha a felülbírált funkció hívást kap, a C ++ meghatározza, hogy a függvény melyik verzióját hívják - a mutató által megjelölt objektum típusa alapján - amellyel a függvény felhívja.

A felülbírálás végrehajtása a C ++ programban

osztálybázis {public: virtual void funct () {// az base class cout virtuális függvénye << "Ez egy funct () base classs osztály;" }}; class deri1: public base {public: void funct () {// az base class virtuális függvénye újradefiniálva a deri1 class coutban << "Ez egy deri1 osztály funct ()"; }}; osztály deri2: nyilvános bázis {public: void funct () {// az alap osztály virtuális függvénye újradefiniálva deri2 osztály osztályban << "Ez egy deri2 osztály funct ()"; }}; int main () {alap * p, b; származtatott1 d1; származtatott2d2; * P = & B; p-> funct (); // hívás az alaposztály funkciójára (). * P = & D1; p-> funct (); // hívás a deri1 osztályú funkcióra (). * P = & D2; p-> funct (); // hívás a deri2 osztályú funkcióra (). visszatérés 0; }

Itt van egy alap osztály, amelyet nyilvánosan két származtatott osztály örököl. A virtuális függvényt egy alaposztály határozza meg egy „virtuális” kulcsszóval, és mindkét származtatott osztály meghatározza újra, kulcsszó nélkül. A main ()-ban az alaposztály létrehoz egy „p” mutatóváltozót és „b” objektumot; A „deri1” osztály létrehozza a d1 objektumot, a deri2 osztály pedig a d2 objektumot hozza létre.

Most kezdetben az alap osztály „b” objektumának címét a „p” alap osztály mutatójának kell hozzárendelni. A „p” meghívja a funct () függvényt, tehát az alap osztály függvényét hívjuk.Ezután a származtatott1 „d1” osztályobjektum címét a „p” mutatóhoz rendelik, és ez ismét meghívja a funct () -ot; itt végrehajtjuk a deri1 osztály funct () függvényét. Végül a „p” mutatót a deri2 osztály objektumához kell hozzárendelni. Ezután a „p” meghívja a funct () függvényt, amely végrehajtja a deri2 osztály funct () funkcióját.

Ha a deri1 / deri2 osztály nem határozta meg újra a funct () értéket, akkor az alap osztály funct () -ját hívnánk, mivel a virtuális függvény „hierarchikus”.

1. A túlterhelt funkció prototípusa különbözik a túlterhelt funkcióhoz átadott paraméter típusa és száma miatt. Másrészt a felülbírált függvény prototípusa nem változik, mert egy felülbírált függvény különböző műveleteket hajt végre azon osztályhoz, amelyhez tartozik, de azonos típusú és paraméterszámmal.
2. A túlterhelt függvénynév nem jelent semmilyen kulcsszót, míg a felülbírált függvény neve csak a „Virtuális” kulcsszóval áll elő az alaposztályban.
3. A túlterhelt függvényt a függvényt átvitt paraméter típusától vagy számától függ. Az, hogy melyik osztály hívja felül a függvényt, attól függ, hogy melyik osztály objektumcíme van hozzárendelve az a mutatóhoz, amely a függvényt meghívta.
4. Melyik túlterhelt függvényt kell meghívni, a fordítási idő alatt oldódik meg. Melyik felülbírált funkciót kell felhívni, a futási idő alatt oldódik meg.
5. A konstruktorok túlterhelhetők, de nem szabad meghaladni.
6. A pusztítók nem terhelhetők túl, de felülbírálhatók.
7. A túlterhelés korai megkötést ér el, mivel a túlterhelt funkció meghívásra kerül a fordítási idő alatt. A felülbírálás késői kötést ér el, mivel a felülbírált funkció meghívásra kerül a futási idő alatt.

Hasonlóságok

1. Mindkettőt az osztály tagfüggvényeire alkalmazzák.
2. A polimorfizmus mindkettő mögött rejlő alapelv.
3. A függvény neve változatlan marad, miközben túlterhelést és felülírást alkalmazunk a funkciókra.

Következtetés

A túlterhelés és a felülbírálás hasonlónak tűnik, de nem ez a helyzet. A funkciók túlterhelhetők, de a jövőben bármely osztály nem tudja újradefiniálni a túlterhelt funkciót. A virtuális funkciót nem lehet túlterhelni; csak felülbírálhatók.