Overbelasting door C ++ operator (met voorbeelden)

In deze tutorial leren we aan de hand van voorbeelden over overbelasting van operators.

In C ++ kunnen we de manier wijzigen waarop operators werken voor door de gebruiker gedefinieerde typen zoals objecten en structuren. Dit staat bekend als overbelasting door de operator . Bijvoorbeeld,

Stel dat we drie objecten c1, c2 hebben gemaakt en het resultaat zijn van een klasse met de naam Complexdie complexe getallen vertegenwoordigt.

Omdat overbelasting van operators ons in staat stelt de manier waarop operators werken te veranderen, kunnen we opnieuw definiëren hoe de +operator werkt en deze gebruiken om de complexe getallen van c1 en c2 toe te voegen door de volgende code te schrijven:

 result = c1 + c2;

in plaats van zoiets als

 result = c1.addNumbers(c2);

Dit maakt onze code intuïtief en gemakkelijk te begrijpen.

Opmerking: We kunnen geen gebruik maken van operator overbelasting van de fundamentele data types zoals int, float, charen ga zo maar door.

Syntaxis voor overbelasting door C ++ operator

Om een ​​operator te overbelasten, gebruiken we een speciale operatorfunctie.

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

Hier,

  • returnType is het retourtype van de functie.
  • operator is een trefwoord.
  • symbolis de operator die we willen overbelasten. Zoals: +, <, -, ++, etc.
  • arguments zijn de argumenten die aan de functie worden doorgegeven.

Overbelasting van operators bij unaire operators

Unaire operators werken op slechts één operand. De operator voor verhogen ++en verlagen --zijn voorbeelden van unaire operatoren.

Voorbeeld 1: ++ Operator (Unary Operator) Overbelasting

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

Uitvoer

 Aantal: 6

Hier, wanneer we gebruiken ++count1;, void operator ++ ()wordt de aangeroepen. Dit verhoogt het waardeattribuut voor het object count1 met 1.

Opmerking: als we operators overbelasten, kunnen we deze gebruiken om op elke gewenste manier te werken. We hadden bijvoorbeeld ++de waarde met 100 kunnen verhogen.

Dit maakt onze code echter verwarrend en moeilijk te begrijpen. Het is onze taak als programmeur om operatoroverbelasting correct en op een consistente en intuïtieve manier te gebruiken.

Het bovenstaande voorbeeld werkt alleen als het ++als voorvoegsel wordt gebruikt. Om ++werk te maken als postfix gebruiken we deze syntaxis.

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

Let op de intbinnenkant van de haakjes. Het is de syntaxis die wordt gebruikt voor het gebruik van unaire operatoren als postfix; het is geen functieparameter.

Voorbeeld 2: ++ Operator (Unary Operator) Overbelasting

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

Uitvoer

 Aantal: 6 Aantal: 7

Het voorbeeld 2 werkt wanneer ++wordt gebruikt als zowel prefix en achtervoegsel. Het werkt echter niet als we zoiets als dit proberen te doen:

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

Dit komt doordat het retourtype van onze operatorfunctie void. We kunnen dit probleem oplossen door Countals het retourtype van de operatorfunctie te maken.

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

Voorbeeld 3: geretourneerde waarde van operatorfunctie (++ 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; )

Uitvoer

 Aantal: 6 Aantal: 7

Hier hebben we de volgende code gebruikt voor overbelasting van voorvoegseloperatoren:

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

De code voor overbelasting door de postfix-operator is ook hetzelfde. Merk op dat we een objecttemp hebben gemaakt en de waarde ervan hebben geretourneerd naar de operatorfunctie.

Let ook op de code

 temp.value = ++value;

De variabele waarde behoort tot het count1-object in main()omdat count1 de functie aanroept, terwijl temp.value tot het temp-object behoort.

Operator overbelasting in binaire operatoren

Binaire operators werken op twee operanden. Bijvoorbeeld,

 result = num + 9;

Hier +is een binaire operator die werkt op de operanden num en 9.

Wanneer we de binaire operator voor door de gebruiker gedefinieerde typen overbelasten door de code te gebruiken:

 obj3 = obj1 + obj2;

De operatorfunctie wordt aangeroepen met behulp van het object obj1 en obj2 wordt als argument aan de functie doorgegeven.

Voorbeeld 4: Overbelasting van de C ++ binaire operator

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

Uitvoer

 Voer het eerste complexe getal in: voer respectievelijk reële en imaginaire delen in: 9 5 Voer het tweede complexe getal in: voer respectievelijk reële en imaginaire delen in: 7 6 Uitvoer Complex getal: 16 + 11i

In dit programma is de operatorfunctie:

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

In plaats daarvan hadden we deze functie ook kunnen schrijven zoals:

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

Echter,

  • gebruik &maakt onze code efficiënt door te verwijzen naar het complex2-object in plaats van een duplicaat te maken binnen de operatorfunctie.
  • gebruiken constwordt als een goede gewoonte beschouwd omdat het voorkomt dat de operatorfunctie complex2 wijzigt.
Overbelasting van binaire operators in C ++

Dingen om te onthouden in C ++ Operator Overloading

  1. Twee operators =en &zijn standaard al overbelast in C ++. Om bijvoorbeeld objecten van dezelfde klasse te kopiëren, kunnen we rechtstreeks de =operator gebruiken. We hoeven geen operatorfunctie te maken.
  2. Overbelasting van operators kan de prioriteit en associativiteit van operators niet veranderen. Als we de volgorde van evaluatie echter willen wijzigen, moeten haakjes worden gebruikt.
  3. Er zijn 4 operators die niet kunnen worden overbelast in C ++. Zij zijn:
    1. :: (scope resolutie)
    2. . (selectie van leden)
    3. .* (ledenselectie via aanwijzer naar functie)
    4. ?: (ternaire operator)

Bezoek deze pagina's voor meer informatie over:

  • Hoe de incrementele operator op de juiste manier te overbelasten?
  • Hoe de binaire operator te overbelasten - om complexe getallen af ​​te trekken?

Interessante artikelen...