C ++ - käyttäjän ylikuormitus (esimerkkien kanssa)

Tässä opetusohjelmassa opitaan käyttäjän ylikuormituksesta esimerkkien avulla.

C ++ -sovelluksessa voimme muuttaa tapaa, jolla operaattorit työskentelevät käyttäjän määrittelemille tyyppeille, kuten esineille ja rakenteille. Tätä kutsutaan käyttäjän ylikuormitukseksi . Esimerkiksi,

Oletetaan, että olemme luoneet kolme objektia c1, c2 ja johtuvat luokasta nimeltä, Complexjoka edustaa kompleksilukuja.

Koska operaattorin ylikuormitus antaa meille mahdollisuuden muuttaa operaattoreiden toimintaa, voimme määrittää +operaattorin toiminnan uudelleen ja lisätä sen avulla c1: n ja c2: n kompleksiluvut kirjoittamalla seuraavan koodin:

 result = c1 + c2;

jotain sellaista

 result = c1.addNumbers(c2);

Tämä tekee koodistamme intuitiivisen ja helposti ymmärrettävän.

Huom: Emme voi käyttää operaattorin ylikuormitusta perusoikeuksien tietotyyppejä kuten int, float, charja niin edelleen.

Syntaksi C ++ - operaattorin ylikuormitukselle

Operaattorin ylikuormittamiseen käytämme erityistoimintoa operator.

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

Tässä,

returnType on funktion palautustyyppi.
operaattori on avainsana.
symbolon operaattori, jonka haluamme ylikuormittaa. Kuten: +, <, -, ++, jne
arguments on funktiolle välitetyt argumentit.

Operaattorin ylikuormitus Unary Operatorissa

Unary-operaattorit toimivat vain yhdellä operandilla. Inkrementtioperaattori ++ja vähennysoperaattori --ovat esimerkkejä unary-operaattoreista.

Esimerkki 1: ++ Operaattori (Unary Operator) Ylikuormitus

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

Tuotos

 Laskenta: 6

Tässä, kun käytämme ++count1;, void operator ++ ()kutsutaan. Tämä lisää objektimäärän1 arvoattribuuttia yhdellä.

Huomaa: Kun ylikuormitamme operaattoreita, voimme käyttää sitä toimimaan haluamallamme tavalla. Olisimme voineet esimerkiksi ++lisätä arvoa 100: lla.

Tämä tekee koodistamme kuitenkin hämmentävän ja vaikeasti ymmärrettävän. Meidän tehtävämme ohjelmoijana on käyttää käyttäjän ylikuormitusta oikein, johdonmukaisella ja intuitiivisella tavalla.

Yllä oleva esimerkki toimii vain, kun ++sitä käytetään etuliitteenä. Tehdäkseen ++työn postfix-tiedostona käytämme tätä syntaksia.

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

Huomaa intsulkujen sisäpuoli. Se on syntaksia, jota käytetään unary-operaattoreiden käyttämiseen postfix-koodina; se ei ole toimintoparametri.

Esimerkki 2: ++ Operaattori (Unary Operator) Ylikuormitus

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

Tuotos

 Laskea: 6 Laskea: 7

Esimerkki 2 toimii, kun ++käytetään sekä etuliite ja postfix. Se ei kuitenkaan toimi, jos yritämme tehdä jotain tällaista:

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

Tämä johtuu siitä, että operaattoritoimintomme palautustyyppi on void. Voimme ratkaista tämän ongelman tekemällä Countoperaattorin palautustyypiksi.

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

Esimerkki 3: Palautusarvo operaattoritoiminnosta (++ operaattori)

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

Tuotos

 Laskea: 6 Laskea: 7

Tässä olemme käyttäneet seuraavaa koodia etuliiteoperaattorin ylikuormitukseen:

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

Myös postfix-operaattorin ylikuormituksen koodi on sama. Huomaa, että olemme luoneet objektilämpötilan ja palauttaneet sen arvon operaattoritoiminnolle.

Huomaa myös koodi

 temp.value = ++value;

Muuttujan arvo kuuluu count1-objektille, main()koska count1 kutsuu funktiota, kun taas temp.value kuuluu temp-objektiin.

Operaattorin ylikuormitus binäärioperaattoreissa

Binaariset operaattorit työskentelevät kahdella operandilla. Esimerkiksi,

 result = num + 9;

Tässä +on binäärioperaattori, joka toimii operandeilla num ja 9.

Kun ylikuormitamme binäärioperaattoria käyttäjän määrittelemille tyypeille koodin avulla:

 obj3 = obj1 + obj2;

Operaattoritoimintoa kutsutaan objektilla obj1 ja obj2 välitetään argumenttina funktiolle.

Esimerkki 4: C ++ - binäärioperaattorin ylikuormitus

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

Tuotos

 Syötä ensimmäinen kompleksiluku: Syötä todelliset ja kuvitteelliset osat: 9 5 Syötä toinen kompleksiluku: Syötä todelliset ja kuvitteelliset osat: 7 6 Lähtökompleksin numero: 16 + 11i

Tässä ohjelmassa operaattoritoiminto on:

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

Tämän sijasta olisimme voineet myös kirjoittaa tämän toiminnon kuten:

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

Kuitenkin,

käyttäminen &tekee koodistamme tehokkaan viittaamalla complex2-objektiin sen sijaan, että tehdään päällekkäinen objekti operaattoritoiminnon sisällä.
käyttöä constpidetään hyvänä käytäntönä, koska se estää operaattoritoimintoa muokkaamasta kompleksia2.

Binaaristen operaattoreiden ylikuormitus C ++: ssa

Muistettavaa C ++ -operaattorin ylikuormituksessa

Kaksi operaattoria =ja &oletusarvoisesti ylikuormitettu C ++: ssa. Esimerkiksi saman luokan objektien kopioimiseksi voimme käyttää suoraan =operaattoria. Meidän ei tarvitse luoda operaattoritoimintoa.
Operaattorin ylikuormitus ei voi muuttaa operaattoreiden etusijaa ja assosiatiivisuutta. Jos kuitenkin haluamme muuttaa arvioinnin järjestystä, on käytettävä sulkeita.
On 4 operaattoria, joita ei voida ylikuormittaa C ++: ssa. He ovat:
1. :: (soveltamisalan tarkkuus)
2. . (jäsenvalinta)
3. .* (jäsenen valinta osoittimen avulla toimintoon)
4. ?: (kolminkertainen operaattori)