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. Tenk deg at det er en funksjon å legge til to heltall og returnere et heltall. Ville det ikke være hyggelig å ha en annen funksjon med samme navn, som legger til, men to eller enda flere flyter for å returnere en flottør? Det sies å være å overbelaste den første funksjonen.

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

Inkrementoperatøren ++ legger til 1 til en int eller en float. 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 med koblet liste er forskjellige steder i minnet (ikke i påfølgende regioner). Ville det ikke være fint å overbelaste inkrementoperatøren for en iterator, å inkrementere, men peke på følgende element, i den koblede listen?

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

Artikkelinnhold

Funksjon Overbelastning
Overbelastning av operatør
Eksempel på overbelastning av strengklassoperatør
Overbelastning av operatøroperatør
Konklusjon

Funksjon Overbelastning

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

int add (int no1, int no2)

int sum = no1 + no2;
retur sum;

Prototypen til denne funksjonen er:
int add (int no1, int no2);
Prototypen til en funksjon i toppteksten til funksjonen, og slutter med 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;
retur sum;

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

int sm = add (2, 3);

vil kalle heltalsfunksjonen, mens funksjonen kaller,

flyte sme = legg til (2.3, 3.4, 2.0);

vil kalle flytefunksjonen. 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 omsetter de ovennevnte kodesegmentene til handling:

#inkludere
bruker navneområde std;
int add (int no1, int no2)

int sum = no1 + no2;
retur sum;

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

float sum = no1 + no2 + no3;
retur sum;

int main ()

int sm = add (2, 3);
cout<flyte sme = legg til (2.3, 3.4, 2.0);
cout<retur 0;

Utgangen er:
5
7.7

Overbelastning av operatør

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

Eksempel på overbelastning av strengklassoperatør

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

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

#inkludere
bruker navneområde std;
klasse vår

offentlig:
// data medlemmer
char val [100];
int n;
char concat [100];
// medlemsfunksjoner
vår (char arr [])

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

int i;
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';
våren obj (newStr);
retur obj;

;
int main ()

char ch1 [] = "Jeg hater deg! "; fjærstr1 (ch1);
char ch2 [] = "Men hun elsker deg!"; fjærstr2 (ch2);
char ch3 [] = "en"; vårstr3 (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 sammenkoblingen av de to strenglitteraturene. Strengene i seg selv er instantierte gjenstander.

Definisjonen av operatørfunksjonen er inne i beskrivelsen (definisjonen) av strengklassen. Det begynner med returtypen "vår" for "streng". Det spesielle navnet "operatør, følg dette". Etter det er det symbolet til operatøren (som skal overbelastes). Så er det parameterlisten, som faktisk er operandlisten. + er en binær operatør: betyr at det tar en venstre og en høyre operand. Imidlertid, etter C ++ spesifikasjonen, har parameterlisten her bare riktig parameter. Så er det kroppen til operatørfunksjonen, som etterligner den vanlige operatøratferden.

Ved C ++ spesifikasjonen tar + operatørdefinisjonen bare riktig operandparameter, fordi resten av klassebeskrivelsen er venstre operandparameter.

I koden ovenfor er bare operatør + () -funksjonsdefinisjonen opptatt av + overbelastning. Resten av koden for klassen er normal koding. Inne i denne definisjonen er de to strenglitteraturene sammenkoblet til matrisen, newStr []. Etter det blir et nytt strengobjekt faktisk opprettet (instantiert), ved hjelp av et argument, newStr []. På slutten av funksjonsdefinisjonen for operator + () returneres det nyopprettede objektet med den sammenkoblede strengen.

I hovedfunksjonen () gjøres tillegget av uttalelsen:

str3 = str1 + str2;

Hvor str1, str2 og str3 er strengobjekter som allerede er opprettet i main (). Uttrykket “str1 + str2” med dets +, kaller operatøren + () medlemsfunksjon i str1-objektet. Operatør + () medlemsfunksjon i str1-objektet bruker str2 som argument og returnerer det nye objektet med (utviklet) den sammenhengende strengen. Oppdragsoperatøren (=) for den komplette setningen, erstatter innholdet (verdier av variabler) til str3-objektet, med de for det returnerte objektet. I hovedfunksjonen (), etter tillegg, verdien av dataelementet str3.val er ikke lenger "ett"; det er den sammenhengende (tilleggs) streng, "Jeg hater deg! Men hun elsker deg!". Operatør + () medlemsfunksjon i str1-objektet, bruker sitt eget objekts strenge bokstavelige, og strengen bokstavelig i argumentet, str2 for å komme opp med en sammenføyet streng bokstavelig.

Overbelastning av operatøroperatør

Når det gjelder iteratoren, er minst to objekter involvert: en koblet liste og selve iteratoren. Faktisk er minst to klasser involvert: en klasse som en koblet-liste er instantiert fra, og en klasse som en iterator er instantiert fra.

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 av 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, hvor hvert element er ett sted, og alle matriseelementene er påfølgende steder. Her er de forskjellige elementene forskjellige steder i minneserien, men hvert element består av tre påfølgende steder.

For hvert element inneholder midtplasseringen verdien. Den rette plasseringen har pekeren til neste element. Den venstre plasseringen har pekeren til forrige element. For det siste elementet peker riktig plassering mot en teoretisk slutt på listen. For det første elementet peker venstre plassering til en teoretisk start på listen.

Med matrisen, inkrementoperatoren (++), øker pekeren for å peke på det fysisk neste stedet. Med listen er elementene ikke i påfølgende regioner i minnet. Så økningsoperatøren kan bli overbelastet, flytt iteratoren (pekeren) fra ett element til det logisk neste elementet. Den samme projeksjonen gjelder for reduksjonsoperatøren (-).

En fremover iterator er en iterator som peker på neste element når den er engasjert. En revers iterator er en iterator som peker på forrige element når den er engasjert.

Overbelastning ++ annonse -

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

Syntaksen for prototypen til overbelastning av trinnoperatøren, er prefiks

ReturnType-operatør ++ ();

Syntaksen for prototypen til overbelastning av trinnoperatøren, postfix, er

ReturnType-operatør ++ (int);

Syntaksen for prototypen til degrementoperatøren overbelastning, prefiks, er

ReturnType-operatør - ();

Syntaksen for prototypen til overbelastning av trinnoperatøren, postfix, er

ReturnType-operatør - (int);

Konklusjon

Overbelastning betyr å gi en annen betydning til en funksjon eller en operatør. Funksjoner er overbelastet i samme omfang. Det som skiller overbelastede funksjoner er antall og / eller typer parametere i deres parameterlister. I noen tilfeller, hvor antall parametere er det samme, men med forskjellige typer, avviser kompilatoren overbelastningen - se senere. Mange vanlige operatører kan overbelastes i klasser som gjenstander blir gjenstand for. Dette gjøres ved å gi en returtype, parameterliste og brødtekst til den spesielle funksjonen som heter operatør i klassebeskrivelsen.