Overbelastning i C ++

C ++ tillater ikke en funksjon som legger til to heltall og returnerer et heltall, for å legge til to flottører og returnere en flottør. Se for deg at det er en funksjon for å legge til to heltall og returnere et heltall. Ville det ikke være fint å ha en annen funksjon med samme navn, som legger til bare to eller enda flere flyter for å returnere en flottør? Å gjøre det sies å være å overbelaste den første funksjonen.

Aritmetiske operatører brukes vanligvis til aritmetiske operasjoner. Er det ikke hyggelig å ha +, bli med i to strenger? Aktivering som sies å overbelaste den aritmetiske tilleggsoperatøren, for strenger.

Økningsoperatøren, ++ legger 1 til en int eller en flottør. Når du arbeider med pekere, legger den ikke 1 til pekeren. Det får pekeren til å peke på neste påfølgende objekt i minnet. En iterator peker på neste objekt i en koblet liste, men objektene for koblet liste er forskjellige steder i minnet (ikke i påfølgende regioner). Ville det ikke være fint å overbelaste økningsoperatøren for en iterator, å øke, men peke på følgende element, i den koblede listen?

Denne artikkelen forklarer overbelastning i C++. Det er delt inn i to deler: Funksjonsoverbelastning og overbelastning av operatøren. Å ha allerede grunnleggende kunnskap i C ++ er nødvendig for å forstå resten av artikkelen.

Artikkelinnhold

• Funksjon overbelastning
• Operatøroverbelastning
• Eksempel Strengklasse Operatøroverbelastning
• Iteratoroperatøroverbelastning
• Konklusjon

Funksjon overbelastning

Følgende funksjon legger til to INT og returnerer en int:

int add (int no1, int no2)

int sum = NO1 + NO2;
retursum;

Prototypen til denne funksjonen er:

int add (int no1, int no2);

Prototypen til en funksjon i funksjonen til funksjonen, og slutter med en semikolon. Følgende funksjon med samme navn, men med en annen prototype, vil legge til tre flottører og returnere en flottør:

Float Add (Float No1, Float No2, Float No3)

Float Sum = NO1 + NO2 + NO3;
retursum;

Hvordan skiller kompilatoren hvilken som fungerer som den skal ringe, siden to eller flere funksjoner har samme navn? Kompilatoren bruker antall argumenter og argumenttyper for å bestemme hvilken funksjon du skal ringe. Parameterlisten over overbelastede funksjoner skal variere i antall og/eller parametertyper. Så funksjonsanropet,

int sm = legg til (2, 3);

ville kalle heltallfunksjonen, mens funksjonsanropet,

Float SME = Legg til (2.3, 3.4, 2.0);

ville kalle float -funksjonen. Merk: Det er situasjoner der kompilatoren vil avvise en overbelastet funksjon når antall argumenter er det samme, men av forskjellige typer! - Årsak: - Se senere.

Følgende program setter ovennevnte kodesegmenter i verk:

#inkludere
ved hjelp av navneområdet STD;
int add (int no1, int no2)

int sum = NO1 + NO2;
retursum;

Float Add (Float No1, Float No2, Float No3)

Float Sum = NO1 + NO2 + NO3;
retursum;

int main ()

int sm = legg til (2, 3);
cout<Float SME = Legg til (2.3, 3.4, 2.0);
cout<retur 0;

Utgangen er:

5
7.7

Operatøroverbelastning

Aritmetiske operatører brukes til å overbelaste operasjoner i klassetyper. En iterator er en klassetype. Økningen og decrement -operatørene brukes til å overbelaste operasjoner for en iterator.

Eksempel Strengklasse Operatøroverbelastning

Denne delen gir et eksempel, der + er overbelastet for en enkelt designet strengklasse, kalt en vårklasse. + samvirke litteraturene til to strengobjekter, og returnerer et nytt objekt med de sammenkoblede bokstavene. Sammenhengende to bokstaver betyr å bli med den andre bokstavelige til slutten av den første bokstavelige.

Nå har C ++ en spesiell medlemsfunksjon for alle klasser, kalt operatøren. Programmereren kan bruke denne spesielle funksjonen til å overbelaste operatører, for eksempel +. Følgende program viser overbelastning av + -operatøren for to strenger.

#inkludere
ved hjelp av navneområdet STD;
Klasse våren

offentlig:
// Datamedlemmer
Char Val [100];
int n;
char concat [100];
// medlemsfunksjoner
Spring (Char arr [])

for (int i = 0; i<100; ++i)
val [i] = arr [i];
if (arr [i] == '\ 0')
gå i stykker;

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

Spring Operator+(Spring & St)
int newlen = n + st.n;
Char NewsTr [Newlen+1];
for (int i = 0; ifor (int i = n; iNewsTr [newlen] = '\ 0';
Spring OBJ (Newstr);
returner obj;

;
int main ()

char ch1 [] = "Jeg hater deg! "; Spring Str1 (CH1);
char ch2 [] = "men hun elsker deg!"; Spring Str2 (CH2);
char ch3 [] = "en"; Spring Str3 (CH3);
str3 = str1 + str2;
cout<retur 0;

Verdien av str1 er "Jeg hater deg! "". Verdien av str2 er "men hun elsker deg!"". Verdien av STR3, som er, Str1 + Str2, er utgangen:

"Jeg hater deg! Men hun elsker deg!""

som er sammenkobling av de to strenglitteralene. Strengene i seg selv er instantierte objekter.

Definisjonen av operatørfunksjonen er inne i beskrivelsen (definisjonen) av strengklassen. Det begynner med returtypen, "Spring" for "String". Spesialnavnet, "Operatør, følg dette". Etter det er det symbolet på operatøren (for å bli overbelastet). Så er det parameterlisten, som faktisk er operandlisten. + er en binær operatør: noe som betyr at det tar en venstre og en høyre operand. Imidlertid har parameterlisten her bare den rette parameteren C ++. Så er det kroppen til operatørfunksjonen, som etterligner den vanlige operatørens oppførsel.

Ved C ++ -spesifikasjonen tar definisjonen av+ operatør bare den rette operandparameteren, fordi resten av klassebeskrivelsen er parameteren til venstre operand.

I ovennevnte kode er det bare operatøren + () funksjonsdefinisjonen, som er opptatt av + overbelastning. Resten av koden for klassen er normal koding. Inne i denne definisjonen blir de to strenglitteralene sammenkoblet i matrisen, NewsTr []. Etter det opprettes et nytt strengobjekt faktisk (instantiert), ved hjelp av et argument, NewsTr []. På slutten av operatøren+() -funksjonsdefinisjonen blir det nyopprettede objektet, med den sammenkoblede strengen, returnert.

I hovedfunksjonen () utføres tillegget ved uttalelsen:

str3 = str1 + str2;

Hvor Str1, Str2 og STR3 er strengobjekter som allerede er opprettet i Main (). Uttrykket, “str1 +str2” med sin +, kaller operatøren +() medlemsfunksjon i STR1 -objektet. Operatøren+() medlemsfunksjon i STR1 -objektet bruker STR2 som argument og returnerer det nye objektet med (utviklet) den sammenkoblede strengen. Oppdragsoperatøren (=) i den komplette uttalelsen, erstatter innholdet (verdiene til variabler) til STR3 -objektet, med de av det returnerte objektet. I hovedfunksjonen (), etter tillegg, verdien av datamedlemmet STR3.Val er ikke lenger "en"; Det er den sammenkoblede (tilleggs) strengen, "Jeg hater deg! Men hun elsker deg!"". Operatøren+() medlemsfunksjon i STR1 -objektet bruker sitt eget objekts streng bokstavelig, og strengen bokstavelig av argumentet, Str2 for å komme med en sammenføyd streng bokstavelig.

Iteratoroperatøroverbelastning

Når du arbeider med iteratoren, er minst to objekter involvert: en koblet liste og iteratoren selv. Faktisk er minst to klasser involvert: en klasse som en koblet liste er instantiert fra, og en klasse som en iterator er instantiert.

Koblet liste

Et diagram for et dobbelt koblet listeobjekt er:

Denne listen har tre elementer, men det kan være flere. De tre elementene her er elementer i heltall. Den første har verdien, 14; Den neste har verdien, 88; og den siste har verdien, 47. Hvert element her består av tre påfølgende steder.

Dette er i motsetning til matrisen, der hvert element er ett sted, og alle matriseelementene er på sammenhengende steder. Her er de forskjellige elementene forskjellige steder i minneserien, men hvert element består av tre påfølgende steder.

For hvert element holder den midterste plasseringen verdien. Riktig plassering har pekeren til neste element. Venstre plassering har pekeren til det forrige elementet. For det siste elementet peker det rette stedet på en teoretisk ende av listen. For det første elementet peker venstre plassering på en teoretisk start av listen.

Med matrisen, trinn som trinnsutstyr (++), øker pekeren for å peke på det fysisk neste stedet. Med listen er ikke elementene i påfølgende regioner i minnet. Så økt operatøren kan overbelastes, flytte iteratoren (pekeren) fra ett element til det logisk neste elementet. Den samme projeksjonen gjelder for Dekrementoperatøren (-).

En fremover iterator er en iterator som når den er engasjert, peker på neste element. En omvendt iterator er en iterator, som når den er engasjert, peker på det forrige elementet.

Overbelastning ++ annonse -

Overbelastning av disse operatørene gjøres i klassebeskrivelsen (definisjonen) av iteratoren.

Syntaksen for prototypen til økt operatøroverbelastning, prefiks, er

ReturnType operatør ++ ();

Syntaksen for prototypen til økt operatøroverbelastning, postfix, er

ReturnType operatør ++ (int);

Syntaksen for prototypen til overbelastning av reduksjonsoperatør, prefiks, er

Returtype operatør-();

Syntaksen for prototypen til økt operatøroverbelastning, postfix, er

Returtype operatør-(int);

Konklusjon

Overbelastning betyr å gi en annen betydning for en funksjon eller en operatør. Funksjonene er overbelastet i samme omfang. Hva som skiller overbelastede funksjoner er antall og/eller typer parametere i parameterlistene deres. I noen tilfeller, der antallet på parametrene er det samme, men med forskjellige typer, avviser kompilatoren overbelastningen - se senere. Mange vanlige operatører kan overbelastes i klasser fra hvilke objekter blir instantiert. Dette gjøres ved å gi en returtype, parameterliste og kropp, til den spesielle funksjonen som er navngitt, operatør, i klassebeskrivelsen.