Operatora C ++ pārslodze (ar piemēriem)

Šajā apmācībā mēs uzzināsim par operatora pārslodzi, izmantojot piemērus.

Programmā C ++ mēs varam mainīt operatoru darbību lietotāja definētiem tipiem, piemēram, objektiem un struktūrām. To sauc par operatora pārslodzi . Piemēram,

Pieņemsim, ka mēs esam izveidojuši trīs objektus c1, c2 un izriet no klases, Complexkas apzīmē kompleksus skaitļus.

Tā kā operatora pārslodze ļauj mums mainīt operatoru darbību, mēs varam no jauna definēt +operatora darbību un izmantot to, lai pievienotu sarežģītos numurus c1 un c2, ierakstot šādu kodu:

 result = c1 + c2;

kaut kā līdzīga vietā

 result = c1.addNumbers(c2);

Tas padara mūsu kodu intuitīvu un viegli saprotamu.

Piezīme: Mēs nevaram izmantot operatoru nepārslogotu pamattiesību datu veidiem, piemēram int, float, charun tā tālāk.

Sintakse C ++ operatora pārslodzei

Lai pārslogotu operatoru, mēs izmantojam īpašu operatorfunkciju.

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

Šeit,

returnType ir funkcijas atgriešanas veids.
operators ir atslēgvārds.
symbolir operators, kuru mēs vēlamies pārslogot. Tāpat: +, <, -, ++, uc
arguments ir funkcijai nodotie argumenti.

Operatora pārslodze vienreizējos operatoros

Unāri operatori darbojas tikai vienā operandā. Pieauguma operators ++un samazināšanas operators --ir unāru operatoru piemēri.

1. piemērs: ++ Operatora (Unary Operator) pārslodze

 // 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; )

Rezultāts

 Skaits: 6

Šeit, kad mēs izmantojam ++count1;, void operator ++ ()tiek saukts. Tas palielina objekta count1 vērtības atribūtu par 1.

Piezīme. Pārslogojot operatorus, mēs varam to izmantot, lai darbotos jebkurā sev vēlamā veidā. Piemēram, mēs būtu varējuši izmantot, ++lai palielinātu vērtību par 100.

Tomēr tas padara mūsu kodu mulsinošu un grūti saprotamu. Mūsu kā programmētāja darbs ir pareizi, konsekventi un intuitīvi izmantot operatora pārslodzi.

Iepriekš minētais piemērs darbojas tikai tad, ja ++to izmanto kā prefiksu. Lai ++darbotos kā pēcfikss, mēs izmantojam šo sintaksi.

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

Ievērojiet intiekavās iekšpusē. Tā ir sintakse, kas tiek izmantota unāru operatoru izmantošanai kā postfix; tas nav funkcijas parametrs.

2. piemērs: ++ Operatora (Unary Operator) pārslodze

 // 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; )

Rezultāts

 Skaits: 6 Skaits: 7

2. piemērs darbojas, ja ++to lieto gan kā prefiksu, gan kā prefiksu. Tomēr tas nedarbojas, ja mēģinām darīt kaut ko līdzīgu šim:

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

Tas ir tāpēc, ka mūsu operatora funkcijas atgriešanās veids ir void. Mēs varam atrisināt šo problēmu, padarot Countoperatora funkcijas atgriešanās veidu.

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

3. piemērs: atgriešanās vērtība no operatora funkcijas (++ operators)

 #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; )

Rezultāts

 Skaits: 6 Skaits: 7

Šeit prefiksu operatora pārslodzei esam izmantojuši šādu kodu:

 // 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 operatora pārslodzes kods ir vienāds. Ievērojiet, ka esam izveidojuši objekta temp un atgriezuši tā vērtību operatora funkcijai.

Ievērojiet arī kodu

 temp.value = ++value;

Mainīgā vērtība pieder objektam count1, main()jo count1 izsauc funkciju, savukārt temp.value pieder temp objektam.

Operatora pārslodze bināros operatoros

Binārie operatori strādā pie diviem operandiem. Piemēram,

 result = num + 9;

Šeit +ir binārs operators, kas darbojas ar operandiem num un 9.

Kad mēs pārslogojam bināro operatoru lietotāja definētiem tipiem, izmantojot kodu:

 obj3 = obj1 + obj2;

Operatora funkcija tiek izsaukta, izmantojot obj1 obj1, un obj2 tiek nodots kā arguments funkcijai.

4. piemērs: C ++ binārā operatora pārslodze

 // 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; )

Rezultāts

 Ievadiet pirmo kompleksa numuru: Ievadiet attiecīgi reālo un iedomāto daļu: 9 5 Ievadiet otro kompleksa numuru: Ievadiet attiecīgi reālo un iedomāto daļu: 7 6 Izejas kompleksa numurs: 16 + 11i

Šajā programmā operatora funkcija ir:

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

Tā vietā mēs arī būtu varējuši uzrakstīt šo funkciju, piemēram:

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

Tomēr

Izmantojot, &mūsu kods ir efektīvs, atsaucoties uz complex2 objektu, nevis izveidojot objekta dublikātu operatora funkcijā.
izmantošana consttiek uzskatīta par labu praksi, jo tā neļauj operatora funkcijai modificēt kompleksu2.

Bināro operatoru pārslodze C ++

Lietas, kas jāatceras C ++ operatora pārslodzes gadījumā

Divi operatori =un &pēc noklusējuma jau ir pārslogoti C ++. Piemēram, lai kopētu vienas klases objektus, mēs varam tieši izmantot =operatoru. Mums nav jāizveido operatora funkcija.
Operatora pārslodze nevar mainīt operatoru prioritāti un asociativitāti. Tomēr, ja mēs vēlamies mainīt vērtēšanas kārtību, jāizmanto iekavas.
Ir 4 operatori, kurus nevar pārslogot C ++. Viņi ir:
1. :: (darbības jomas izšķirtspēja)
2. . (dalībnieku atlase)
3. .* (dalībnieka izvēle, izmantojot rādītāju, lai darbotos)
4. ?: (trīskāršais operators)