Funkció túlterhelése C ++ nyelven: Minden, amit tudnia kell

Ez a cikk részletes és átfogó ismereteket nyújt a funkció túlterheléséről C ++ nyelven, rengeteg megértendő példával.

A C ++ egyike azoknak a programozási nyelveknek, amelyek nagyon rugalmasak, és kiterjed az objektum-orientált programozás számos jellemzőjére is. A túlterhelés a programozási nyelv másik jellemzője.A következő mutatókkal foglalkozik ez a „Funkció túlterhelése a C ++ -ban” cikk-



C ++ Túlterhelés

Amikor két vagy több tagot hozunk létre egy osztályból, amelyeknek ugyanaz a neve, de számukban vagy paramétereikben különböznek egymástól, akkor ezt C ++ túlterhelésnek nevezik. C ++ - ban túlterhelhetjük:



  • mód,
  • kivitelezők, és
  • indexelt tulajdonságok

A túlterhelés típusai C ++ - ban

types-of-overloading-in-c++

Mi a függvény túlterhelése a C ++ nyelven?

Funkció Túlterhelés C ++ nyelven úgy határozható meg, hogy egy osztálynak két vagy több tagfüggvénye legyen azonos névvel, de paramétereikben eltérő. A függvény túlterhelésében a függvény újradefiniálható akár különböző típusú argumentumok használatával, akár a követelménynek megfelelő számú argumentum használatával. A fordító csak ezen különbségek révén képes megkülönböztetni a két túlterhelt funkciót.



A Function overloading egyik fő előnye, hogy növeli a program olvashatóságát, mert nem kell ugyanazon művelethez újra és újra különböző neveket használnunk.

Az érvek számának megváltoztatásával

A függvények túlterhelésének ezen a módon két függvényt határozunk meg ugyanazokkal a nevekkel, de különböző számú, azonos típusú paraméterrel. Például az alább említett programban két add () függvényt készítettünk a két és három egész összegének visszaadásához.

bináris-decimális átalakító java
// első függvénydefiníció int add (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }

Itt azt mondják, hogy az add () függvény túlterhelt, mivel két meghatározása van, az egyik két argumentumot fogad el, a másik pedig három argumentumot. Az, hogy melyik add () függvény lesz meghívva, az argumentumok számától függ.



int main () {add (10, 20) // az add () 2 paraméterrel add (10, 20, 30) // összeg () 3 paraméterrel lesz hívva}
#include névtér használatával std int add (int a, int b) {cout<< a+b <

A fenti példában az argumentumok számának megváltoztatásával túlterheljük az add () függvényt. Először definiálunk egy add () függvényt két paraméterrel, majd túlterheljük azáltal, hogy újból meghatározzuk az add () függvényt, de ezúttal három paraméterrel.

Különböző típusú érvek birtoklásával

Ebben a módszerben két vagy több függvényt definiálunk azonos névvel és azonos számú paraméterrel, de az ezekhez a paraméterekhez használt adattípus eltérő. Például ebben a programban három add () függvényünk van, az első két egész, a második két lebegő, a harmadik pedig két kettős argumentumot kap.

#include névtér használatával std int add (int x, int y) // első meghatározás {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }

A fenti példában háromszor definiáljuk az add () függvényt. Először egész számokat használunk paraméterekként, másodszor float-t használunk paraméterként, harmadszor pedig a duplát használjuk paraméterként.
Így kétszer felülírjuk az add () függvényt.

mi átmeneti a java-ban

A funkció előnyei Túlterhelés C ++ - ban

  • A funkciók túlterhelését használjuk programunk memóriaterületének, konzisztenciájának és olvashatóságának megtakarításához.

  • A use function overloading koncepcióval több funkciót is kifejleszthetünk ugyanazzal a névvel

  • A függvények túlterhelése megmutatja a polimorfizmus viselkedését, amely lehetővé teszi számunkra, hogy eltérő viselkedést kapjunk, bár lesz némi kapcsolat a függvény azonos nevével.

  • A funkció túlterhelése felgyorsítja a program végrehajtását.

  • A funkciók túlterhelését a kód újrafelhasználhatóságára és a memória megtakarítására használják.

  • Segít az alkalmazásnak betölteni az osztály metódust a paraméter típusa alapján.

  • A kód karbantartása egyszerű.

A funkció túlterhelése C ++ - ban

  • Azok a funkciódeklarációk, amelyek csak a visszatérési típusukban különböznek egymástól, nem terhelhetők túlfunkciós funkciókkal.
  • Az azonos paraméterekkel vagy azonos névtípusú tagfüggvény-deklarációk nem terhelhetők túl, ha bármelyiküket statikus tagfüggvényként deklarálják.
  • osztály XYZ {static void func () void func () // error}

Funkció Túlterhelés és kétértelműség

Amikor a fordító nem tudja eldönteni, hogy melyik függvényt kell először meghívnia a túlterhelt függvények közül, ezt a helyzetet függvénytúlterhelő kétértelműségnek nevezzük. A fordító nem futtatja a programot, ha egyértelműséghibát mutat. A funkció túlterhelésének kétértelműsége okai:

  • Írja be a konverziót.
  • Funkció alapértelmezett argumentumokkal.
  • Funkció hivatkozással történő átadással

Típusátalakítás:

#include névtér használatával std void függvény (float) void függvény (int) void függvény (float x) {std :: cout<< 'Value of x is : ' <

A fenti példa hibát vet - „a túlterhelt’ függvény (kettős) ’hívása félreérthető”. A (3.4) függvény meghívja az első függvényt. A (34) függvény előrejelzésünk szerint meghívja a második függvényt. De ez nem történik meg, mert a C ++ - ban az összes lebegőpontos állandót kettősnek, nem pedig úszónak tekintik. Ha az úszó változót kettős változóra cseréljük, akkor a program jól fog működni. Ezért ezt típusú konverziós hibának hívjuk úszóról kettősre.

Funkció alapértelmezett argumentumokkal:

#include névtér használatával std void függvény (int) void függvény (int, int) void függvény (int x) {std :: cout<< 'Value of x is : ' <

A fenti példa hibát ad, mondván, hogy „a túlterhelt„ fun (int) ”hívása nem egyértelmű”, mert a függvényt (int y, int z = 12) kétféleképpen lehet meghívni:

  1. A függvény egy argumentummal történő meghívásával (és ez automatikusan felveszi a z = 12 értékét)
  2. A függvény két argumentummal történő meghívásával.

Amikor meghívjuk a function: function (12) függvényt, akkor kitöltjük a függvény (int) és a function (int, int) feltételét, így a fordító kétértelműségbe kerül, hibát mutat.

Funkció hivatkozással történő átadással

állítsa be a java classpath-t a linuxban
#include névtér használatával std void függvény (int) void függvény (int &) void függvény (int a) {std :: cout<< 'Value of a is : ' < 

A fenti program hibát ad, mondván, hogy „a túlterhelt„ fun (int &) ”hívása kétértelmű”. Amint látjuk, az első függvény egy egész argumentumot vesz fel, a második függvény pedig egy referenciaparamétert vesz fel argumentumként. Ebben az esetben a fordító nem képes megérteni, hogy melyik funkcióra van szüksége a felhasználónak, mivel a szórakozás (int) és a szórakozás (int &) között nincs szintaktikai különbség, így a kétértelműség hibáját veti fel.

Ezzel véget értünk ennek a C ++ - ban végzett túlterhelésnek. Ha többet szeretne megtudni, nézze meg a Edureka, egy megbízható online tanulási társaság. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát arra tervezték, hogy mind az alapvető, mind a fejlett Java koncepciókra kiképezzen különféle Java keretrendszereket, például a Hibernate & Spring.

Van egy kérdésünk? Kérjük, említse meg a blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.