Preťaženie operátora C ++ (s príkladmi)

V tomto výučbe sa pomocou príkladov dozvieme o preťažení operátora.

V C ++ môžeme zmeniť spôsob fungovania operátorov pre typy definované používateľom, ako sú objekty a štruktúry. Toto sa označuje ako preťaženie operátora . Napríklad,

Predpokladajme, že sme vytvorili tri objekty c1, c2 a sú výsledkom triedy s názvom, Complexktorá predstavuje komplexné čísla.

Pretože preťaženie operátora nám umožňuje zmeniť spôsob fungovania operátorov, môžeme predefinovať fungovanie +operátora a pomocou neho pridať komplexné čísla c1 a c2 napísaním nasledujúceho kódu:

 result = c1 + c2;

namiesto niečoho ako

 result = c1.addNumbers(c2);

Vďaka tomu je náš kód intuitívny a ľahko pochopiteľný.

Poznámka: Nemôžeme použiť operátor preťaženiu základných dátových typov, ako sú int, float, chara tak ďalej.

Syntax pre preťaženie operátora C ++

Na preťaženie operátora používame špeciálnu operatorfunkciu.

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

Tu,

returnType je návratový typ funkcie.
operátor je kľúčové slovo.
symbolje operátor, ktorého chceme preťažiť. Ako sú: +, <, -, ++, atď.
arguments sú argumenty odovzdané funkcii.

Preťaženie operátora unárnymi operátormi

Unárne operátory pracujú iba s jedným operandom. Operátor prírastku ++a operátor dekrementácie --sú príkladmi unárnych operátorov.

Príklad1: ++ Preťaženie operátora (unárny operátor)

 // 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ýkon

 Počet: 6

Tu, keď použijeme ++count1;, void operator ++ ()sa volá. Toto zvyšuje atribút hodnoty pre počet objektov1 o 1.

Poznámka: Keď operátory preťažíme, môžeme ich použiť na prácu akýmkoľvek spôsobom. Mohli sme napríklad použiť ++na zvýšenie hodnoty o 100.

Toto však robí náš kód mätúcim a ťažko pochopiteľným. Našou úlohou ako programátora je správne a dôsledne a intuitívne využívať preťaženie operátora.

Vyššie uvedený príklad funguje, iba ak ++sa použije ako predpona. Aby sme ++fungovali ako postfix, používame túto syntax.

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

Všimnite si intvnútornú zátvorku. Je to syntax použitá pre použitie unárnych operátorov ako postfix; nie je to funkčný parameter.

Príklad 2: Preťaženie operátora ++ (unárny operátor)

 // 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ýkon

 Počet: 6 Počet: 7

Príklad 2 funguje, keď ++sa používa ako ako prefix a postfix. Nefunguje to však, ak sa pokúsime urobiť niečo také:

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

Je to preto, že návratový typ našej funkcie operátora je void. Tento problém môžeme vyriešiť tak, že Countako návratový typ použijeme operátorskú funkciu.

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

Príklad 3: Vrátená hodnota z funkcie operátora (operátor ++)

 #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ýkon

 Počet: 6 Počet: 7

Tu sme použili nasledujúci kód na preťaženie operátora predpony:

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

Rovnaký je aj kód pre preťaženie operátora postfix. Všimnite si, že sme vytvorili dočasnú teplotu objektu a vrátili sme jeho hodnotu funkcii operator.

Všimnite si tiež kód

 temp.value = ++value;

Hodnota premennej patrí k objektu main()count1, pretože count1 volá funkciu, zatiaľ čo temp.value patrí k dočasnému objektu.

Preťaženie operátora v binárnych operátoroch

Binárne operátory pracujú na dvoch operandoch. Napríklad,

 result = num + 9;

Tu +je binárny operátor, ktorý pracuje na operandoch num a 9.

Keď preťažíme binárny operátor pre typy definované používateľom pomocou kódu:

 obj3 = obj1 + obj2;

Funkcia operátora sa volá pomocou objektu obj1 a obj2 sa odovzdá funkcii ako argument.

Príklad 4: Preťaženie binárneho operátora 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; )

Výkon

 Zadajte prvé komplexné číslo: Zadajte reálnu a imaginárnu časť: 9 5 Zadajte druhé komplexné číslo: Zadajte skutočnú a imaginárnu časť: 7 6 Výstupní komplexní číslo: 16 + 11i

V tomto programe je funkcia operátora:

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

Namiesto toho by sme tiež mohli napísať túto funkciu ako:

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

Avšak

použitie &robí náš kód efektívnym odkazom na objekt complex2 namiesto toho, aby sme vytvorili duplicitný objekt vo vnútri funkcie operátora.
použitie constsa považuje za dobrú prax, pretože bráni tomu, aby operátorská funkcia zmenila komplex2.

Preťaženie binárnych operátorov v C ++

Na čo treba pamätať pri preťažení operátora C ++

Dva operátory =a &v C ++ sú už predvolene preťažené. Napríklad na kopírovanie objektov rovnakej triedy môžeme priamo použiť =operátor. Nie je potrebné vytvárať operátorské funkcie.
Preťaženie operátora nemôže zmeniť prednosť a asociativitu operátorov. Ak však chceme zmeniť poradie hodnotenia, mali by sme použiť zátvorky.
Existujú 4 operátory, ktoré v C ++ nemôžu byť preťažené. Oni sú:
1. :: (rozlíšenie rozsahu)
2. . (výber členov)
3. .* (výber člena pomocou ukazovateľa na funkciu)
4. ?: (ternárny operátor)