C++ Operator Ylikuormitus esimerkeillä

Syntaksi

Ylikuormittaaksesi a C++ -operaattoria, sinun tulee määrittää luokan sisällä erityinen funktio seuraavasti:

class class_name
{
    ... .. ...
    public
       return_type operator symbol (argument(s))
       {
           ... .. ...
       } 
    ... .. ...
};

Tässä on selitys yllä olevalle syntaksille:

• Palautustyyppi on funktion palautustyyppi.
• Seuraavaksi mainitset operaattorin avainsanan.
• Symboli tarkoittaa ylikuormitettua käyttäjäsymbolia. Esimerkiksi +, -, <, ++.
• Argumentti(t) voidaan välittää operaattorifunktiolle samalla tavalla kuin funktiot.

Esimerkki 1

#include <iostream>
using namespace std;
class TestClass {
private:
	int count;
public:
	TestClass() : count(5) {}
	void operator --() {
		count = count - 3;
	}
	void Display() { 

		cout << "Count: " << count; }
};

int main() {
	TestClass tc;
	--tc;
	tc.Display();
	return 0;
}

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisällytä iostream-otsikkotiedosto koodiimme käyttääksesi sen toimintoja.
2. Sisällytä std-nimiavaruus ohjelmaamme, jotta voit käyttää sen luokkia kutsumatta sitä.
3. Luo luokka nimeltä TestClass.
4. Käytä yksityisen käyttöoikeuden muokkausta, joka merkitsee luokan jäsenen yksityisesti käytettävissä olevaksi.
5. Luo kokonaislukumuuttujamäärä. Tämä muuttuja on yksityisesti käytettävissä.
6. Käytä julkisen käyttöoikeuden muokkausta, joka merkitsee luokan jäsenen yksityisesti käytettävissä olevaksi.
7. Käytä luokkakonstruktoria alustaaksesi muuttujalaskurin arvoksi 5.
8. Ylikuormita operaattorin merkitys.
9. Operaattori pienentää muuttujan x arvoa yhdellä.
10. Kuljettajan ylikuormitusosan loppu. Operaattorille on annettu uusi nimi.
11. Näyttö()-nimisen funktion määrittäminen.
12. Tulosta muuttujan count arvo muun tekstin rinnalle konsoliin, kun Display()-funktiota kutsutaan. } merkitsee Display()-funktion rungon loppua.
13. Luokan rungon loppu.
14. Kutsu main()-funktiota. Ohjelmalogiikka tulisi lisätä tähän toimintoon.
15. Luo esiintymä luokasta TestClass ja anna sille nimi tc.
16. Tämä kutsuu void-operaattorin –()-funktion.
17. Käytä TestClass Class -asentoa Display()-funktion kutsumiseen.
18. Toiminnon on palautettava arvo, kun se on suoritettu.
19. Funktion main() rungon loppu.

Erilaisia ​​lähestymistapoja Operator Ylikuormitus sisään C++

Voit suorittaa operaattorin ylikuormituksen toteuttamalla minkä tahansa seuraavista toiminnoista:

1. Jäsentoiminto
2. Ei-jäsentoiminto
3. Ystävätoiminto

• Operaattorin ylikuormitusfunktio voi olla jäsenfunktio, kun vasen operandi on luokan objekti.
• Kun vasen operandi on erilainen, Operator-ylikuormitustoiminnon tulisi olla ei-jäsentoiminto.

Voit tehdä operaattorin ylikuormitustoiminnosta ystävätoiminnon, jos se tarvitsee pääsyn yksityisiin ja suojattuihin luokan jäseniin.

Voiko kaikki C++ Operaovatko ne ylikuormitettuja?

Ei. On C++ operaattorit, joita ei voi ylikuormittaa.

Niihin kuuluvat:

• :: -Scope-resoluutiooperaattori
• ?: -kolmioperaattori.
• . -jäsenvalitsin
• Operaattorin koko
• * -jäsen osoittimen valitsin

Muistettavaa

1. Operaattorin ylikuormituksella voit määrittää uudelleen tavan, jolla operaattori toimii vain käyttäjän määrittämille tyypeille (objektit, rakenteet). Et voi käyttää sitä sisäänrakennetuissa tyypeissä (float, char, int jne.).
2. = ja & C++ operaattorit ovat oletuksena ylikuormitettuja. Voit esimerkiksi kopioida saman luokan objektit suoraan =-operaattorilla.
3. OperaEnsisijaisuus ei muuta operaattoreiden assosiatiivisuutta ja ensisijaisuutta. Voit kuitenkin muuttaa arvioinnin järjestystä suluilla.
4. On neljä operaattoria, joita et voi ylikuormittaa C++. Niitä ovat laajuuden erotteluoperaattori (::), jäsenvalintaoperaattori (.), jäsenvalinta osoittimen avulla toimintooperaattoriin (.*) ja kolmiosainen operaattori (?:).

Säännöt Operator Ylikuormitus

Tässä ovat säännöt Operator ylikuormitus:

• Jotta se toimisi, vähintään yhden operandin on oltava käyttäjän määrittämä luokkaobjekti.
• Voit ylikuormittaa vain olemassa olevia operaattoreita. Uusia operaattoreita ei voi ylikuormittaa.
• Joitakin operaattoreita ei voi ylikuormittaa kaveritoiminnolla. Tällaiset operaattorit voidaan kuitenkin ylikuormittaa jäsentoimintoa käyttämällä.

Kuinka ylikuormittaa OperaTor

Esimerkki 1

#include <iostream>   
using namespace std;
class OperatorOverload {
private:
	int x;

public:
	OperatorOverload() : x(10) {}
	void operator ++() {
		x = x + 2;
	}
	void Print() {
		cout << "The Count is: " << x;
		}
};
int main() {
	OperatorOverload ov;
	++ov;   
	ov.Print();
	return 0;
}

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisällytä iostream-otsikkotiedosto koodiimme käyttääksesi sen toimintoja.
2. Sisällytä std-nimiavaruus ohjelmaamme, jotta voit käyttää sen luokkia kutsumatta sitä.
3. Luo luokka nimeltä OperatoOverload.
4. Käytä yksityisen käyttöoikeuden muokkausta, joka merkitsee luokan jäsenen yksityisesti käytettävissä olevaksi.
5. Luo kokonaislukumuuttuja x. Tämä muuttuja on yksityisesti käytettävissä.
6. Käytä julkisen käyttöoikeuden muokkausta, joka merkitsee luokan jäsenen yksityisesti käytettävissä olevaksi.
7. Käytä luokkakonstruktoria alustaaksesi muuttujan x arvoon 10.
8. Ylikuormitetaan ++-operaattorin merkitys.
9. Operaattori lisää muuttujan x arvoa kahdella.
10. Kuljettajan ylikuormitusosan loppu. Operaattorille on annettu uusi nimi.
11. Print()-funktion kutsuminen.
12. Tulosta muuttujan x arvo muun tekstin rinnalle konsolissa, kun Print()-funktiota kutsutaan.
13. Print()-funktion rungon loppu.
14. Luokan rungon loppu.
15. Kutsu main()-funktiota. Ohjelmalogiikka tulisi lisätä tähän toimintoon.
16. Luo esiintymä OperatorOverload Luokka nimeltä ov.
17. Tämä kutsuu void-operaattorin ++() -funktion.
18. Käytä asentoa OperatorOverload-luokka kutsuaksesi Print()-funktiota.
19. Toiminnon on palautettava arvo, kun se on suoritettu.
20. Funktion main() rungon loppu.

Esimerkki 2

#include<iostream> 
using namespace std;

class TestClass {
private:
	int real, over;
public:
	TestClass(int rl = 0, int ov = 0) {
		real = rl;
		over = ov;
	}

	TestClass operator + (TestClass const &obj) {
		TestClass result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() {
		cout << real << " + i" << over << endl;
	}
};
int main()
{
	TestClass c1(9, 5), c2(4, 3);
	TestClass c3 = c1 + c2;
	c3.print();
}

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisällytä iostream-otsikkotiedosto ohjelmaamme käyttääksemme sen toimintoja.
2. Sisällytä std-nimiavaruus ohjelmaamme, jotta voit käyttää sen luokkia kutsumatta sitä.
3. Luo luokka nimeltä TestClass. { merkitsee luokan rungon alkua.
4. Käytä yksityisen käyttöoikeuden muokkaajaa merkitäksesi muuttujat yksityisiksi, mikä tarkoittaa, että niihin pääsee vain luokasta käsin.
5. Määritä kaksi kokonaislukumuuttujaa, real ja over.
6. Käytä julkisen käyttöoikeuden muokkaajaa merkitsemään rakentaja julkiseksi, mikä tarkoittaa, että se on käytettävissä myös luokan ulkopuolella.
7. Luokan rakentajan luominen ja alustaminen muuttujat.
8. Alusta muuttujan real arvo.
9. Alusta muuttujan arvo yli.
10. Rakentajan rungon loppu.
11. Ohita +-operaattorin merkitys.
12. Luo tietotyypin tulos, jonka tyyppi on TestClass.
13. Käytä +-operaattoria kompleksilukujen kanssa. Tämä rivi lisää luvun reaaliosan toisen luvun reaaliosaan.
14. Käytä +-operaattoria kompleksilukujen kanssa. Tämä rivi lisää luvun imaginaarisen osan toisen luvun imaginaariseen osaan.
15. Ohjelma palauttaa muuttujan tuloksen arvon onnistuneen suorituksen jälkeen.
16. + -operaattorin uuden merkityksen, eli ylikuormituksen, määritelmän loppu.
17. Kutsu print()-menetelmää.
18. Tulosta uusi kompleksiluku lisäyksen jälkeen konsolissa.
19. Print()-funktion rungon loppu.
20. TestClass-luokan rungon loppu.
21. Main()-funktion kutsuminen.
22. Sekä todellisten että monimutkaisten lisättävien osien arvojen välittäminen. C1:n ensimmäinen osa lisätään c2:n ensimmäiseen osaan, eli 9+4. C1:n toinen osa lisätään c:n toiseen osaan, eli 5+3.
23. Toiminnon suorittaminen ylikuormitettu + -operaattorilla ja tuloksen tallentaminen muuttujaan c3.
24. Muuttujan c3 arvon tulostaminen konsoliin.
25. Main()-funktion rungon loppu.

Yhteenveto

• Voit määrittää a:lle useamman kuin yhden merkityksen C++ operaattori yhdessä laajuudessa.
• Tätä kutsutaan operaattorin ylikuormitukseksi.
• Operator overloading tarjoaa operaattorin erityisen merkityksen käyttäjän määrittämälle tietotyypille.
• Voit määrittää suurimman osan uudelleen C++ operaattorit ylikuormituksen vuoksi.
• Ei kaikki C++ operaattorit voivat olla ylikuormitettuja.
• Jotta operaattori olisi ylikuormitettu, ainakin yhden operandeista on oltava käyttäjän määrittämä objekti.
• Vain olemassa olevat käyttäjät voivat ylikuormittua. Et voi ylikuormittaa uusia operaattoreita.