C ++ Funkció Túlterhelés

A C ++ egy rugalmas általános célú programozási nyelv. Ezt a programozási nyelvet eredetileg Bjarne Stroustrup, dán informatikus hozta létre még 1985-ben. A C ++ támogatja a polimorfizmust, az öröklődést és még sok mást. Ez a cikk a funkció túlterhelésével foglalkozik a fordítási idejű polimorfizmus elérése érdekében a C ++ programozási nyelvben.

Mi a funkció?

A függvény nem más, mint egy adott kóddarab, amely egy adott feladatot hajt végre a megadott bemenetek alapján, és a kért eredményeket kimenet formájában adja vissza a felhasználónak. A funkciókat az ismétlődő kódok kiküszöbölésére használják nagy kódbázisokban.

A függvény meghatározása után később felhasználhatja később, akár ugyanabban a programban, akár egy másik programban.

Funkció szintaxisa

A C ++ egyik függvényének a következő szintaxisa van:

returnType functionName (paraméter_lista)

…
…
return return_value;

A returnType, a paraméter_lista és a return utasítás nem kötelező. A C ++ nyelvű függvény legfeljebb egy értéket adhat vissza. Ha egy függvény nem ad vissza értéket, akkor a returnType-t érvénytelennek kell definiálni.

Mi a funkció túlterhelése?

A C ++ nyelven több függvénydefiníciónak ugyanaz a függvényneve lehet, de eltérő paraméterekkel. Ezt hívjuk függvénytúlterhelésnek. A függvénytúlterhelési funkció segítségével a fordítási időbeli polimorfizmus C-ban érhető el++.

A funkciókat a következő módon lehet túlterhelni:

A paraméterek száma eltérő lehet
A paraméterek adattípusa eltérő lehet
A paraméterek sorrendje eltérő lehet

A visszatérési értéket azonban nem vesszük figyelembe a függvény túlterhelésénél.

A következő funkciók túlterheltek:

int összeadás (int a, int b)
úszó hozzáadás (float f, gloat g)
úszó hozzáadás (float f, int i)
úszó hozzáadása (int i, float f)
int összeadás (int a, int b, int c)
úszó hozzáadás (úszó f, úszó g, úszó h)

Mint látható, a C ++ funkciótúlterhelő funkciójának segítségével több definíció / funkció lehet ugyanazzal a funkciónévvel és ugyanabban a hatókörben.

A függvénytúlterhelési funkció nélkül külön változatot kell írnod [például: add_1 (), hozzáadva_2 () stb.]. Például két egész szám hozzáadásához írnia kell az add_1 () -t, a két úszó hozzáadásához az. Azonban, amint azt a fentiekben láthatja, a függvénytúlterhelési funkcióval meghatározható az „addíció ()” függvény több változata, miközben ugyanaz a függvénynév megmarad.

A következő függvények nem tekinthetők túlterheltnek, mert e kettő között csak a visszatérés típusa különbözik (a visszatérési típus nem számít függvénytúlterhelésnek C ++ nyelven):

int összeadás (int a, int b)
úszó összeadás (int a, int b)

Példák

Most, hogy megértette a funkciók túlterhelésének fogalmát, áttekintünk néhány működő példaprogramot, hogy ezt a fogalmat tisztábban megértsük. A következő példákat mutatjuk be:

1. példa: Egyszerű funkció
2. példa: Egyszerű addíciós függvény
3. példa: Funkció túlterhelés (1)
4. példa: Funkció túlterhelés (2)
5. példa: Funkció túlterhelés (3)

Az első két példa elmagyarázza, hogyan működnek a normál függvények a C ++ nyelven, míg az utolsó három példa a C funkciók túlterhelését mutatja be++.

1. példa: Egyszerű funkció

Ebben a példában bemutatjuk, hogyan definiálható és meghívható egy egyszerű függvény C-ben++. Meghatározzuk a "Display" nevű osztályt és a "display () nevű nyilvános függvényt.”A„ main () ”függvényből meghívjuk a„ display () ”függvényt a„ Display ”osztályobjektum (d) segítségével.

#include
névtér használata std;
osztály Kijelző

nyilvános:
érvénytelen kijelző ()

cout << "Hello World!" << endl;

;
int main ()

D kijelző;
d.kijelző();
visszatér 0;

2. példa: Egyszerű addíciós függvény

Ebben a példában bemutatjuk, hogyan definiálható egy egyszerű „add ()” függvény a C-ben++. Meghatározunk egy „DemoAdd” nevű osztályt és egy „add ()” nevű nyilvános függvényt.”A“ main () ”függvényből az“ add () ”függvényt hívjuk meg a“ DemoAdd ”osztályobjektum (d) segítségével.

Ebben a példában az „addíció ()” függvény jelenlegi megvalósítása csak két egész paramétert fogad el. Ez azt jelenti, hogy a jelenlegi „addíció ()” függvény csak két egész számot képes összeadni.

Ha kettő helyett három egész számot kíván hozzáadni, akkor megadhat egy eltérő névvel rendelkező függvényt, például „addíció_1 ()”. A C ++ - ban egy függvény túlterhelhető, ami azt jelenti, hogy az „addíció ()” függvény másik meghatározása definiálható három egész szám hozzáadásához és ugyanazon név megtartásához, azaz.e., "kiegészítés().”A következő példában megvizsgáljuk, hogyan lehet túlterhelni az„ add () ”függvényt.

#include
névtér használata std;
osztály DemoAdd

nyilvános:
int összeadás (int a, int b)

int eredmény;
eredmény = a + b;
visszatérési eredmény;

;
int main ()

DemoAdd d;
int i1 = 10, i2 = 20, res;
res = d.addíció (i1, i2);
cout << "Result = " << res << endl;
visszatér 0;

3. példa: Funkció túlterhelés (1)

Az előző példában meghatároztuk az „addíció ()” függvényt két egész szám hozzáadásához és a kiszámított eredmény visszaadásához. Ebben a példában most túlterheljük az „addíció ()” függvényt három egész szám hozzáadásához. Tehát két egész argumentummal, valamint három egész argumentummal meghívhatjuk az „addition ()” függvényt.

A funkciótúlterhelő funkció nélkül egy másik függvényt kellene írnunk, más néven.

#include
névtér használata std;
osztály DemoAdd

nyilvános:
// Az összeadás első függvénydefiníciója ()
int összeadás (int a, int b)

int eredmény;
eredmény = a + b;
visszatérési eredmény;

// Az Add () függvény túlterhelt változata
int összeadás (int a, int b, int c)

int eredmény;
eredmény = a + b + c;
visszatérési eredmény;

;
int main ()

DemoAdd d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.addíció (i1, i2); // addíció () 2 paraméterrel
res2 = d.addíció (i1, i2, i3); // addíció () 3 paraméterrel
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
visszatér 0;

4. példa: Funkció túlterhelés (2)

A cikk korábbi szakaszaiban megtanulta, hogy a függvénytúlterhelés a paramétertípusok különbségei alapján hajtható végre. Itt a paraméter adattípusa alapján túlterheltük az „add ()” függvényt. Az összeadás függvény első verziójában két egész típusú változót adunk hozzá; a második változatban pedig két úszó típusú változót adunk hozzá.

#include
névtér használata std;
osztály DemoAdd

nyilvános:
// Az összeadás első meghatározása ()
int összeadás (int a, int b)

int eredmény;
eredmény = a + b;
visszatérési eredmény;

// Túlterhelt függvénydefiníció
úszó hozzáadás (float f, float g)

úszó eredmény;
eredmény = f + g;
visszatérési eredmény;

;
int main ()

DemoAdd d;
int i1 = 10, i2 = 20, res1;
float f1 = 10.5, f2 = 20.7, res2;
res1 = d.addíció (i1, i2); // az összeadás (int a, int b) lesz meghívva
res2 = d.addíció (f1, f2); // összeadás (float f, flat g) lesz meghívva
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
visszatér 0;

5. példa: Funkció túlterhelés (3)

Ebben a példában az „addíció ()” függvény túlterhelt a paraméterlista sorrendjének különbségei alapján. Ez egy másik módja a C-ben lévő függvény túlterhelésének++.

#include
névtér használata std;
osztály DemoAdd

nyilvános:
// Az addition () függvény első függvénydefiníciója
úszó hozzáadás (int a, float b)

úszó eredmény;
eredmény = (úszó) a + b;
visszatérési eredmény;

// Az addíció () függvény túlterhelt függvény-meghatározása
úszó hozzáadás (float a, int b)

úszó eredmény;
eredmény = a + (úszó) b;
visszatérési eredmény;

;
int main ()

DemoAdd d;
int i1 = 10;
float f1 = 10.5, res1, res2;
res1 = d.addíció (i1, f1); // hozzáadás (int a, float b) lesz meghívva
res2 = d.addíció (f1, i1); // összeadás (float a, int b) lesz meghívva
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
visszatér 0;

Következtetés

A C ++ egy általános célú és rugalmas programozási nyelv, amelyet széles körben használnak a különböző területeken. Ez a programozási nyelv támogatja a fordítási és a futási idejű polimorfizmust is. Ebben a cikkben megtanulta, hogyan lehet elérni a fordítási idejű polimorfizmust a C ++ - ban a függvénytúlterhelés funkció használatával. Ez egy nagyon hasznos szolgáltatás a C ++ rendszerben, amely segít a programozóknak olvasható kódot írni. Hasznos lehet újrafelhasználható kód írásakor is.