C++ Operator Overbelastning med eksempler

Syntaks

At overbelaste a C++ operatør, skal du definere en speciel funktion inde i klassen som følger:

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

Her er en forklaring på ovenstående syntaks:

• Return_type er returtypen for funktionen.
• Dernæst nævner du operatornøgleordet.
• Symbolet angiver det operatørsymbol, der skal overbelastes. For eksempel +, -, <, ++.
• Argumentet eller argumenterne kan overføres til operatorfunktionen på samme måde som funktioner.

Eksempel 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;
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluderer iostream-headerfilen i vores kode for at bruge dens funktioner.
2. Inkluder std-navneområdet i vores program for at bruge dets klasser uden at kalde det.
3. Opret en klasse ved navn TestClass.
4. Brug den private adgangsmodifikator, som markerer et klassemedlem som privat tilgængeligt.
5. Opret et heltalsvariabelantal. Denne variabel vil være privat tilgængelig.
6. Brug offentlig adgangsmodifikator, som markerer et klassemedlem som privat tilgængeligt.
7. Brug en klassekonstruktør til at initialisere variabeltælleren til 5.
8. Overbelast betydningen af ​​— operatoren.
9. Operatøren vil formindske værdien af ​​variablen x med 1.
10. Slut på operatørens overbelastningssektion. Operatøren har fået et nyt navn.
11. Definere en funktion ved navn Display() funktion.
12. Udskriv værdien af ​​variabelantal sammen med anden tekst på konsollen, når Display()-funktionen kaldes. } markerer slutningen af ​​display()-funktionens brødtekst.
13. Slutningen af ​​klassens krop.
14. Kald funktionen main(). Programlogikken skal tilføjes i denne funktion.
15. Opret en instans af klassen TestClass og giv den navnet tc.
16. Dette kalder void-operatoren –()-funktionen.
17. Brug holdningen til TestClass Class til at kalde Display()-funktionen.
18. Funktionen skal returnere værdi efter vellykket afslutning.
19. Slutningen af ​​kroppen af ​​funktionen main().

Forskellige tilgange til Operator Overbelastning ind C++

Du kan udføre operatøroverbelastning ved at implementere en af ​​følgende typer funktioner:

1. Medlemsfunktion
2. Ikke-medlemsfunktion
3. Ven funktion

• Operatørens overbelastningsfunktion kan være en medlemsfunktion, når en venstre operand er et objekt i klassen.
• Når venstre operand er anderledes, vil Operator overbelastningsfunktion bør være en ikke-medlemsfunktion.

Du kan gøre operatørens overbelastningsfunktion til en vennefunktion, hvis den skal have adgang til de private og beskyttede klassemedlemmer.

Kan alle C++ Operators være overbelastet?

Nej. Det er der C++ operatører, der ikke kan overbelastes.

De omfatter:

• :: -Scope resolution operator
• ?: -ternær operator.
• . -medlemsvælger
• Størrelse på operatør
• * -medlemsmarkørvælger

Ting at huske

1. Med operatøroverbelastning kan du omdefinere den måde, en operatør kun fungerer på for de brugerdefinerede typer (objekter, strukturer). Du kan ikke bruge det til indbyggede typer (float, char, int osv.).
2. = og & C++ operatører er overbelastet som standard. For eksempel kan du kopiere objekterne i den samme klasse direkte ved at bruge =-operatoren.
3. Operator forrang ændrer ikke den associative og forrang for operatører. Du kan dog ændre rækkefølgen af ​​evalueringen ved hjælp af parentes.
4. Der er fire operatører, som du ikke kan overbelaste i C++. De inkluderer scope resolution operator (::), member selection operator (.), member selection via en pointer to function operator (.*) og den ternære operator (?:).

Regler for Operator overbelastning

Her er regler for Operator overbelastning:

• For at det kan fungere, skal mindst én operand være et brugerdefineret klasseobjekt.
• Du kan kun overbelaste eksisterende operatører. Du kan ikke overbelaste nye operatører.
• Nogle operatører kan ikke overbelastes ved hjælp af en ven-funktion. Sådanne operatører kan dog blive overbelastet ved hjælp af medlemsfunktionen.

Sådan overbelastes OperaTor

Eksempel 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;
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluderer iostream-headerfilen i vores kode for at bruge dens funktioner.
2. Inkluder std-navneområdet i vores program for at bruge dets klasser uden at kalde det.
3. Opret en klasse med navnet OperatorOverload.
4. Brug den private adgangsmodifikator, som markerer et klassemedlem som privat tilgængeligt.
5. Opret en heltalsvariabel x. Denne variabel vil være privat tilgængelig.
6. Brug offentlig adgangsmodifikator, som markerer et klassemedlem som privat tilgængeligt.
7. Brug en klassekonstruktør til at initialisere variabel x til 10.
8. Overlæs betydningen af ​​++ operatoren.
9. Operatøren vil øge værdien af ​​variabel x med 2.
10. Slut på operatørens overbelastningssektion. Operatøren har fået et nyt navn.
11. Kaldning af Print()-funktionen.
12. Udskriv værdien af ​​variabel x sammen med anden tekst på konsollen, når funktionen Print() kaldes.
13. Slutningen af ​​brødteksten af ​​Print()-funktionen.
14. Slutningen af ​​klassens krop.
15. Kald funktionen main(). Programlogikken skal tilføjes i denne funktion.
16. Opret en instans af OperatorOverload Klasse ved navn ov.
17. Dette kalder void-operatoren ++()-funktionen.
18. Brug holdningen til OperatorOverload-klassen for at kalde Print()-funktionen.
19. Funktionen skal returnere værdi efter vellykket afslutning.
20. Slutningen af ​​kroppen af ​​funktionen main().

Eksempel 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();
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluderer iostream header-filen i vores program for at bruge dens funktioner.
2. Inkluder std-navneområdet i vores program for at bruge dets klasser uden at kalde det.
3. Opret en klasse ved navn TestClass. { markerer begyndelsen af ​​klassens brødtekst.
4. Brug den private adgangsmodifikator til at markere variabler som private, hvilket betyder, at de kun kan tilgås fra klassen.
5. Definer to heltalsvariabler, reelle og over.
6. Brug public access modifier til at markere konstruktøren som offentlig, hvilket betyder, at den vil være tilgængelig selv uden for klassen.
7. Oprettelse af klassekonstruktøren og initialisering af variabler.
8. Initialiser værdien af ​​variabel reel.
9. Initialiser værdien af ​​variablen over.
10. Slut på konstruktørlegemet.
11. Tilsidesæt betydningen af ​​+-operatoren.
12. Opret datatyperesultatet af typen TestClass.
13. Brug operatoren + med komplekse tal. Denne linje tilføjer den reelle del af et tal til den reelle del af et andet tal.
14. Brug operatoren + med komplekse tal. Denne linje tilføjer den imaginære del af et tal til den imaginære del af et andet tal.
15. Programmet returnerer værdien af ​​det variable resultat ved vellykket udførelse.
16. Slutningen af ​​definitionen af ​​den nye betydning af + operator, det vil sige overbelastning.
17. Kald print() metoden.
18. Udskriv det nye komplekse tal efter tilføjelse på konsollen.
19. Slutningen af ​​body of print()-funktionen.
20. Slutningen af ​​kroppen af ​​TestClass Class.
21. Kalder hoved()-funktionen.
22. Passer værdierne af både reelle og komplekse dele, der skal tilføjes. Den første del af c1 vil blive tilføjet den første del af c2, det vil sige 9+4. Den anden del af c1 vil blive tilføjet til den anden del af c, det vil sige 5+3.
23. Udførelse af en operation ved hjælp af overbelastet + operator og lagring af resultatet i variabel c3.
24. Udskrivning af værdien af ​​variabel c3 på konsollen.
25. Slutningen af ​​hoveddelen af ​​funktionen main().

Resumé

• Du kan angive mere end én betydning for en C++ operatør i ét omfang.
• Dette kaldes operatøroverbelastning.
• Operator overbelastning giver en speciel betydning af en operatør for en brugerdefineret datatype.
• Du kan omdefinere størstedelen af C++ operatører gennem operatøroverbelastning.
• Ikke alle C++ operatører kan blive overbelastet.
• For at en operator skal overbelastes, skal mindst en af ​​operanderne være et brugerdefineret objekt.
• Kun eksisterende operatører kan overbelastes. Du kan ikke overbelaste nye operatører.