Phenquestions
Rekenkundige operatoren worden meestal gebruikt voor rekenkundige bewerkingen. Is het niet leuk om de + te hebben, voeg twee strings samen?? Als u dat inschakelt, wordt de rekenkundige opteloperator voor strings overbelast.
De increment-operator, ++ voegt 1 toe aan een int of een float. Bij het omgaan met aanwijzers, wordt er geen 1 aan de aanwijzer toegevoegd. Het laat de aanwijzer naar het volgende opeenvolgende object in het geheugen wijzen. Een iterator wijst naar het volgende object in een gekoppelde lijst, maar de gekoppelde lijstobjecten bevinden zich op verschillende plaatsen in het geheugen (niet in opeenvolgende regio's). Zou het niet leuk zijn om de increment-operator voor een iterator te overbelasten, om te verhogen, maar te wijzen op het volgende element, in de gekoppelde lijst?
Dit artikel legt overbelasting in C . uit++. Het is verdeeld in twee delen: overbelasting van functies en overbelasting van de operator. Het hebben van al basiskennis in C++ is noodzakelijk om de rest van het artikel te begrijpen.
Artikel Inhoud
- Functie Overbelasting
- Overbelasting van de operator
- Voorbeeld String Class Operator Overbelasting
- Overbelasting van iteratoroperator
- Conclusie
Functie Overbelasting
De volgende functie voegt twee ints toe en retourneert een int:
int toevoegen(int no1, int no2)int som = no1 + no2;
terug som;
Het prototype van deze functie is:
int add(int no1, int no2);
Het prototype van een functie in de kop van de functie, eindigend met een puntkomma. De volgende functie met dezelfde naam, maar met een ander prototype, zou drie floats toevoegen en een float retourneren:
float toevoegen (float no1, float no2, float no3)
vlottersom = no1 + no2 + no3;
terug som;
Hoe onderscheidt de compiler welke functie moet worden aangeroepen, aangezien twee of meer functies dezelfde naam hebben?? De compiler gebruikt het aantal argumenten en argumenttypes om te bepalen welke functie moet worden aangeroepen. De parameterlijst van overbelaste functies moet verschillen in aantal en/of parametertypes. Dus de functieaanroep,
int sm = optellen (2, 3);zou de integer-functie aanroepen, terwijl de functie call,
float SME = optellen (2.3, 3.4, 2.0);zou de float-functie aanroepen. Opmerking: er zijn situaties waarin de compiler een overbelaste functie afwijst wanneer het aantal argumenten hetzelfde is, maar van verschillende typen is! - Reden: - zie later.
Het volgende programma zet de bovenstaande codesegmenten in actie:
#includenamespace std; gebruiken;
int toevoegen(int no1, int no2)
int som = no1 + no2;
terug som;
float toevoegen (float no1, float no2, float no3)
vlottersom = no1 + no2 + no3;
terug som;
int hoofd()
int sm = optellen (2, 3);
cout<
cout<
De uitvoer is:
5
7.7
Overbelasting van de operator
Rekenkundige operatoren worden gebruikt om bewerkingen in klassentypen te overbelasten. Een iterator is een klassetype. De increment- en decrement-operators worden gebruikt om bewerkingen voor een iterator te overbelasten.
Voorbeeld String Class Operator Overbelasting
Deze sectie geeft een voorbeeld, waarbij + overbelast is voor een eenvoudig ontworpen snaarklasse, een springklasse genoemd. + voegt de letterlijke waarden van twee tekenreeksobjecten samen en retourneert een nieuw object met de aaneengeschakelde letterlijke waarden. Het aaneenschakelen van twee letterlijke woorden betekent het samenvoegen van de tweede letterlijke aan het einde van de eerste letterlijke.
Nu heeft C++ een speciale lidfunctie voor alle klassen, de operator genaamd. De programmeur kan deze speciale functie gebruiken om operators te overbelasten, zoals: +. Het volgende programma toont de overbelasting van de + operator voor twee strings.
#includenamespace std; gebruiken;
klasse lente
openbaar:
//gegevensleden
char val[100];
int n;
char concat[100];
// ledenfuncties
lente (char arr[])
voor (int i=0; i<100; ++i)
val[i] = arr[i];
if (arr[i] == '\0')
breken;
int ik;
voor (i=0; i<100; ++i) if (arr[i] == '\0') break;
n = ik;
veer operator+(veer& st)
int nieuweLen = n + st.z;
char newStr[newLen+1];
voor (int i=0; i
lente obj(newStr);
retour obj;
;
int hoofd()
char ch1[] = "Ik haat je! "; veer str1(ch1);
char ch2[] = "Maar ze houdt van je!"; veer str2(ch2);
char ch3[] = "één"; veer str3(ch3);
str3 = str1 + str2;
cout<
De waarde van str1 is "Ik haat je! ". De waarde van str2 is "Maar ze houdt van je!". De waarde van str3, dat wil zeggen, str1 + str2, is de uitvoer:
"Ik haat je! Maar ze houdt van je!"
wat de aaneenschakeling is van de twee letterlijke tekenreeksen. De strings zelf zijn geïnstantieerde objecten.
De definitie van de operatorfunctie bevindt zich binnen de beschrijving (definitie) van de tekenreeksklasse. Het begint met het retourtype "spring" voor "string". De speciale naam, "operator, volg dit". Daarna is er het symbool van de bediener (te overbelasten). Dan is er de parameterlijst, die eigenlijk de operandlijst is. + is een binaire operator: wat betekent dat er een linker en een rechter operand nodig zijn. Volgens de C++-specificatie heeft de parameterlijst hier echter alleen de juiste parameter. Dan is er de body van de operatorfunctie, die het gewone operatorgedrag nabootst.
Volgens de C++-specificatie neemt de operatordefinitie + alleen de rechter operandparameter, omdat de rest van de klassebeschrijving de linker operandparameter is.
In de bovenstaande code heeft alleen de functiedefinitie operator+() betrekking op de + overbelasting. De rest van de code voor de klas is normale codering. Binnen deze definitie worden de twee letterlijke tekenreeksen aaneengeschakeld in de array, newStr[]. Daarna wordt er daadwerkelijk een nieuw string-object gemaakt (geïnstantieerd), met behulp van een argument, newStr[]. Aan het einde van de functiedefinitie operator+() wordt het nieuw gemaakte object met de aaneengeschakelde tekenreeks geretourneerd.
In de functie main() wordt de toevoeging gedaan door de instructie:
str3 = str1 + str2;Waarbij str1, str2 en str3 string-objecten zijn die al zijn gemaakt in main(). De uitdrukking, "str1 + str2" met zijn +, roept de operator+() lidfunctie aan in het str1-object. De operator+() lidfunctie in het str1-object gebruikt str2 als argument en retourneert het nieuwe object met (ontwikkelde) de aaneengeschakelde tekenreeks. De toewijzingsoperator (=) van de volledige instructie vervangt de inhoud (waarden van variabelen) van het str3-object door die van het geretourneerde object. In de main()-functie, na toevoeging, de waarde van het gegevenslid str3.val is niet langer "één"; het is de aaneengeschakelde (toevoeging) string, "I hate you! Maar ze houdt van je!". De operator+() lidfunctie in het str1-object, gebruikt de letterlijke tekenreeks van zijn eigen object en de letterlijke tekenreeks van zijn argument, str2 om met een samengevoegde tekenreeks te komen.
Overbelasting van iteratoroperator
Bij het omgaan met de iterator zijn er ten minste twee objecten betrokken: een gekoppelde lijst en de iterator zelf. In feite zijn er ten minste twee klassen bij betrokken: een klasse waaruit een gekoppelde lijst wordt geïnstantieerd en een klasse waaruit een iterator wordt geïnstantieerd.
Gelinkte lijst
Een diagram voor een dubbel gekoppeld lijstobject is:
Deze lijst heeft drie elementen, maar er kunnen er meer zijn. De drie elementen hier zijn elementen van gehele getallen. De eerste heeft de waarde 14; de volgende heeft de waarde 88; en de laatste heeft de waarde, 47. Elk element hier bestaat uit drie opeenvolgende locaties.
Dit is anders dan de array, waar elk element één locatie is en alle arrayelementen zich op opeenvolgende locaties bevinden. Hier bevinden de verschillende elementen zich op verschillende plaatsen in de geheugenreeks, maar elk element bestaat uit drie opeenvolgende locaties.
Voor elk element bevat de middelste locatie de waarde. De juiste locatie heeft de aanwijzer naar het volgende element. De linker locatie heeft de aanwijzer naar het vorige element. Voor het laatste element verwijst de juiste locatie naar een theoretisch einde van de lijst. Voor het eerste element wijst de linker locatie naar een theoretisch begin van de lijst.
Met de array verhoogt de increment-operator (++) de aanwijzer om naar de fysiek volgende locatie te wijzen. Met de lijst bevinden de elementen zich niet in opeenvolgende regio's in het geheugen. Dus de increment-operator kan worden overbelast, verplaats de iterator (aanwijzer) van het ene element naar het logisch volgende element. Dezelfde projectie is van toepassing op de decrement-operator (-).
Een voorwaartse iterator is een iterator die, wanneer ingeschakeld, naar het volgende element wijst. Een omgekeerde iterator is een iterator die, wanneer ingeschakeld, naar het vorige element wijst.
Overbelasting ++ advertentie -
Overbelasting van deze operatoren wordt gedaan in de klassebeschrijving (definitie) van de iterator.
De syntaxis voor het prototype van de increment-operator overbelasting, prefix, is
ReturnType-operator++();De syntaxis voor het prototype van de increment-operator overbelasting, postfix, is
ReturnType-operator ++ (int);De syntaxis voor het prototype van de decrement-operator overbelasting, prefix, is
ReturnType-operator--();De syntaxis voor het prototype van de increment-operator overbelasting, postfix, is
ReturnType-operator--(int);Conclusie
Overbelasting betekent een andere betekenis geven aan een functie of een operator. Functies zijn overbelast in hetzelfde bereik. Wat overbelaste functies onderscheidt, is het aantal en/of typen parameters in hun parameterlijsten. In sommige gevallen, waar het aantal parameters hetzelfde is, maar met verschillende typen, verwerpt de compiler de overbelasting - zie later. Veel gewone operators kunnen worden overbelast in klassen waaruit objecten worden geïnstantieerd. Dit wordt gedaan door een retourtype, parameterlijst en hoofdtekst te geven aan de speciale functie genaamd operator in de klassebeschrijving.
