Ylikuormitus C ++

C ++ ei salli funktiota, joka lisää kaksi kokonaislukua ja palauttaa kokonaisluvun, lisätä kaksi kelluketta ja palauttaa kelluvan. Kuvittele, että on funktio lisätä kaksi kokonaislukua ja palauttaa kokonaisluku. Eikö olisikaan mukavaa saada toinen toiminto samalla nimellä, joka lisää vain kaksi tai jopa useampia kellukkeita palauttamaan kelluvan? Näin sanotaan olevan ylikuormitettu ensimmäinen toiminto.

Aritmeettisia operaattoreita käytetään tyypillisesti aritmeettisiin operaatioihin. Eikö ole mukavaa saada +, yhdistä kaksi merkkijonoa? Tämän sallimisen sanotaan ylikuormittavan aritmeettisen lisäysoperaattorin merkkijonoja varten.

Inkrementtioperaattori ++ lisää 1 int: iin tai floatiin. Kun käsitellään osoittimia, se ei lisää 1 osoittimeen. Se saa osoittimen osoittamaan seuraavaa peräkkäistä muistissa olevaa kohdetta. Iteraattori osoittaa linkitetyn luettelon seuraavaan objektiin, mutta linkitetyn luettelon objektit ovat muistin eri paikoissa (ei peräkkäisillä alueilla). Eikö olisi mukavaa ylikuormittaa iteraattorin lisäysoperaattoria, lisätä, mutta osoittaa linkitettyyn luetteloon seuraavaa elementtiä?

Tässä artikkelissa selitetään C: n ylikuormitus++. Se on jaettu kahteen osaan: toimintojen ylikuormitus ja käyttäjän ylikuormitus. Jo perustiedot C ++: ssa on välttämätöntä artikkelin loppuosan ymmärtämiseksi.

Artikkelin sisältö

Toiminto Ylikuormitus
Kuljettajan ylikuormitus
Esimerkki merkkijono-luokan operaattorin ylikuormituksesta
Iteraattorioperaattorin ylikuormitus
Johtopäätös

Toiminto Ylikuormitus

Seuraava funktio lisää kaksi intia ja palauttaa int:

int lisää (int no1, int no2)

int summa = no1 + ei2;
paluusumma;

Tämän toiminnon prototyyppi on:
int lisää (int no1, int no2);
Funktion prototyyppi funktion otsikossa, päättyen puolipisteeseen. Seuraava funktio, jolla on sama nimi, mutta jolla on erilainen prototyyppi, lisäisi kolme kelluketta ja palauttaisi kellukkeen:
float add (kelluva no1, float no2, float no3)

kelluva summa = no1 + no2 + no3;
paluusumma;

Kuinka kääntäjä erottaa kutsuttavan funktion, koska kahdella tai useammalla toiminnolla on sama nimi? Kääntäjä käyttää argumenttien määrää ja argumenttityyppejä määrittääkseen, minkä toiminnon kutsutaan. Ylikuormitettujen toimintojen parametriluettelon tulisi olla erilainen lukumääränsä ja / tai parametrityyppiensä mukaan. Joten, toimintokutsu,

int sm = lisää (2, 3);

kutsuisi kokonaislukufunktion, kun taas funktio kutsuu,

float sme = lisää (2.3, 3.4, 2.0);

kutsuisi float-funktion. Huomaa: on tilanteita, joissa kääntäjä hylkää ylikuormitetun funktion, kun argumenttien määrä on sama, mutta erityyppinen! - Syy: - katso myöhemmin.

Seuraava ohjelma panee yllä mainitut koodisegmentit toimintaan:

#sisältää
käyttämällä nimitilaa vakio;
int lisää (int no1, int no2)

int summa = no1 + ei2;
paluusumma;

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

kelluva summa = no1 + no2 + no3;
paluusumma;

int main ()

int sm = lisää (2, 3);
cout<float sme = lisää (2.3, 3.4, 2.0);
cout<paluu 0;

Tuotos on:
5
7.7

Kuljettajan ylikuormitus

Aritmeettisia operaattoreita käytetään ylikuormittamaan operaatioita luokkatyypeissä. Iteraattori on luokkatyyppi. Inkrementti- ja vähennysoperaattoreita käytetään iteraattorin toimintojen ylikuormittamiseen.

Esimerkki merkkijono-luokan operaattorin ylikuormituksesta

Tässä osassa on esimerkki, jossa + on ylikuormitettu yksinkertaisesti suunnitellulle merkkijonoluokalle, jota kutsutaan jousiluokaksi. + ketjuttaa kahden merkkijono-objektin literaalit ja palauttaa uuden objektin liitettyjen literaalien kanssa. Kahden literaalin yhdistäminen tarkoittaa toisen literaalin liittämistä ensimmäisen literaalin loppuun.

Nyt C ++: lla on erityinen jäsenfunktio kaikille luokille, jota kutsutaan operaattoriksi. Ohjelmoija voi käyttää tätä erikoistoimintoa ylikuormittamaan operaattoreita, kuten +. Seuraava ohjelma näyttää + -operaattorin ylikuormituksen kahdelle merkkijonolle.

#sisältää
käyttämällä nimitilaa vakio;
luokan kevät

julkinen:
// datajäsenet
char val [100];
int n;
char concat [100];
// jäsenfunktiot
kevät (char arr [])

varten (int i = 0; i<100; ++i)
val [i] = arr [i];
jos (arr [i] == '\ 0')
tauko;

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

jousioperaattori + (kevät & st)
int uusiLen = n + st.n;
char newStr [uusiLen + 1];
varten (int i = 0; ifor (int i = n; inewStr [newLen] = '\ 0';
kevään obj (newStr);
palata obj;

;
int main ()

char ch1 [] = "Vihaan sinua! "; jousi str1 (ch1);
char ch2 [] = "Mutta hän rakastaa sinua!"; jousi str2 (ch2);
char ch3 [] = "yksi"; jousi str3 (ch3);
str3 = str1 + str2;
cout<paluu 0;

Str1: n arvo on "Vihaan sinua! ". Str2: n arvo on "Mutta hän rakastaa sinua!". Str3: n arvo, joka on str1 + str2, on lähtö:

"Vihaan sinua! Mutta hän rakastaa sinua!"

mikä on kahden merkkijonon literaalin ketjutus. Jouset itsessään ovat instantioituja esineitä.

Operaattoritoiminnon määritelmä on merkkijonoluokan kuvauksen (määritelmän) sisällä. Se alkaa palautustyypillä "jousi" sanalle "merkkijono". Erityisnimi "operaattori, seuraa tätä". Sen jälkeen on käyttäjän symboli (ylikuormitettu). Sitten on parametriluettelo, joka on itse asiassa operandiluettelo. + on binäärioperaattori: mikä tarkoittaa, että se vaatii vasemman ja oikean operandin. C ++ -määrityksen mukaan tässä parametriluettelossa on kuitenkin vain oikea parametri. Sitten on operaattoritoiminnon runko, joka jäljittelee käyttäjän tavallista käyttäytymistä.

C ++ -määrityksen mukaan operaattorin + määritelmä ottaa vain oikean operandiparametrin, koska loput luokan kuvauksesta ovat vasemman operandin parametrit.

Yllä olevassa koodissa vain operaattorin + () funktion määrittely koskee + ylikuormitusta. Loput luokan koodista ovat normaalia koodausta. Tämän määritelmän sisällä kaksi merkkijonolitraalia liitetään taulukkoon newStr []. Sen jälkeen uusi merkkijono-objekti luodaan (instantioidaan) argumentin newStr [] avulla. Operaattori + () -funktion määrityksen lopussa vasta luotu objekti, jossa on ketjutettu merkkijono, palautetaan.

Main () -funktiossa lisäys tehdään lauseella:

str3 = str1 + str2;

Missä str1, str2 ja str3 ovat merkkijono-objekteja, jotka on jo luotu main (). Lauseke “str1 + str2” +: lla kutsuu operaattorin + () jäsenfunktion str1-objektista. Str1-objektin operaattori + () -jäsenfunktio käyttää argumenttina str2 ja palauttaa uuden objektin ketjutetulla merkkijonolla (kehitetty). Täydellisen käskyn määritysoperaattori (=) korvaa str3-objektin sisällön (muuttujien arvot) palautetun objektin sisällöllä. Main () -funktiossa lisäyksen jälkeen datajäsenen str3 arvo.val ei ole enää "yksi"; se on ketjutettu (lisäys) merkkijono: "Vihaan sinua! Mutta hän rakastaa sinua!". Operaattori + () jäsenfunktio str1-objektissa käyttää oman objektin merkkijonolitraalia ja argumenttinsa merkkijono-literaali str2 keksimään liitetyn merkkijonolitraalin.

Iteraattorioperaattorin ylikuormitus

Kun käsitellään iteraattoria, mukana on ainakin kaksi objektia: linkitetty luettelo ja itse iteraattori. Itse asiassa mukana on vähintään kaksi luokkaa: luokka, josta linkitetty luettelo on instantoitu, ja luokka, josta iteraattori on instantoitu.

Linkitetty luettelo

Kaksinkertaisesti linkitetyn luettelon objektin kaavio on:

Tässä luettelossa on kolme elementtiä, mutta niitä voi olla enemmän. Kolme elementtiä ovat kokonaislukujen elementtejä. Ensimmäisellä on arvo 14; seuraavalla on arvo 88; ja viimeisellä on arvo 47. Jokainen elementti koostuu kolmesta peräkkäisestä sijainnista.

Tämä on toisin kuin matriisi, jossa kukin elementti on yksi paikka, ja kaikki matriisi-elementit ovat peräkkäisissä sijainneissa. Tässä eri elementit ovat eri paikoissa muistisarjassa, mutta jokainen elementti koostuu kolmesta peräkkäisestä sijainnista.

Jokaisen elementin keskimmäinen sijainti pitää arvon. Oikealla paikalla on osoitin seuraavaan elementtiin. Vasemmassa paikassa on osoitin edelliseen elementtiin. Viimeisen elementin kohdalla oikea sijainti osoittaa luettelon teoreettiseen päähän. Ensimmäisen elementin vasen sijainti osoittaa luettelon teoreettista alkua.

Taulukon avulla kasvainoperaattori (++) lisää osoitinta osoittamaan fyysisesti seuraavaan sijaintiin. Luettelon avulla elementit eivät ole peräkkäisillä alueilla muistissa. Joten lisäysoperaattori voidaan ylikuormittaa, siirrä iteraattori (osoitin) yhdestä elementistä loogisesti seuraavaan elementtiin. Sama projektio koskee vähennysoperaattoria (-).

Eteenpäin iteraattori on iteraattori, joka kytkettynä osoittaa seuraavaan elementtiin. Käänteinen iteraattori on iteraattori, joka kytkettynä osoittaa edelliseen elementtiin.

++ mainoksen ylikuormitus -

Näiden operaattoreiden ylikuormitus tapahtuu iteraattorin luokan kuvauksessa (määritelmässä).

Lisäoperaattorin ylikuormituksen, etuliitteen prototyypin syntakse on

ReturnType-operaattori ++ ();

Lisäoperaattorin ylikuormituksen, postfixin, prototyypin syntaksia on

ReturnType-operaattori ++ (int);

Vähennysoperaattorin ylikuormituksen prototyypin syntaksin etuliite on

ReturnType-operaattori - ();

Lisäoperaattorin ylikuormituksen, postfixin, prototyypin syntaksia on

ReturnType-operaattori - (int);

Johtopäätös

Ylikuormitus tarkoittaa eri merkityksen antamista toiminnolle tai operaattorille. Toiminnot ovat ylikuormitettuja samassa laajuudessa. Ylikuormitetut toiminnot erottavat parametrien lukumäärän ja / tai tyypit niiden parametriluetteloissa. Joissakin tapauksissa, joissa parametrien lukumäärä on sama, mutta eri tyypeillä, kääntäjä hylkää ylikuormituksen - katso myöhemmin. Monet tavalliset operaattorit voivat olla ylikuormitettuja luokkiin, joista objektit ovat instantioitu. Tämä tehdään antamalla palautustyyppi, parametriluettelo ja runko luokan kuvauksessa erityistoiminnolle nimeltä operaattori.