i C++ er operatøroverbelastning en kompileringstidspolymorfi. Det er en idé om at give en speciel betydning til en eksisterende operator i C++ uden at ændre dens oprindelige betydning.
I denne artikel vil vi yderligere diskutere om operatøroverbelastning i C++ med eksempler og se, hvilke operatører vi kan eller ikke kan overbelaste i C++.
C++ Operatør Overbelastning
C++ har evnen til at give operatørerne en særlig betydning for en datatype, denne evne er kendt som operatøroverbelastning. Operatøroverbelastning er en kompileringstidspolymorfi. For eksempel kan vi overbelaste en operator '+' i en klasse som String, så vi kan sammenkæde to strenge ved blot at bruge +. Andre eksempelklasser, hvor aritmetiske operatorer kan være overbelastet, er komplekse tal, brøktal, store heltal osv.
Eksempel:
int a; float b,sum; sum = a + b;>
Her er variable a og b af typerne int og float, som er indbyggede datatyper. Derfor kan tilføjelsesoperatoren '+' nemt tilføje indholdet af a og b. Dette skyldes, at additionsoperatoren + er foruddefineret til kun at tilføje variabler af indbygget datatype.
Implementering:
C++
// C++ Program to Demonstrate the> // working/Logic behind Operator> // Overloading> class> A {> >statements;> };> int> main()> {> >A a1, a2, a3;> >a3 = a1 + a2;> >return> 0;> }> |
>
linux kørselskommando
>
I dette eksempel har vi 3 variabler a1, a2 og a3 af type klasse A. Her forsøger vi at tilføje to objekter a1 og a2, som er af brugerdefineret type, dvs. af type klasse A ved hjælp af + operatoren. Dette er ikke tilladt, fordi tilføjelsesoperatøren + er foruddefineret til kun at fungere på indbyggede datatyper. Men her er klasse A en brugerdefineret type, så compileren genererer en fejl. Det er her, konceptet med operatøroverbelastning kommer ind i billedet.
Nu, hvis brugeren ønsker at få operatoren + til at tilføje to klasseobjekter, skal brugeren omdefinere betydningen af + operatoren, således at den tilføjer to klasseobjekter. Dette gøres ved at bruge konceptet Operator overloading. Så hovedideen bag Operator-overbelastning er at bruge C++-operatorer med klassevariable eller klasseobjekter. At omdefinere betydningen af operatorer ændrer virkelig ikke deres oprindelige betydning; i stedet har de fået yderligere betydning sammen med deres eksisterende.
Eksempel på operatøroverbelastning i C++
C++
// C++ Program to Demonstrate> // Operator Overloading> #include> using> namespace> std;> class> Complex {> private>:> >int> real, imag;> public>:> >Complex(>int> r = 0,>int> i = 0)> >{> >real = r;> >imag = i;> >}> >// This is automatically called when '+' is used with> >// between two Complex objects> >Complex operator+(Complex>const>& obj)> >{> >Complex res;> >res.real = real + obj.real;> >res.imag = imag + obj.imag;> >return> res;> >}> >void> print() { cout << real <<>' + i'> << imag <<>'
'>; }> };> int> main()> {> >Complex c1(10, 5), c2(2, 4);> >Complex c3 = c1 + c2;> >c3.print();> }> |
>
>Produktion
privat vs offentlig java
12 + i9>
Forskellen mellem operatørfunktioner og normale funktioner
Operatørfunktioner er de samme som normale funktioner. De eneste forskelle er, at navnet på en operatørfunktion altid er operatør søgeord efterfulgt af symbolet for operatøren, og operatørfunktioner kaldes, når den tilsvarende operatør bruges.
Eksempel
C++
#include> using> namespace> std;> class> Complex {> private>:> >int> real, imag;> public>:> >Complex(>int> r = 0,>int> i = 0)> >{> >real = r;> >imag = i;> >}> >void> print() { cout << real <<>' + i'> << imag << endl; }> >// The global operator function is made friend of this> >// class so that it can access private members> >friend> Complex operator+(Complex>const>& c1,> >Complex>const>& c2);> };> Complex operator+(Complex>const>& c1, Complex>const>& c2)> {> >return> Complex(c1.real + c2.real, c1.imag + c2.imag);> }> int> main()> {> >Complex c1(10, 5), c2(2, 4);> >Complex c3> >= c1> >+ c2;>// An example call to 'operator+'> >c3.print();> >return> 0;> }> |
>
>Produktion
12 + i9>
Kan vi overbelaste alle operatører?
Næsten alle operatører kan overbelastes på nær nogle få. Følgende er listen over operatører, der ikke kan overbelastes.
sizeof typeid Scope resolution (::) Class member access operators (.(dot), .* (pointer to member operator)) Ternary or conditional (?:)>
Operatører, der kan overbelastes i C++
Vi kan overbelaste
Unære operatorer Binære operatorer Specielle operatorer ( [ ], () osv.)
Men blandt dem er der nogle operatører, der ikke kan overbelastes. De er
Scope resolution operator (: Medlemsvalg operatør Medlemsvalg gennem *
Markør til en medlemsvariabel
- Betinget operator (? Sizeof operator sizeof()
| Operatører, der kan overbelastes | Eksempler |
|---|---|
| Binær aritmetik | +, -, *, /, % |
| Unær aritmetik | +, -, ++, — |
| Opgave | =, +=,*=, /=,-=, %= |
| Bitvis | &, | , <> , ~ , ^ |
| De-reference | (->) |
| Dynamisk hukommelsestildeling, De-allokering | Ny, slet |
| Subscript | [ ] |
| Funktionsopkald | () |
| Logisk | &, | |,! |
| Relationel | >, <, = =, = |
Hvorfor kan de ovennævnte operatører ikke overbelastes?
1. operatørens størrelse
Dette returnerer størrelsen af objektet eller datatypen, der er indtastet som operanden. Dette evalueres af compileren og kan ikke evalueres under kørsel. Den korrekte inkrementering af en pointer i en række objekter afhænger implicit af operatorens størrelse. Ændring af dets betydning ved hjælp af overbelastning ville få en grundlæggende del af sproget til at kollapse.
java liste streng
2. typeid Operatør
Dette giver et CPP-program mulighed for at gendanne den faktisk afledte type af objektet, der henvises til med en pointer eller reference. For denne operatør er hele pointen at identificere en type unikt. Hvis vi ønsker at få en brugerdefineret type til at 'ligne' en anden type, kan polymorfi bruges, men betydningen af typeid-operatoren skal forblive uændret, ellers kan der opstå alvorlige problemer.
3. Scope resolution (::) Operatør
Dette hjælper med at identificere og specificere den kontekst, som en identifikator refererer til, ved at angive et navneområde. Det evalueres fuldstændigt under kørsel og arbejder på navne frem for værdier. Operanderne for scope-opløsning er noteudtryk med datatyper, og CPP har ingen syntaks til at fange dem, hvis det var overbelastet. Så det er syntaktisk umuligt at overbelaste denne operatør.
4. Klassemedlemsadgangsoperatører (.(dot ), .* (peger til medlemsoperatør))
Betydningen og den implicitte brug af klassemedlemsadgangsoperatører kan forstås gennem følgende eksempel:
Eksempel:
C++
// C++ program to demonstrate operator overloading> // using dot operator> #include> using> namespace> std;> class> ComplexNumber {> private>:> >int> real;> >int> imaginary;> public>:> >ComplexNumber(>int> real,>int> imaginary)> >{> >this>->ægte = ægte;> >this>->imaginær = imaginær;> >}> >void> print() { cout << real <<>' + i'> << imaginary; }> >ComplexNumber operator+(ComplexNumber c2)> >{> >ComplexNumber c3(0, 0);> >c3.real =>this>->real + c2.real;> >c3.imaginary =>this>->imaginær + c2.imaginær;> >return> c3;> >}> };> int> main()> {> >ComplexNumber c1(3, 5);> >ComplexNumber c2(2, 4);> >ComplexNumber c3 = c1 + c2;> >c3.print();> >return> 0;> }> |
>
>Produktion
5 + i9>
Forklaring:
Udsagnet Complex Number c3 = c1 + c2; er internt oversat som komplekst tal c3 = c1.operator+ (c2); for at aktivere operatørfunktionen. Argumentet c1 videregives implicit ved hjælp af '.' operatør. Den næste sætning gør også brug af prikoperatoren til at få adgang til medlemsfunktionen print og videregive c3 som et argument.
Desuden arbejder disse operatører også på navne og ikke værdier, og der er ingen bestemmelse (syntaktisk) til at overbelaste dem.
5. Ternær eller betinget (?:) Operatør
Den ternære eller betingede operator er en stenografi af en if-else-sætning. I operatoren evalueres de sande/falske udtryk kun ud fra sandhedsværdien af det betingede udtryk.
conditional statement ? expression1 (if statement is TRUE) : expression2 (else)>
En funktion, der overbelaster den ternære operator for en klasse siger ABC ved hjælp af definitionen
ABC operator ?: (bool condition, ABC trueExpr, ABC falseExpr);>
ville ikke kunne garantere, at kun et af udtrykkene blev evalueret. Den ternære operatør kan således ikke overbelastes.
Vigtige punkter om operatøroverbelastning
1) For at operatøroverbelastning skal fungere, skal mindst en af operanderne være et brugerdefineret klasseobjekt.
java konverter int til streng
2) Opgaveoperatør: Compiler opretter automatisk en standard tildelingsoperatør med hver klasse. Standardtildelingsoperatoren tildeler alle medlemmer af højre side til venstre side og fungerer fint i de fleste tilfælde (denne adfærd er den samme som kopikonstruktøren). Se dette for flere detaljer.
3) Konverteringsoperatør: Vi kan også skrive konverteringsoperatorer, der kan bruges til at konvertere en type til en anden type.
Eksempel:
C++
// C++ Program to Demonstrate the working> // of conversion operator> #include> using> namespace> std;> class> Fraction {> private>:> >int> num, den;> public>:> >Fraction(>int> n,>int> d)> >{> >num = n;> >den = d;> >}> >// Conversion operator: return float value of fraction> >operator>float>()>const> >{> >return> float>(num) />float>(den);> >}> };> int> main()> {> >Fraction f(2, 5);> >float> val = f;> >cout << val <<>'
'>;> >return> 0;> }> |
download youtube video med vlc
>
>Produktion
0.4>
Overbelastede konverteringsoperatører skal være en medlemsmetode. Andre operatører kan enten være medlemsmetoden eller den globale metode.
4) Enhver konstruktør, der kan kaldes med et enkelt argument, fungerer som en konverteringskonstruktør, hvilket betyder, at den også kan bruges til implicit konvertering til den klasse, der konstrueres.
Eksempel:
C++
// C++ program to demonstrate can also be used for implicit> // conversion to the class being constructed> #include> using> namespace> std;> class> Point {> private>:> >int> x, y;> public>:> >Point(>int> i = 0,>int> j = 0)> >{> >x = i;> >y = j;> >}> >void> print()> >{> >cout <<>'x = '> << x <<>', y = '> << y <<>'
'>;> >}> };> int> main()> {> >Point t(20, 20);> >t.print();> >t = 30;>// Member x of t becomes 30> >t.print();> >return> 0;> }> |
>
>Produktion
x = 20, y = 20 x = 30, y = 0>
Quiz om operatøroverbelastning