Suprasolicitare operator C ++ (cu exemple)

În acest tutorial, vom afla despre supraîncărcarea operatorului cu ajutorul exemplelor.

În C ++, putem schimba modul în care operează operatorii pentru tipuri definite de utilizator, cum ar fi obiecte și structuri. Acest lucru este cunoscut sub numele de supraîncărcare a operatorului . De exemplu,

Să presupunem că am creat trei obiecte c1, c2 și rezultă dintr-o clasă numită Complexcare reprezintă numere complexe.

Deoarece supraîncărcarea operatorului ne permite să schimbăm modul în care funcționează operatorii, putem redefini modul în +care funcționează operatorul și îl putem folosi pentru a adăuga numerele complexe ale c1 și c2 scriind următorul cod:

 result = c1 + c2;

în loc de ceva de genul

 result = c1.addNumbers(c2);

Acest lucru face ca codul nostru să fie intuitiv și ușor de înțeles.

Notă: Nu putem folosi supraîncărcarea operatorului pentru tipuri de date fundamentale , cum ar fi int, float, charși așa mai departe.

Sintaxa pentru supraîncărcarea operatorului C ++

Pentru a supraîncărca un operator, folosim o operatorfuncție specială .

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

Aici,

returnType este tipul returnat al funcției.
operator este un cuvânt cheie.
symboleste operatorul pe care dorim să îl supraîncărcăm. La fel ca: +, <, -, ++etc.
arguments este argumentele transmise funcției.

Supraîncărcarea operatorului în operatorii unari

Operatorii unari operează pe un singur operand. Operatorul de incrementare ++și operatorul de decrementare --sunt exemple de operatori unari.

Exemplul 1: Operator ++ (operator unar) Suprasolicitare

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

Ieșire

 Număr: 6

Aici, când folosim ++count1;, void operator ++ ()se numește. Aceasta crește atributul valorii pentru numărul de obiecte1 cu 1.

Notă: Când supraîncărcăm operatorii, îl putem folosi pentru a funcționa în orice mod ne place. De exemplu, am fi putut folosi ++pentru a crește valoarea cu 100.

Cu toate acestea, acest lucru face ca codul nostru să fie confuz și dificil de înțeles. Treaba noastră ca programator este să folosim corect supraîncărcarea operatorului și într-un mod consecvent și intuitiv.

Exemplul de mai sus funcționează numai atunci când ++este utilizat ca prefix. Pentru a ++funcționa ca postfix, folosim această sintaxă.

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

Observați intinteriorul parantezelor. Este sintaxa utilizată pentru utilizarea operatorilor unari ca postfix; nu este un parametru funcțional.

Exemplul 2: Operator ++ (operator unar) Suprasolicitare

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

Ieșire

 Număr: 6 Număr: 7

Exemplul 2 funcționează atunci când ++este utilizat atât ca prefix și postfix. Cu toate acestea, nu funcționează dacă încercăm să facem așa ceva:

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

Acest lucru se datorează faptului că tipul de returnare a funcției noastre de operator este void. Putem rezolva această problemă făcând Countca tip de returnare a funcției operator.

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

Exemplul 3: valoarea returnată din funcția operatorului (operatorul ++)

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

Ieșire

 Număr: 6 Număr: 7

Aici, am folosit următorul cod pentru supraîncărcarea operatorului de prefix:

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

Codul pentru supraîncărcarea operatorului postfix este același. Observați că am creat un obiect temp și i-am returnat valoarea funcției operator.

De asemenea, observați codul

 temp.value = ++value;

Valoarea variabilă aparține obiectului count1 din main()deoarece count1 apelează funcția, în timp ce valoarea temp.apartine obiectului temp.

Supraîncărcarea operatorului în operatorii binari

Operatorii binari lucrează pe doi operanzi. De exemplu,

 result = num + 9;

Aici +este un operator binar care funcționează pe operanzii num și 9.

Când supraîncărcăm operatorul binar pentru tipurile definite de utilizator folosind codul:

 obj3 = obj1 + obj2;

Funcția operator este numită folosind obiectul obj1 și obiect2 este transmis ca argument funcției.

Exemplul 4: supraîncărcare a operatorului binar C ++

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

Ieșire

 Introduceți primul număr complex: Introduceți părțile reale și respectiv imaginare: 9 5 Introduceți al doilea număr complex: Introduceți părțile reale și respectiv imaginare: 7 6 Număr complex de ieșire: 16 + 11i

În acest program, funcția operator este:

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

În loc de aceasta, am fi putut scrie și această funcție ca:

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

In orice caz,

folosirea &eficientizează codul nostru prin referirea la obiectul complex2 în loc de a crea un obiect duplicat în interiorul funcției operator.
utilizarea consteste considerată o bună practică deoarece împiedică funcția operatorului să modifice complexul2.

Supraîncărcarea operatorilor binari în C ++

Lucruri de reținut în supraîncărcarea operatorului C ++

Doi operatori =și &sunt deja supraîncărcați implicit în C ++. De exemplu, pentru a copia obiecte din aceeași clasă, putem folosi direct =operatorul. Nu este nevoie să creăm o funcție de operator.
Supraîncărcarea operatorului nu poate schimba prioritatea și asociativitatea operatorilor. Cu toate acestea, dacă dorim să schimbăm ordinea evaluării, ar trebui folosite paranteze.
Există 4 operatori care nu pot fi supraîncărcați în C ++. Sunt:
1. :: (rezoluția scopului)
2. . (selectarea membrilor)
3. .* (selectarea membrilor prin pointer pentru a funcționa)
4. ?: (operator ternar)