C++ Operator Overloading

In deze tutorial leren we over operator overloading met behulp van voorbeelden.

In C++ kunnen we de manier veranderen waarop operatoren werken voor gebruiker-gedefinieerde types zoals objecten en structuren. Dit heet operator overloading. Bijvoorbeeld,

Stel we hebben drie objecten c1, c2 en result gemaakt van een klasse genaamd Complex die complexe getallen vertegenwoordigt.

Omdat operator overloading ons toestaat om te veranderen hoe operatoren werken, kunnen we herdefiniëren hoe de + operator werkt en deze gebruiken om de complexe getallen van c1 en c2 op te tellen 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 makkelijk te begrijpen.

Let op: We kunnen operator overloading niet gebruiken voor fundamentale datatypes zoals int, float, char enz.

Syntax voor C++ Operator Overloading

Om een operator te overladen, gebruiken we een speciale operator functie. We definiëren de functie binnen de klasse of structuur wiens objecten/variabelen we willen dat de overladen operator mee werkt.

 class className { ... .. ... public returnType operator symbol (arguments) { ... .. ... } ... .. ... };

Hier,

• returnType is het returntype van de functie.
• operator is een keyword.
• symbol is de operator die we willen overladen. Zoals: +, <, -, ++, etc.
• arguments is de argumenten die aan de functie doorgegeven worden.

Operator Overloading in Unaire Operatoren

Unaire operatoren opereren op slechts één operand. De increment-operator ++ en decrement-operator -- zijn voorbeelden van unaire operatoren.

Voorbeeld 1: ++ Operator (Unaire Operator) Overloading

 // Overload ++ wanneer gebruikt als prefix #include <iostream> using namespace std; class Count { private: int value; public: // Constructor om count te initialiseren op 5 Count() : value(5) {} // Overload ++ wanneer gebruikt als prefix void operator ++ () { ++value; } void display() { cout << "Count: " << value << endl; } }; int main() { Count count1; // Roep de "void operator ++ ()" functie aan ++count1; count1.display(); return 0; }

Output

 Count: 6

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

Let op: Wanneer we operatoren overladen, kunnen we ze laten werken op elke manier die we willen. Bijvoorbeeld, we hadden ++ kunnen gebruiken om value met 100 te verhogen.

Echter, dit maakt onze code verwarrend en moeilijk te begrijpen. Het is onze taak als programmeur om operator overloading correct en op een consistente, intuïtieve manier te gebruiken.

Het bovenstaande voorbeeld werkt alleen wanneer ++ als prefix gebruikt wordt. Om ++ te laten werken als postfix gebruiken we deze syntax.

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

Let op de int binnen de haakjes. Het is de syntax gebruikt voor unaire operatoren als postfix; het is geen functieparameter.

Voorbeeld 2: ++ Operator (Unaire Operator) Overloading

 // Overload ++ wanneer gebruikt als prefix en postfix #include <iostream> using namespace std; class Count { private: int value; public: // Constructor om count te initialiseren op 5 Count() : value(5) {} // Overload ++ wanneer gebruikt als prefix void operator ++ () { ++value; } // Overload ++ wanneer gebruikt als postfix void operator ++ (int) { value++; } void display() { cout << "Count: " << value << endl; } }; int main() { Count count1; // Roep de "void operator ++ (int)" functie aan count1++; count1.display(); // Roep de "void operator ++ ()" functie aan ++count1; count1.display(); return 0; }

Output

 Count: 6 Count: 7

Het Voorbeeld 2 werkt wanneer ++ zowel als prefix als postfix gebruikt wordt. Echter, het werkt niet als we proberen zoiets te doen als dit:

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

Dit is omdat het returntype van onze operatorfunctie void is. We kunnen dit probleem oplossen door Count als het returntype van de operatorfunctie te maken.

 // return Count wanneer ++ gebruikt als prefix Count operator ++ () { // code } // return Count wanneer ++ gebruikt als postfix Count operator ++ (int) { // code }

Voorbeeld 3: Returnwaarde van operatorfunctie (++ Operator)

 #include <iostream> using namespace std; class Count { private: int value; public : // Constructor om count te initialiseren op 5 Count() : value(5) {} // Overload ++ wanneer gebruikt als prefix Count operator ++ () { Count temp; // Hier is value het value-attribuut van het aanroepende object temp.value = ++value; return temp; } // Overload ++ wanneer gebruikt als postfix Count operator ++ (int) { Count temp; // Hier is value het value-attribuut van het aanroepende object temp.value = value++; return temp; } void display() { cout << "Count: " << value << endl; } }; int main() { Count count1, result; // Roep de "Count operator ++ ()" functie aan result = ++count1; result.display(); // Roep de "Count operator ++ (int)" functie aan result = count1++; result.display(); return 0; }

Output

 Count: 6 Count: 6

Hier hebben we de volgende code gebruikt voor prefix operator overloading:

 // Overload ++ wanneer gebruikt als prefix Count operator ++ () { Count temp; // Hier is value het value-attribuut van het aanroepende object temp.value = ++value; return temp; }

De code voor de postfix operator overloading is ook vergelijkbaar. Let op dat we een object temp hebben aangemaakt en de waarde ervan teruggegeven hebben aan de operatorfunctie.

Ook, let op de code

 temp.value = ++value; 

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

Operator Overloading in Binaire Operatoren

Binaire operatoren 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 overladen voor gebruiker-gedefinieerde types door de code te gebruiken:

 obj3 = obj1 + obj2;

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

Voorbeeld 4: C++ Binaire Operator Overloading

 // C++ programma om de binaire operator + te overladen // Dit programma telt twee complexe getallen op #include <iostream> using namespace std; class Complex { private: float real; float imag; public: // Constructor om real en imag te initialiseren op 0 Complex() : real(0), imag(0) {} void input() { cout << "Voer reële en imaginaire delen respectievelijk in: "; cin >> real; cin >> imag; } // Overload de + 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 getal: " << real << imag << "i"; else cout << "Output Complex getal: " << real << "+" << imag << "i"; } }; int main() { Complex complex1, complex2, result; cout << "Voer eerste complexe getal in:\n"; complex1.input(); cout << "Voer tweede complexe getal in:\n"; complex2.input(); // complex1 roept de operatorfunctie aan // complex2 wordt als argument doorgegeven aan de functie result = complex1 + complex2; result.output(); return 0; }

Output

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

In dit programma is de operatorfunctie:

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

In plaats van dit, hadden we deze functie ook kunnen schrijven als:

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

Echter,

• het gebruik van & maakt onze code efficiënter door te refereren naar het complex2 object in plaats van een duplicaatobject binnen de operatorfunctie aan te maken.
• het gebruik van const wordt als een goede praktijk beschouwd omdat het de operatorfunctie voorkomt complex2 te wijzigen.

Dingen om te onthouden bij C++ Operator Overloading

1. Twee operatoren = en & zijn al standaard overladen in C++. Bijvoorbeeld, om objecten van dezelfde klasse te kopiëren, kunnen we direct de = operator gebruiken. We hoeven geen operatorfunctie aan te maken.
2. Operator overloading kan de precedente en associativiteit van operatoren niet veranderen. Echter, als we de evaluatievolgorde willen veranderen, moeten haakjes worden gebruikt.
3. Er zijn 4 operatoren die niet overladen kunnen worden in C++. Zij zijn:
   1. :: (scope resolution)
   2. . (lidselectie)
   3. .* (lidselectie via pointer naar functie)
   4. ?: (ternaire operator)

Bezoek deze pagina's om meer te leren over:

• Hoe de increment-operator op de juiste manier te overladen?
• Hoe de binaire operator - te overladen om complexe getallen af te trekken?