Ülekoormus C ++

C ++ ei luba funktsiooni, mis lisab kaks täisarvu ja tagastab täisarvu, kahe ujuki lisamiseks ja ujuki tagastamiseks. Kujutage ette, et on olemas funktsioon kahe täisarvu lisamiseks ja täisarvu tagastamiseks. Kas poleks tore, kui teil oleks mõni teine samanimeline funktsioon, mis ujuki tagastamiseks lisab vaid kaks või isegi rohkem ujukit? Seda tehes öeldakse, et esimese funktsiooni ülekoormamine.

Aritmeetikaoperaatoreid kasutatakse tavaliselt aritmeetilisteks toiminguteks. Kas pole tore, kui teil on +, ühendage kaks stringi? Selle lubamine väidetavalt koormab stringide jaoks aritmeetilise liitmise operaatorit.

Inkrement-operaator ++ lisab int-le või ujukile 1. Kursoritega tegelemisel ei lisata kursorile 1. See paneb kursori osutama järgmisele järjestikusele mälus olevale objektile. Iteraator osutab lingitud loendis järgmisele objektile, kuid lingitud loendi objektid asuvad mälus erinevates kohtades (mitte järjestikustes piirkondades). Kas poleks tore iteraatori juurdekasvuoperaatorit üle koormata, suurendamiseks vaid viidata lingitud loendis järgmisele elemendile?

See artikkel selgitab C-i ülekoormamist++. See on jagatud kaheks osaks: funktsiooni ülekoormamine ja operaatori ülekoormus. Artikli põhiosa mõistmiseks on vaja juba põhiteadmisi C ++ keeles.

Artikli sisu

Funktsioon Ülekoormus
Operaatori ülekoormus
Näide stringiklassi operaatori ülekoormusest
Iteraatori operaatori ülekoormus
Järeldus

Funktsioon Ülekoormus

Järgmine funktsioon lisab kaks inti ja tagastab int:

int lisama (int nr1, int nr2)

int summa = no1 + no2;
tagastussumma;

Selle funktsiooni prototüüp on:
int lisama (int no1, int no2);
Funktsiooni prototüüp funktsiooni päises, lõpeb semikooloniga. Järgmine sama nimega, kuid erineva prototüübiga funktsioon lisaks kolm ujukit ja tagastaks ujuki:
float add (ujuk nr1, ujuk nr2, ujuk nr3)

ujuk summa = no1 + no2 + no3;
tagastussumma;

Kuidas kompilaator eristab, millist funktsiooni kutsuda, kuna kahel või enamal funktsioonil on sama nimi? Koostaja kasutab argumentide arvu ja argumentitüüpe, et määrata, millist funktsiooni kutsuda. Ülekoormatud funktsioonide parameetrite loend peaks erinema nende arvu ja / või parameetrite tüüpide poolest. Niisiis, funktsioonikõne,

int sm = lisama (2, 3);

kutsub funktsiooni täisarv, samal ajal kui funktsioon kutsub,

ujuk sme = lisama (2.3, 3.4, 2.0);

kutsuks ujukfunktsiooni. Märkus: on olukordi, kus kompilaator lükkab ülekoormatud funktsiooni tagasi, kui argumentide arv on sama, kuid erinevat tüüpi! - Põhjus: - vaata hiljem.

Järgmine programm paneb ülaltoodud koodisegmendid toimima:

# kaasata
nimeruumi kasutamine std;
int lisama (int nr1, int nr2)

int summa = no1 + no2;
tagastussumma;

float add (ujuk nr1, ujuk nr2, ujuk nr3)

ujuk summa = no1 + no2 + no3;
tagastussumma;

int main ()

int sm = lisama (2, 3);
cout<ujuk sme = lisama (2.3, 3.4, 2.0);
cout<tagastama 0;

Väljund on:
5
7.7

Operaatori ülekoormus

Aritmeetikaoperaatoreid kasutatakse klassitüüpides toimingute ülekoormamiseks. Iteraator on klassi tüüp. Kasvu- ja vähendusoperaatoreid kasutatakse iteraatori toimingute ülekoormamiseks.

Näide stringiklassi operaatori ülekoormusest

Selles jaotises on näide, kus + on ülekoormatud lihtsalt kujundatud stringiklassile, mida nimetatakse vedruklassiks. + liidab kahe stringiobjekti literaalid, tagastades liidetud literaalidega uue objekti. Kahe literaali liitmine tähendab teise literaali ühendamist esimese literaali lõpuga.

Nüüd on C ++ -s kõigi klasside jaoks spetsiaalne liikmefunktsioon, mida nimetatakse operaatoriks. Programmeerija saab seda erifunktsiooni kasutada operaatorite ülekoormamiseks, näiteks +. Järgmine programm näitab operaatori + ülekoormust kahele stringile.

# kaasata
nimeruumi kasutamine std;
klassi kevad

avalik:
// andmeliikmed
char val [100];
int n;
char concat [100];
// liikme funktsioonid
kevad (char arr [])

jaoks (int i = 0; i<100; ++i)
val [i] = arr [i];
kui (arr [i] == '\ 0')
murda;

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

vedruoperaator + (kevad & st)
int newLen = n + st.n;
char newStr [newLen + 1];
jaoks (int i = 0; ijaoks (int i = n; inewStr [newLen] = '\ 0';
kevadobjekt (newStr);
tagastamise obj;

;
int main ()

char ch1 [] = "Ma vihkan sind! "; vedru str1 (ch1);
char ch2 [] = "Aga ta armastab sind!"; vedru str2 (ch2);
char ch3 [] = "üks"; vedru str3 (ch3);
str3 = str1 + str2;
cout<tagastama 0;

Str1 väärtus on "Ma vihkan sind! ". Str2 väärtus on "Aga ta armastab sind!". Str3 väärtus, mis on str1 + str2, on väljund:

"Ma vihkan sind! Kuid ta armastab sind!"

mis on kahe stringliitali liitmine. Stringid ise on instantiseeritud objektid.

Operaatori funktsiooni määratlus on stringiklassi kirjelduses (määratluses). See algab tagasitüübiga "string" stringile. Erinimi "operaator, järgi seda". Pärast seda on operaatori sümbol (ülekoormatud). Siis on parameetrite loend, mis on tegelikult operandiloend. + on binaaroperaator: see tähendab, et selleks on vaja vasakut ja paremat operandi. Kuid C ++ spetsifikatsiooni järgi on siin parameetrite loendis ainult õige parameeter. Siis on operaatori funktsiooni keha, mis jäljendab operaatori tavalist käitumist.

C ++ spetsifikatsiooni järgi võtab operaatori + määratlus ainult parema operandi parameetri, kuna ülejäänud klassi kirjeldus on vasak operandi parameeter.

Ülaltoodud koodis tegeleb + ülekoormusega ainult operaatori + () funktsiooni määratlus. Klassi ülejäänud kood on tavaline kodeerimine. Selle definitsiooni sees liidetakse kaks stringi literaali massiivi newStr []. Pärast seda luuakse (instantiseeritakse) uus stringiobjekt, kasutades argumenti newStr []. Operaatori + () funktsiooni määratluse lõpus tagastatakse vastloodud stringiga vastloodud objekt.

Funktsioonis main () lisatakse lause abil:

str3 = str1 + str2;

Kus str1, str2 ja str3 on stringiobjektid, mis on juba loodud main (). Avaldis “str1 + str2” oma + -ga kutsub objektil str1 operaatori + () liikme funktsiooni. Funktsioon operaator + () str1-objektis kasutab argumendina str2 ja tagastab uue objekti liidetud stringiga. Täieliku lause omistamisoperaator (=) asendab str3 objekti sisu (muutujate väärtused) tagastatud objekti omaga. Funktsioonis main () lisatakse pärast liitmist andmeliikme str3 väärtus.val pole enam "üks"; see on liidetud (liitmis) string: "Ma vihkan sind! Kuid ta armastab sind!". Funktsioon operaator + () liige str1 objektis kasutab oma objekti stringi litaliiti ja selle argumendi stringiliitrit str2, et tulla välja liidetud stringi litali.

Iteraatori operaatori ülekoormus

Iteraatoriga suheldes on kaasatud vähemalt kaks objekti: lingitud loend ja iteraator ise. Tegelikult on kaasatud vähemalt kaks klassi: klass, millest lingitud loend tehakse, ja klass, kust iteraator on.

Lingitud loend

Topelt lingitud loendi objekti skeem on:

Selles loendis on kolm elementi, kuid neid võib olla rohkem. Kolm elementi on siin täisarvude elemendid. Esimesel on väärtus 14; järgmise väärtus on 88; ja viimasel on väärtus 47. Iga element koosneb siin kolmest järjestikusest asukohast.

See on erinevalt massiivist, kus iga element on üks asukoht ja kõik massiivi elemendid asuvad järjestikustes kohtades. Siin asuvad erinevad elemendid mälusarja erinevates kohtades, kuid iga element koosneb kolmest järjestikusest asukohast.

Iga elemendi jaoks hoiab väärtust keskmine asukoht. Õiges asukohas on kursor järgmisele elemendile. Vasakul asukohal on kursor eelmisele elemendile. Viimase elemendi puhul osutab õige asukoht loendi teoreetilisele lõpule. Esimese elemendi puhul osutab vasak asukoht loendi teoreetilisele algusele.

Massiiviga inkrementeeriv operaator (++) suurendab kursorit füüsiliselt järgmisele asukohale osutamiseks. Loendi puhul ei ole elemendid mälus järjestikustes piirkondades. Seega saab juurdekasvuoperaatorit üle koormata, liigutage iteraator (kursor) ühelt elemendilt loogiliselt järgmisele elemendile. Sama projektsioon kehtib kahanemisoperaatori (-) kohta.

Edasine iteraator on iteraator, mis lülitatuna osutab järgmisele elemendile. Pöörd iteraator on iteraator, mis on sisse lülitatuna osundanud eelmisele elemendile.

++ reklaami ülekoormus -

Nende operaatorite ülekoormamine toimub iteraatori klassi kirjelduses (määratluses).

Kasvukäitleja ülekoormuse, eesliite prototüübi süntaks on

Operaator ReturnType ++ ();

Kasvuoperaatori ülekoormuse, postfixi prototüübi süntaks on

Operaator ReturnType ++ (int);

Dekreetimisoperaatori ülekoormuse, eesliite prototüübi süntaks on

Operaator ReturnType - ();

Kasvuoperaatori ülekoormuse, postfixi prototüübi süntaks on

Operaator ReturnType - (int);

Järeldus

Ülekoormamine tähendab funktsioonile või operaatorile erineva tähenduse andmist. Funktsioonid on samas ulatuses ülekoormatud. Ülekoormatud funktsioone eristab nende parameetrite loendis olevate parameetrite arv ja / või tüübid. Mõnel juhul, kui parameetrite arv on sama, kuid erinevat tüüpi, lükkab kompilaator ülekoormuse tagasi - vt hiljem. Paljusid tavalisi operaatoreid saab klassides, millest objektid on liidetud, üle koormata. Selleks antakse klassi kirjelduses erifunktsioonile operaator nimega return-tüüp, parameetrite loend ja keha.