C ++ operatøroverbelastning (med eksempler)

I denne veiledningen vil vi lære om overbelastning av operatører ved hjelp av eksempler.

I C ++ kan vi endre måten operatører jobber for brukerdefinerte typer som objekter og strukturer. Dette er kjent som operatøroverbelastning . For eksempel,

Anta at vi har opprettet tre objekter c1, c2 og resultat fra en klasse som heter Complexkomplekse tall.

Siden operatøroverbelastning lar oss endre hvordan operatører fungerer, kan vi omdefinere hvordan +operatøren fungerer og bruke den til å legge til de komplekse tallene c1 og c2 ved å skrive følgende kode:

 result = c1 + c2;

i stedet for noe sånt

 result = c1.addNumbers(c2);

Dette gjør koden vår intuitiv og lett å forstå.

Merk: Vi kan ikke bruke operatør overbelastning for grunnleggende datatyper som int, float, charog så videre.

Syntaks for C ++ operatøroverbelastning

For å overbelaste en operatør bruker vi en spesiell operatorfunksjon.

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

Her,

returnType er returtypen til funksjonen.
operatør er et nøkkelord.
symboler operatøren vi vil overbelaste. Som: +, <, -, ++, etc.
arguments er argumentene overført til funksjonen.

Overbelastning av operatører hos unære operatører

Unary operatører opererer bare på en operand. Økningsoperatøren ++og dekrementoperatøren --er eksempler på unary operatører.

Eksempel1: ++ Operatør (Unary Operator) Overbelastning

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

Produksjon

 Antall: 6

Her, når vi bruker ++count1;, void operator ++ ()kalles det. Dette øker verdien attributtet for objektet count1 med 1.

Merk: Når vi overbelaster operatører, kan vi bruke den til å fungere på den måten vi vil. For eksempel kunne vi ha brukt ++til å øke verdien med 100.

Dette gjør imidlertid koden vår forvirrende og vanskelig å forstå. Det er vår jobb som programmerer å bruke operatøroverbelastning riktig og på en konsistent og intuitiv måte.

Ovennevnte eksempel fungerer bare når ++det brukes som et prefiks. For å få et ++arbeid som et postfix bruker vi denne syntaksen.

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

Legg merke til intinnsiden av parentesene. Det er syntaksen som brukes til å bruke unary operatorer som postfix; det er ikke en funksjonsparameter.

Eksempel 2: ++ Operatør (Unary Operator) Overbelastning

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

Produksjon

 Antall: 6 Antall: 7

Den Eksempel 2 fungerer når ++brukes som både prefiks og postfiks. Det fungerer imidlertid ikke hvis vi prøver å gjøre noe slikt:

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

Dette er fordi returtypen til vår operatørfunksjon er void. Vi kan løse dette problemet ved å lage Countsom returtype for operatørfunksjonen.

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

Eksempel 3: Returverdi fra operatørfunksjon (++ 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; )

Produksjon

 Antall: 6 Antall: 7

Her har vi brukt følgende kode for overbelastning av prefiksoperatø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 for overbelastning av postfix-operatøren er også den samme. Legg merke til at vi har opprettet et objekttemp og returnert verdien til operatørfunksjonen.

Legg også merke til koden

 temp.value = ++value;

Variabelverdien tilhører count1-objektet main()fordi count1 kaller funksjonen, mens temp.value tilhører temp-objektet.

Overbelastning av operatører i binære operatører

Binære operatører jobber på to operander. For eksempel,

 result = num + 9;

Her +er en binær operatør som fungerer på operandene num og 9.

Når vi overbelaster den binære operatøren for brukerdefinerte typer ved å bruke koden:

 obj3 = obj1 + obj2;

Operatørfunksjonen kalles ved hjelp av obj1-objektet og obj2 sendes som et argument til funksjonen.

Eksempel 4: C ++ binær operatøroverbelastning

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

Produksjon

 Angi første komplekse nummer: Angi henholdsvis reelle og imaginære deler: 9 5 Angi andre komplekse nummer: Angi henholdsvis reelle og imaginære deler: 7 6 Utgang Kompleks nummer: 16 + 11i

I dette programmet er operatørfunksjonen:

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

I stedet for dette kunne vi også ha skrevet denne funksjonen som:

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

Men,

bruk &gjør koden vår effektiv ved å referere til complex2-objektet i stedet for å lage et duplikatobjekt inne i operatørfunksjonen.
bruk constbetraktes som en god praksis fordi det forhindrer operatørfunksjonen i å endre kompleks2.

Overbelastning av binære operatører i C ++

Ting å huske i C ++ operatøroverbelastning

To operatører =og &er allerede overbelastet som standard i C ++. For eksempel, for å kopiere objekter av samme klasse, kan vi bruke =operatøren direkte. Vi trenger ikke opprette en operatørfunksjon.
Overbelastning av operatører kan ikke endre operatørenes forrang og tilknytning. Imidlertid, hvis vi ønsker å endre rekkefølgen på evalueringen, bør parentes brukes.
Det er 4 operatører som ikke kan overbelastes i C ++. De er:
1. :: (omfangsoppløsning)
2. . (medlemsvalg)
3. .* (medlemsvalg gjennom pekeren for å fungere)
4. ?: (ternær operatør)