Túlterhelés C ++ -ban

A C ++ nem engedélyezi azt a függvényt, amely két egész számot ad hozzá és egész számot ad vissza, két lebegőt ad hozzá és úsztat. Képzelje el, hogy van egy függvény, amely két egész számot ad hozzá és egy egész számot ad vissza. Nem lenne jó, ha van egy másik, azonos nevű függvény, amely kettő vagy még több úszót ad hozzá az úszó visszaadásához? Ezt mondják az első funkció túlterheléséről.

A számtani operátorokat általában számtani műveletekhez használják. Nem jó, ha van a +, illessz két húrot? Ennek engedélyezése állítólag túlterheli az aritmetikai összeadás operátort a húrok számára.

A ++ növekmény operátor 1-et ad hozzá egy int-hez vagy egy float-hoz. Mutatókkal való foglalkozáskor nem ad hozzá 1-et a mutatóhoz. A mutató a memória következő egymást követő objektumára mutat. Az iterátor a csatolt lista következő objektumára mutat, de a csatolt lista objektumai a memória különböző helyein vannak (nem egymást követő régiókban). Nem lenne jó túlterhelni a növekmény operátort egy iterátor számára, hogy növelje, hanem rámutat a következő elemre a linkelt listában?

Ez a cikk elmagyarázza a C túlterhelését++. Két részre oszlik: a funkció túlterhelése és a kezelő túlterhelése. A cikk további részének megértéséhez elengedhetetlen a C ++ nyelvű alapismeretek birtoklása.

A cikk tartalma

Funkció Túlterhelés
Üzemeltető túlterhelése
Példa karakterlánc osztály kezelő túlterhelés
Az Iterator Operator túlterhelése
Következtetés

Funkció Túlterhelés

A következő függvény két intot ad hozzá és int-t ad vissza:

int add (int no1, int no2)

int összeg = no1 + no2;
visszatérési összeg;

Ennek a funkciónak a prototípusa:
int add (int no1, int no2);
A függvény prototípusa a függvény fejlécében, pontosvesszővel végződik. A következő függvény ugyanazzal a névvel, de más prototípussal három úszt adna hozzá, és egy úszt adna vissza:
float add (float no1, float no2, float no3)

úszó összeg = no1 + no2 + no3;
visszatérési összeg;

Hogyan különbözteti meg a fordító, hogy melyik függvényt hívja meg, mivel két vagy több függvénynek ugyanaz a neve? A fordító az argumentumok és argumentumtípusok alapján határozza meg, hogy melyik függvényt hívja meg. A túlterhelt függvények paraméterlistájának számban és / vagy paramétertípusban különböznie kell. Tehát, a függvényhívás,

int sm = add (2, 3);

hívja az egész függvényt, míg a függvény hívja,

lebeg sme = add (2.3, 3.4, 2.0);

az float függvényt hívná meg. Megjegyzés: vannak olyan helyzetek, amikor a fordító elutasítja a túlterhelt függvényt, ha az argumentumok száma megegyezik, de különböző típusúak! - Ok: - lásd később.

A következő program működésbe hozza a fenti kódszegmenseket:

#include
névtér használata std;
int add (int no1, int no2)

int összeg = no1 + no2;
visszatérési összeg;

float add (float no1, float no2, float no3)

úszó összeg = no1 + no2 + no3;
visszatérési összeg;

int main ()

int sm = add (2, 3);
cout<float sme = add (2.3, 3.4, 2.0);
cout<visszatér 0;

A kimenet:
5
7.7

Üzemeltető túlterhelése

Az aritmetikai operátorokat a műveletek túlterhelésére használják osztálytípusokban. Az iterátor osztálytípus. Az inkrementum és decrement operátorok az iterátor műveleteinek túlterhelésére szolgálnak.

Példa karakterlánc osztály kezelő túlterhelés

Ez a szakasz egy példát mutat be, ahol a + túlterhelt egy egyszerűen megtervezett húrosztályhoz, amelyet tavaszi osztálynak nevezünk. + összefűzi két húr objektum literálját, új objektumot ad vissza az összefűzött literálokkal. Két literál összefűzése azt jelenti, hogy a második literált az első literál végéhez illesztjük.

Most a C ++ minden osztály számára rendelkezik egy speciális tag funkcióval, amelyet operátornak hívnak. A programozó használhatja ezt a speciális funkciót az operátorok túlterhelésére, mint pl +. A következő program bemutatja a + operátor túlterhelését két karakterláncra.

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

nyilvános:
// adattagok
char val [100];
int n;
char concat [100];
// tagfunkciók
tavasz (char arr [])

mert (int i = 0; i<100; ++i)
val [i] = arr [i];
if (arr [i] == '\ 0')
szünet;

int i;
mert (i = 0; i<100; ++i) if (arr[i] == '\0') break;
n = i;

rugókezelő + (tavasz & st)
int newLen = n + st.n;
char newStr [newLen + 1];
mert (int i = 0; imert (int i = n; inewStr [newLen] = '\ 0';
tavaszi obj (newStr);
return obj;

;
int main ()

char ch1 [] = "Utállak! "; rugó str1 (ch1);
char ch2 [] = "De szeret!"; rugó str2 (ch2);
char ch3 [] = "egy"; str3 rugó (ch3);
str3 = str1 + str2;
cout<visszatér 0;

Az str1 értéke: "Utállak! ". Az str2 értéke: "De szeret!". Az str3 értéke, vagyis str1 + str2, a kimenet:

"Utállak! De szeret téged!"

amely a két húros literál összefűzése. Maguk a húrok példányosított objektumok.

Az operátorfüggvény meghatározása a karakterlánc osztály leírásán (definícióján) belül található. A visszatérési típussal kezdődik, a "string" "rugó". A különleges név: "operátor, kövesse ezt". Ezután ott van az operátor szimbóluma (túlterhelt). Aztán ott van a paraméterlista, ami valójában az operanduslista. + bináris operátor: vagyis bal és jobb operandusra van szükség. A C ++ specifikáció szerint azonban az itt található paraméterlista csak a megfelelő paraméterrel rendelkezik. Aztán ott van az operátor funkció teste, amely utánozza a szokásos operátor viselkedést.

A C ++ specifikáció szerint a + operátor definíció csak a jobb operandus paramétert veszi fel, mert az osztályleírás többi része a bal operandus paraméter.

A fenti kódban csak az operátor + () függvénydefiníció foglalkozik a + túlterheléssel. Az osztály kódjának többi része normál kódolás. Ezen a definíción belül a két karakterláncot összefűzik a newStr [] tömbbe. Ezt követően egy új string objektum jön létre (példányosítva) egy argumentum segítségével, newStr []. Az operátor + () függvénydefiníció végén az újonnan létrehozott objektum, összefűzött karakterláncával, visszatér.

A main () függvényben az összeadást az alábbi utasítás hajtja végre:

str3 = str1 + str2;

Az str1, str2 és str3 olyan string objektumok, amelyeket már létrehoztak a main (). Az „str1 + str2” kifejezés a + -jával az oper1 + () tag függvényt hívja meg az str1 objektumban. Az operátor + () tagfüggvénye az str1 objektumban az str2-t használja argumentumként, és az összefűzött karakterlánccal (kifejlesztve) adja vissza az új objektumot. A teljes utasítás hozzárendelési operátora (=) az str3 objektum tartalmát (változók értékei) kicseréli a visszaküldött objektum tartalmára. A main () függvényben az összeadás után az str3 adattag értéke.val már nem "egy"; ez az összefűzött (addíciós) húr: "Utállak! De szeret téged!". Az operátor + () tag függvény az str1 objektumban a saját objektumának karakterláncát használja, és az str2 argumentum karakterláncát egy összekapcsolt karakterlánccal áll elő.

Az Iterator Operator túlterhelése

Az iterátorral való foglalkozás során legalább két objektum vesz részt: egy összekapcsolt lista és maga az iterátor. Valójában legalább két osztály vesz részt: egy osztály, amelyből összekapcsolt listát állítanak elő, és egy osztály, amelyből iterátort hoznak létre.

Linkelt lista

A kétszeresen összekapcsolt lista objektum diagramja:

Ennek a listának három eleme van, de több is lehet. A három elem itt egész számok eleme. Az első értéke 14; a következő értéke 88; és az utolsó értéke 47. Minden elem itt három egymást követő helyből áll.

Ez eltér a tömbtől, ahol minden elem egy hely, és az összes tömb elem egymást követő helyeken van. Itt a különböző elemek a memória sorozat különböző helyein vannak, de mindegyik elem három egymást követő helyből áll.

Minden elem esetében a középső hely tartja az értéket. A megfelelő helyre mutató a következő elem. A bal oldalon található az előző elem mutatója. Az utolsó elemnél a megfelelő hely a lista elméleti végére mutat. Az első elemnél a bal oldali hely a lista elméleti kezdetére mutat.

A tömb segítségével az inkrement operátor (++) növeli a mutatót, hogy a fizikailag következő helyre mutasson. A listával az elemek nincsenek egymást követő régiókban a memóriában. Tehát az inkrement operátor túlterhelhető, vigye az iterátort (mutatót) az egyik elemről a logikailag következő elemre. Ugyanez a vetület vonatkozik a decrement operátorra (-).

Az előremenő iterátor olyan iterátor, amelyet bekapcsolva a következő elemre mutat. A fordított iterátor egy iterátor, amely bekapcsolva az előző elemre mutat.

++ hirdetés túlterhelése -

Ezen operátorok túlterhelését az iterátor osztályleírásában (definíciójában) végezzük.

A növekvő operátor túlterhelésének, az előtagnak a prototípusának szintaxisa:

ReturnType operátor ++ ();

A növekvő operátor túlterhelésének, a postfix prototípusának szintaxisa a

ReturnType operátor ++ (int);

A dekrement operátor túlterhelésének, az előtagnak a prototípusának szintaxisa a

ReturnType operátor - ();

A növekvő operátor túlterhelésének, a postfix prototípusának szintaxisa a

ReturnType operátor - (int);

Következtetés

A túlterhelés azt jelenti, hogy egy funkciónak vagy operátornak más jelentést adunk. A funkciók ugyanabban a körben vannak túlterhelve. A túlterhelt funkciókat a paraméterek száma és / vagy típusa különbözteti meg a paraméterlistájukban. Bizonyos esetekben, amikor a paraméterek száma megegyezik, de különböző típusokkal, a fordító elutasítja a túlterhelést - lásd később. Sok hétköznapi operátor túlterhelhető olyan osztályokban, amelyekből az objektumok példányosak. Ez úgy történik, hogy megadunk egy visszatérési típust, paraméterlistát és törzset az operátor nevű speciális függvénynek az osztályleírásban.