C ++ operátor túlterhelés (példákkal)

Ebben az oktatóanyagban példák segítségével megismerhetjük a kezelő túlterhelését.

A C ++ nyelven megváltoztathatjuk az operátorok munkáját a felhasználó által definiált típusoknál, például objektumoknál és struktúráknál. Ezt nevezik a kezelő túlterhelésének . Például,

Tegyük fel, hogy létrehoztunk három c1, c2 objektumot, amelyek egy Complexösszetett számokat képviselő elnevezett osztályból származnak .

Mivel az operátor túlterhelése lehetővé teszi számunkra, hogy megváltoztassuk az operátorok működését, újradefiniálhatjuk az +operátor működését, és felhasználhatjuk a c1 és c2 komplex számok hozzáadásához a következő kód beírásával:

 result = c1 + c2;

valami ilyesmi helyett

 result = c1.addNumbers(c2);

Ez kódunkat intuitívvá és könnyen érthetővé teszi.

Megjegyzés: Nem tudjuk használni operátor túlterhelés alapvető adattípusok, mint int, float, charés így tovább.

Szintaxis a C ++ operátor túlterheléséhez

Az operátor túlterheléséhez speciális operatorfunkciót használunk .

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

Itt,

returnType a függvény visszatérési típusa.
operátor kulcsszó.
symbolaz a kezelő, akit túl akarunk terhelni. Mint: +, <, -, ++stb
arguments a függvénynek átadott argumentumok.

Operátor túlterhelése az unary operátorokban

Az unár operátorok csak egy operanduson működnek. Az inkrement operátor ++és a decrement operátor --példák az unáris operátorokra.

1. példa: ++ Operator (Unary Operator) Túlterhelés

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

Kimenet

 Gróf: 6

Itt, amikor használjuk ++count1;, az void operator ++ ()ún. Ez 1-vel növeli az objektum count1 értékattribútumát.

Megjegyzés: Amikor túlterheljük az operátorokat, használhatjuk azt bármilyen tetszés szerinti munkához. Például felhasználhattuk ++volna az érték 100- mal történő növelését.

Ez azonban zavaróvá és nehezen érthetővé teszi kódunkat. Programozóként az a feladatunk, hogy megfelelően, következetesen és intuitív módon használjuk az operátorok túlterhelését.

A fenti példa csak akkor működik, ha ++előtagként használják. Ahhoz, hogy ++postfixként működjön, ezt a szintaxist használjuk.

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

Figyelje meg inta zárójeleket. Ez az a szintaxis, amelyet az unari operátorok postfixként használnak; ez nem függvényparaméter.

2. példa: ++ Operator (Unary Operator) Túlterhelés

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

Kimenet

 Count: 6 Count: 7

A 2. példa akkor működik, ha ++előtagként és utótagként egyaránt használják. Ez azonban nem működik, ha ilyesmit próbálunk megtenni:

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

Ennek oka, hogy az operátor függvényünk visszatérési típusa az void. Megoldhatjuk ezt a problémát azáltal, hogy Countaz operátor függvény visszatérési típusaként adjuk meg.

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

3. példa: Visszatérési érték az operátor funkciótól (++ Operator)

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

Kimenet

 Count: 6 Count: 7

Itt a következő kódot használtuk az előtag-operátor túlterheléséhez:

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

A postfix operátor túlterhelésének kódja is megegyezik. Figyelje meg, hogy létrehoztunk egy objektumhőmérsékletet, és visszaadtuk az értékét az operátor függvénynek.

Figyelje meg a kódot is

 temp.value = ++value;

A változó értéke a count1 objektumhoz tartozik, main()mivel a count1 meghívja a függvényt, míg a temp.value a temp objektumhoz tartozik.

Operátor túlterhelése bináris operátorokban

A bináris operátorok két operanduson dolgoznak. Például,

 result = num + 9;

Itt +van egy bináris operátor, amely a num és az operandusokon dolgozik 9.

Amikor a kód használatával túlterheljük a bináris operátort a felhasználó által definiált típusokhoz:

 obj3 = obj1 + obj2;

Az operátor függvényt meghívjuk az obj1 objektum segítségével, és az obj2 argumentumként továbbadódik a függvénynek.

4. példa: C ++ bináris operátor túlterhelése

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

Kimenet

 Írja be az első komplex számot: Írja be a valós és a képzeletbeli részeket: 9 5 Írja be a második komplex számot: Írja be a valós és a képzeletbeli részeket: 7 6 Kimeneti összetett szám: 16 + 11i

Ebben a programban a kezelő funkció:

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

Ehelyett ezt a függvényt is írhattuk volna, például:

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

Azonban,

használatával &hatékonyabbá tesszük a kódunkat azáltal, hogy hivatkozunk a complex2 objektumra, ahelyett, hogy duplikált objektumot készítenénk az operátor függvényen belül.
használata constjó gyakorlatnak számít, mert megakadályozza, hogy az operátor funkció módosítsa a komplex2-t.

A bináris operátorok túlterhelése C ++ nyelven

Emlékezetes dolgok a C ++ operátor túlterhelésében

Két operátor, =és &alapértelmezés szerint már túlterheltek a C ++ nyelven. Például azonos osztályú objektumok másolásához közvetlenül használhatjuk az =operátort. Nincs szükség operátorfüggvény létrehozására.
A kezelő túlterhelése nem változtathatja meg az operátorok elsőbbségét és asszociativitását. Ha azonban meg akarjuk változtatni az értékelés sorrendjét, zárójeleket kell használni.
4 operátor van, amelyeket nem lehet túlterhelni a C ++ verzióban. Ők:
1. :: (hatókör felbontása)
2. . (tagválasztás)
3. .* (a tag kiválasztása a mutató és a funkció között)
4. ?: (hármas üzemeltető)