C ++ operatörsöverbelastning (med exempel)

I den här handledningen lär vi oss om överbelastning av operatörer med hjälp av exempel.

I C ++ kan vi ändra hur operatörer arbetar för användardefinierade typer som objekt och strukturer. Detta kallas operatörsöverbelastning . Till exempel,

Anta att vi har skapat tre objekt c1, c2 och resultat från en klass med namnet Complexsom representerar komplexa nummer.

Eftersom operatörsöverbelastning tillåter oss att ändra hur operatörer fungerar kan vi omdefiniera hur +operatören fungerar och använda den för att lägga till de komplexa siffrorna c1 och c2 genom att skriva följande kod:

 result = c1 + c2;

istället för något liknande

 result = c1.addNumbers(c2);

Detta gör vår kod intuitiv och lätt att förstå.

Obs: Vi kan inte använda föraren överbelastning för grundläggande datatyper som int, float, charoch så vidare.

Syntax för C ++ Operator Overloading

För att överbelasta en operatör använder vi en speciell operatorfunktion.

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

Här,

returnType är funktionens returtyp.
operatör är ett nyckelord.
symbolär den operatör som vi vill överbelasta. Liksom: +, <, -, ++, etc.
arguments är argumenten som skickas till funktionen.

Operatörsöverbelastning hos unary operatörer

Unary operatörer fungerar endast på en operand. Ökningsoperatören ++och minskningsoperatören --är exempel på unary operatörer.

Exempel 1: ++ Operatör (Unary Operator) Överbelastning

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

Produktion

 Räkna: 6

Här, när vi använder ++count1;den void operator ++ ()kallas. Detta ökar värdeattributet för objekträkningen1 med 1.

Obs! När vi överbelastar operatörer kan vi använda det för att fungera på vilket sätt vi vill. Vi kunde till exempel ha använt ++att öka värdet med 100.

Detta gör dock vår kod förvirrande och svår att förstå. Det är vårt jobb som programmerare att använda operatörsöverbelastning ordentligt och på ett konsekvent och intuitivt sätt.

Ovanstående exempel fungerar bara när det ++används som ett prefix. För att ++fungera som en postfix använder vi denna syntax.

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

Lägg märke till intinuti parenteserna. Det är den syntax som används för att använda unary operatorer som postfix; det är inte en funktionsparameter.

Exempel 2: ++ Operatör (Unary Operator) Överbelastning

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

Produktion

 Räkna: 6 Räkna: 7

Den Exempel 2 fungerar när ++används som både prefix och postfix. Det fungerar dock inte om vi försöker göra något så här:

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

Detta beror på att returtypen för vår operatörsfunktion är void. Vi kan lösa detta problem genom att göra Countsom återgångstyp för operatörsfunktionen.

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

Exempel 3: Returvärde från operatörsfunktion (++ operatör)

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

Produktion

 Räkna: 6 Räkna: 7

Här har vi använt följande kod för överbelastning av prefixoperatörer:

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

Koden för postfix-operatörens överbelastning är också densamma. Lägg märke till att vi har skapat ett objekttemp och returnerat dess värde till operatörsfunktionen.

Lägg också märke till koden

 temp.value = ++value;

Variabelvärdet tillhör count1-objektet main()eftersom count1 kallar funktionen, medan temp.value tillhör temp-objektet.

Överbelastning av operatörer i binära operatörer

Binära operatörer arbetar på två operander. Till exempel,

 result = num + 9;

Här +är en binär operatör som fungerar på operanderna num och 9.

När vi överbelastar den binära operatören för användardefinierade typer med hjälp av koden:

 obj3 = obj1 + obj2;

Operatörsfunktionen anropas med obj1-objektet och obj2 skickas som ett argument till funktionen.

Exempel 4: C ++ binär operatörsöverbelastning

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

Produktion

 Ange första komplexa nummer: Ange verkliga respektive imaginära delar: 9 5 Ange andra komplexa nummer: Ange riktiga respektive imaginära delar: 7 6 Utgång Komplexnummer: 16 + 11i

I detta program är operatörsfunktionen:

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

Istället för detta kunde vi också ha skrivit den här funktionen som:

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

Dock,

användning &gör vår kod effektiv genom att referera till complex2-objektet istället för att skapa ett duplikatobjekt inuti operatörsfunktionen.
användning constanses vara en god praxis eftersom det hindrar operatörsfunktionen från att ändra complex2.

Överbelastning av binära operatörer i C ++

Saker att komma ihåg i C ++ Operator Overloading

Två operatörer =och &är redan överbelastade som standard i C ++. Till exempel, för att kopiera objekt av samma klass kan vi direkt använda =operatören. Vi behöver inte skapa en operatörsfunktion.
Överbelastning av operatörer kan inte ändra operatörernas företräde och associativitet. Men om vi vill ändra ordningen för utvärderingen bör parenteser användas.
Det finns fyra operatörer som inte kan överbelastas i C ++. Dom är:
1. :: (omfångsupplösning)
2. . (medlemsval)
3. .* (medlemsval genom pekare för att fungera)
4. ?: (ternär operatör)