C++ Operator Överbelastning med exempel

syntax

Att överbelasta a C++ operatör, bör du definiera en speciell funktion i klassen enligt följande:

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

Här är en förklaring till ovanstående syntax:

• Return_type är returtypen för funktionen.
• Därefter nämner du operatorns nyckelord.
• Symbolen anger operatörssymbolen som ska överbelastas. Till exempel, +, -, <, ++.
• Argumentet/argumenten kan skickas till operatorfunktionen på samma sätt som funktioner.

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera std-namnutrymmet i vårt program för att använda dess klasser utan att anropa det.
3. Skapa en klass som heter TestClass.
4. Använd modifieraren för privat åtkomst, som markerar en klassmedlem som privat tillgänglig.
5. Skapa ett heltalsvariabelantal. Denna variabel kommer att vara privat tillgänglig.
6. Använd modifieraren för offentlig åtkomst, som markerar en klassmedlem som privat tillgänglig.
7. Använd en klasskonstruktor för att initiera variabelräknaren till 5.
8. Överbelasta betydelsen av operatorn —.
9. Operatören kommer att minska värdet på variabeln x med 1.
10. Slutet på operatörens överbelastningssektion. Operatören har fått ett nytt namn.
11. Definiera en funktion som heter Display() funktion.
12. Skriv ut värdet för variabelantal tillsammans med annan text på konsolen när Display()-funktionen anropas. } markerar slutet på display()-funktionens brödtext.
13. Slutet av klassens kropp.
14. Anropa main()-funktionen. Programlogiken bör läggas till i denna funktion.
15. Skapa en instans av klassen TestClass och ge den namnet tc.
16. Detta kommer att anropa void-operatorn –()-funktionen.
17. Använd inställningen för TestClass Class för att anropa Display()-funktionen.
18. Funktionen måste returnera värde efter framgångsrikt slutförande.
19. Slutet på kroppen av funktionen main().

Olika förhållningssätt till Operator Överbelastning in C++

Du kan utföra överbelastning av operatören genom att implementera någon av följande typer av funktioner:

1. Medlemsfunktion
2. Icke-medlemsfunktion
3. Vänfunktion

• Operatörens överbelastningsfunktion kan vara en medlemsfunktion när en vänsteroperand är ett objekt i klassen.
• När vänsteroperanden är annorlunda, Operator överbelastningsfunktion bör vara en icke-medlemsfunktion.

Du kan göra operatörens överbelastningsfunktion till en vänfunktion om den behöver komma åt de privata och skyddade klassmedlemmarna.

Kan alla C++ Operators vara överbelastade?

Nej. Det finns C++ operatörer som inte kan överbelastas.

De innefattar:

• :: -Omfattningsupplösningsoperatör
• ?: -ternär operator.
• . -medlemsväljare
• Operatörens storlek
• * -medlemspekarväljare

Saker att komma ihåg

1. Med operatörsöverbelastning kan du omdefiniera hur en operatör fungerar endast för de användardefinierade typerna (objekt, strukturer). Du kan inte använda den för inbyggda typer (float, char, int, etc.).
2. = och & C++ operatörer är överbelastade som standard. Du kan till exempel kopiera objekten i samma klass direkt med operatorn =.
3. Operator prioritet ändrar inte associativt och prioritet för operatörer. Du kan dock ändra utvärderingsordningen med parentes.
4. Det finns fyra operatörer som du inte kan överbelasta i C++. De inkluderar omfångsupplösningsoperatorn (::), medlemsvalsoperator (.), medlemsval genom en pekare till funktionsoperator (.*) och den ternära operatorn (?:).

Regler för Operator överbelastning

Här finns regler för Operator överbelastning:

• För att det ska fungera måste minst en operand vara ett användardefinierat klassobjekt.
• Du kan bara överbelasta befintliga operatörer. Du kan inte överbelasta nya operatörer.
• Vissa operatörer kan inte överbelastas med en vänfunktion. Sådana operatörer kan dock överbelastas med hjälp av medlemsfunktionen.

Hur man överbelasta Operator

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera std-namnutrymmet i vårt program för att använda dess klasser utan att anropa det.
3. Skapa en klass med namnet OperatorOverload.
4. Använd modifieraren för privat åtkomst, som markerar en klassmedlem som privat tillgänglig.
5. Skapa en heltalsvariabel x. Denna variabel kommer att vara privat tillgänglig.
6. Använd modifieraren för offentlig åtkomst, som markerar en klassmedlem som privat tillgänglig.
7. Använd en klasskonstruktor för att initiera variabel x till 10.
8. Överbelasta innebörden av ++ operatorn.
9. Operatören kommer att öka värdet på variabel x med 2.
10. Slutet på operatörens överbelastningssektion. Operatören har fått ett nytt namn.
11. Anropar Print()-funktionen.
12. Skriv ut värdet på variabel x tillsammans med annan text på konsolen när funktionen Print() anropas.
13. Slutet av brödtexten för Print()-funktionen.
14. Slutet av klassens kropp.
15. Anropa main()-funktionen. Programlogiken bör läggas till i denna funktion.
16. Skapa en instans av OperatorOverload Klass som heter ov.
17. Detta kommer att anropa void-operatorn ++()-funktionen.
18. Använd hållningen av OperatorOverload-klassen för att anropa Print()-funktionen.
19. Funktionen måste returnera värde efter framgångsrikt slutförande.
20. Slutet på kroppen av funktionen main().

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vårt program för att kunna använda dess funktioner.
2. Inkludera std-namnområdet i vårt program för att kunna använda dess klasser utan att anropa det.
3. Skapa en klass som heter TestClass. { markerar början av klasskroppen.
4. Använd modifieraren för privat åtkomst för att markera variabler som privata, vilket innebär att de bara kan nås från klassen.
5. Definiera två heltalsvariabler, reella och över.
6. Använd public access-modifieraren för att markera konstruktorn som offentlig, vilket innebär att den kommer att vara tillgänglig även utanför klassen.
7. Skapar klasskonstruktorn och initierar variabler.
8. Initiera värdet på variabeln real.
9. Initiera värdet på variabeln över.
10. Slutet på konstruktorkroppen.
11. Åsidosätt innebörden av operatorn +.
12. Skapa datatypresultatet av typen TestClass.
13. Använd operatorn + med komplexa tal. Denna rad lägger till den reella delen av ett tal till den reella delen av ett annat tal.
14. Använd operatorn + med komplexa tal. Denna linje kommer att lägga till den imaginära delen av ett tal till den imaginära delen av ett annat tal.
15. Programmet kommer att returnera värdet på variabelresultatet vid framgångsrik exekvering.
16. Slutet på definitionen av den nya betydelsen av + operatör, det vill säga överbelastning.
17. Anropa metoden print().
18. Skriv ut det nya komplexa numret efter tillägg på konsolen.
19. Slutet på body of print()-funktionen.
20. Slutet på kroppen av TestClass Class.
21. Anropar funktionen main().
22. Passar värdena för både verkliga och komplexa delar som ska läggas till. Den första delen av c1 kommer att läggas till den första delen av c2, det vill säga 9+4. Den andra delen av c1 kommer att läggas till den andra delen av c, det vill säga 5+3.
23. Utföra en operation med operatorn överbelastad + och lagra resultatet i variabel c3.
24. Skriver ut värdet för variabel c3 på konsolen.
25. Slutet på huvuddelen av funktionen main().

Sammanfattning

• Du kan ange mer än en betydelse för en C++ Operatören i ett omfång.
• Detta kallas för operatörsöverbelastning.
• Operator överbelastning ger en speciell betydelse av en operatör för en användardefinierad datatyp.
• Du kan omdefiniera majoriteten av C++ operatörer genom operatörsöverbelastning.
• Inte alla C++ operatörer kan överbelastas.
• För att en operatör ska överbelastas måste minst en av operanderna vara ett användardefinierat objekt.
• Endast befintliga operatörer kan överbelastas. Du kan inte överbelasta nya operatörer.