C ++ operaatori ülekoormus (koos näidetega)

Selles õpetuses õpime näidete abil operaatori ülekoormamist.

Rakenduses C ++ saame muuta operaatorite töötamist kasutaja määratud tüüpide, näiteks objektide ja struktuuride puhul. Seda nimetatakse operaatori ülekoormamiseks . Näiteks,

Oletame, et oleme loonud kolm objekti c1, c2 ja tulenevad nimega klassist, Complexmis tähistab kompleksarvusid.

Kuna operaatori ülekoormus võimaldab meil muuta operaatorite tööd, saame operaatori töö uuesti määratleda +ja selle abil lisada koodide c1 ja c2 kompleksarvud, kirjutades järgmise koodi:

 result = c1 + c2;

millegi sarnase asemel

 result = c1.addNumbers(c2);

See muudab meie koodi intuitiivseks ja hõlpsasti mõistetavaks.

Märkus: Me ei saa kasutada operaator ülekoormus põhiõiguste andmetüübid nagu int, float, charja nii edasi.

Süntaks operaatori C ++ ülekoormamiseks

Operaatori ülekoormamiseks kasutame spetsiaalset operatorfunktsiooni.

 class className (… public returnType operator symbol (arguments) (… )… );

Siin,

returnType on funktsiooni tagastustüüp.
operaator on märksõna.
symbolon operaator, keda soovime üle koormata. Nagu: +, <, -, ++, jne
arguments on funktsioonile edastatud argumendid.

Operaatori ülekoormus ühetaolistes operaatorites

Unaaroperaatorid tegutsevad ainult ühel operandil. Juurdekasv operaator ++ja aland operaator --on näited unaarsed operaatorid.

Näide1: ++ Operaator (Unary Operaator) Ülekoormus

 // Overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ ()" function ++count1; count1.display(); return 0; )

Väljund

 Loendus: 6

Siin, kui kasutame ++count1;, void operator ++ ()nimetatakse. See suurendab objekti count1 väärtuse atribuuti 1 võrra.

Märkus. Kui me operaatoreid üle koormame, saame seda kasutada mis tahes viisil. Näiteks oleksime võinud kasutada ++väärtuse suurendamist 100 võrra.

See muudab aga meie koodi segaseks ja raskesti mõistetavaks. Meie ülesanne on programmeerijana kasutada operaatori ülekoormamist korralikult, järjepidevalt ja intuitiivselt.

Ülaltoodud näide töötab ainult siis, kui ++seda kasutatakse eesliitena. Et ++töö kui postfix me kasutame seda süntaksit.

 void operator ++ (int) ( // code )

Pange tähele intsulgude sisemust. See on süntaks, mida kasutatakse unaaroperaatorite kasutamiseks postfiksina; see pole funktsiooni parameeter.

Näide 2: ++ Operaator (Unary Operaator) Ülekoormus

 // Overload ++ when used as prefix and postfix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) // Overload ++ when used as postfix void operator ++ (int) ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ (int)" function count1++; count1.display(); // Call the "void operator ++ ()" function ++ count1; count1.display(); return 0; )

Väljund

 Loend: 6 Loend: 7

Näide 2 töötab, kui ++kasutatakse nii eesliide ja postfix. See aga ei toimi, kui proovime midagi sellist teha:

 Count count1, result; // Error result = ++count1;

Seda seetõttu, et meie operaatori funktsiooni tagastustüüp on void. Selle probleemi saame lahendada, muutes Countoperaatori funktsiooni tagastustüübiks.

 // return Count when ++ used as prefix Count operator ++ () ( // code ) // return Count when ++ used as postfix Count operator ++ (int) ( // code )

Näide 3: tagastusväärtus operaatori funktsioonilt (++ operaator)

 #include using namespace std; class Count ( private: int value; public : // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) // Overload ++ when used as postfix Count operator ++ (int) ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1, result; // Call the "Count operator ++ ()" function result = ++count1; result.display(); // Call the "Count operator ++ (int)" function result = count1++; result.display(); return 0; )

Väljund

 Loend: 6 Loend: 7

Siin oleme kasutanud prefiksioperaatori ülekoormamiseks järgmist koodi:

 // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; )

Postfix-operaatori ülekoormuse kood on samuti sama. Pange tähele, et oleme loonud objekti temp ja tagastanud selle väärtuse operaatori funktsioonile.

Pange tähele ka koodi

 temp.value = ++value;

Muutuja väärtus kuulub objektile count1, main()kuna count1 kutsub funktsiooni, temp.value aga temp objektile.

Operaatori ülekoormus binaarsetes operaatorites

Binaaroperaatorid töötavad kahel operandil. Näiteks,

 result = num + 9;

Siin +on binaaroperaator, mis töötab operandidel num ja 9.

Kui laadime binaaroperaatori kasutaja määratletud tüüpide jaoks koodi kasutades üle:

 obj3 = obj1 + obj2;

Operaatori funktsiooni kutsutakse objekti obj1 abil ja objekt2 edastatakse funktsiooni argumendina.

Näide 4: C ++ binaaroperaatori ülekoormus

 // C++ program to overload the binary operator + // This program adds two complex numbers #include using namespace std; class Complex ( private: float real; float imag; public: // Constructor to initialize real and imag to 0 Complex() : real(0), imag(0) () void input() ( cout <> real; cin>> imag; ) // Overload the + operator Complex operator + (const Complex& obj) ( Complex temp; temp.real = real + obj.real; temp.imag = imag + obj.imag; return temp; ) void output() ( if (imag < 0) cout << "Output Complex number: " << real << imag << "i"; else cout << "Output Complex number: " << real << "+" << imag << "i"; ) ); int main() ( Complex complex1, complex2, result; cout << "Enter first complex number:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Väljund

 Sisestage esimene kompleksarv: sisestage vastavalt tegelik ja kujuteldav osa: 9 5 Sisestage teine kompleksarv: sisestage vastavalt tegelik ja kujuteldav osa: 7 6 Väljundi kompleksarv: 16 + 11i

Selles programmis on operaatori funktsioon:

 Complex operator + (const Complex& obj) ( // code )

Selle asemel oleksime võinud ka selle funktsiooni kirjutada järgmiselt:

 Complex operator + (Complex obj) ( // code )

Kuid,

kasutamine &muudab meie koodi tõhusaks, viidates kompleksfunktsioonile 2 selle asemel, et teha operaatori funktsiooni sisse duplikaatobjekt.
kasutamist constpeetakse heaks tavaks, kuna see takistab operaatori funktsioonil kompleks2 muutmist.

Binaaroperaatorite ülekoormus C ++ keeles

Asjad, mida C ++ operaatori ülekoormamisel meeles pidada

Kaks operaatorit =ja &on C ++ keeles vaikimisi juba ülekoormatud. Näiteks sama klassi objektide kopeerimiseks saame =operaatorit otse kasutada . Me ei pea looma operaatori funktsiooni.
Operaatori ülekoormus ei saa muuta operaatorite ülimuslikkust ja assotsiatiivsust. Kui aga soovime muuta hindamise järjekorda, tuleks kasutada sulgusid.
Seal on 4 operaatorit, mida ei saa C ++ versioonis üle koormata. Nemad on:
1. :: (reguleerimisala resolutsioon)
2. . (liikmete valik)
3. .* (liikme valik kursori kaudu toimimiseks)
4. ?: (kolmepoolne operaator)