C ++ operatörsöverbelastning med exempel

Innehållsförteckning:

Anonim

Vad är operatörens överbelastning?

Med operatörsöverbelastning i C ++ kan du ange mer än en betydelse för en operatör i ett omfång. Syftet med operatörens överbelastning är att ge en operatör en speciell betydelse för en användardefinierad datatyp.

Med hjälp av operatörsöverbelastning kan du omdefiniera majoriteten av C ++ - operatörerna. Du kan också använda överbelastning av operatören för att utföra olika operationer med en operatör.

I denna C ++ -handledning lär du dig:

  • Vad är operatörens överbelastning?
  • Syntax
  • Olika metoder för överbelastning av operatörer i C ++
  • Kan alla C ++ -operatörer överbelastas?
  • Saker att komma ihåg:
  • Regler för överbelastning av operatörer:
  • Hur överbelastar operatören:

Syntax

För att överbelasta en C ++ -operatör bör du definiera en speciell funktion i klassen enligt följande:

class class_name{… publicreturn_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 operatörens nyckelord.
  • Symbolen betecknar operatörssymbolen som ska överbelastas. Till exempel +, -, <, ++.
  • Argumenten kan skickas till operatörsfunktionen på samma sätt som funktioner.

Exempel 1:

#include 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. Inkluderar iostream-huvudfilen i vår kod för att använda dess funktioner.
  2. Inkludera std-namnområdet i vårt program för att använda sina klasser utan att kalla det.
  3. Skapa en klass med namnet TestClass.
  4. Använd modifieraren för privat åtkomst, som markerar en klassmedlem som privat tillgänglig.
  5. Skapa ett heltal variabelantal. Denna variabel kommer att vara privat tillgänglig.
  6. Använd modifieraren för allmän tillgång, som markerar en klassmedlem som privat tillgänglig.
  7. Använd en klasskonstruktör för att initiera variabelräknaren till 5.
  8. Överbelasta innebörden av operatören.
  9. Operatören minskar 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 med namnet Display () -funktion.
  12. Skriv ut värdet för variabelantal tillsammans med annan text på konsolen när Display () -funktionen anropas. } Markerar slutet på displayfunktionen ().
  13. Slutet på klassens kropp.
  14. Ring huvudfunktionen (). Programlogiken bör läggas till inom denna funktion.
  15. Skapa en instans av klassen TestClass och ge den namnet tc.
  16. Detta kommer att anropa tomrumsoperatören - () -funktionen.
  17. Använd hållningen i TestClass Class för att ringa till Display () -funktionen.
  18. Funktionen måste returnera värde när den har slutförts.
  19. Slutet på huvudfunktionens huvud ().

Olika metoder för överbelastning av operatörer i C ++

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

  1. Medlem Funktion
  2. Icke-medlem-funktion
  3. Vänfunktion
  • Funktionen för överbelastning av operatören kan vara en medlemsfunktion när en vänster operand är ett objekt i klassen.
  • När vänster operand är annorlunda, bör överbelastningsfunktionen för operatören vara en icke-medlem-funktion.

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

Kan alla C ++ -operatörer överbelastas?

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

De inkluderar:

  • :: -Opplösningsoperatör
  • ?: -interna operatören.
  • . -medlemsväljare
  • Operatörens storlek
  • * -medlempekerväljare

Saker att komma ihåg:

  1. Med operatörsöverbelastning kan du omdefiniera hur en operatör endast fungerar 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örerna är överbelastade som standard. Du kan till exempel kopiera objekten i samma klass direkt med operatorn =.
  3. Operatörens företräde ändrar inte operatörernas associativa och företräde. 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ösningsoperatören (: :), operatör för medlemsval (.), Medlemsval genom en pekare till funktionsoperator (. *) Och den ternära operatören (? :).

Regler för överbelastning av operatörer:

Här är regler för operatörsö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 överbelastar operatören:

Exempel 1:

#include 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. Inkluderar iostream-huvudfilen i vår kod för att använda dess funktioner.
  2. Inkludera std-namnområdet i vårt program för att använda sina klasser utan att kalla 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 allmän tillgång, som markerar en klassmedlem som privat tillgänglig.
  7. Använd en klasskonstruktör för att initiera variabeln x till 10.
  8. Överbelasta innebörden av ++ -operatören.
  9. Operatören ökar värdet på variabeln x med 2.
  10. Slutet på operatörens överbelastningssektion. Operatören har fått ett nytt namn.
  11. Ringa utskriftsfunktionen ().
  12. Skriv ut värdet på variabeln x tillsammans med annan text på konsolen när Print () -funktionen anropas.
  13. Slutet på kroppen för funktionen Print ().
  14. Slutet på klassens kropp.
  15. Ring huvudfunktionen (). Programlogiken bör läggas till inom denna funktion.
  16. Skapa en instans av OperatorOverload-klassen med namnet ov.
  17. Detta kommer att anropa tomrumsoperatören ++ () -funktionen.
  18. Använd hållningen till klassen OperatorOverload för att ringa funktionen Print ().
  19. Funktionen måste returnera värde när den har slutförts.
  20. Slutet på huvudfunktionens huvud ().

Exempel 2:

#includeusing 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. Inkluderar 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 sina klasser utan att kalla det.
  3. Skapa en klass med namnet TestClass. {Markerar början på klassens kropp.
  4. Använd modifieraren för privat åtkomst för att markera variabler som privata, vilket innebär att de endast kan nås från klassen.
  5. Definiera två heltal variabler, verkliga och över.
  6. Använd modifieraren för allmän tillgång för att markera konstruktören som allmän, vilket innebär att den kommer att vara tillgänglig även utanför klassen.
  7. Skapa klasskonstruktören och initiera variablerna.
  8. Initiera värdet på variabel real.
  9. Initiera värdet på variabeln över.
  10. Slutet på konstruktörskroppen.
  11. Åsidosätt + operatörens innebörd.
  12. Skapa datatypresultatet av typen TestClass.
  13. Använd + -operatören med komplexa siffror. Denna rad lägger till den verkliga delen av ett nummer till den verkliga delen av ett annat nummer.
  14. Använd + -operatören med komplexa siffror. Denna rad lägger till den imaginära delen av ett nummer till den imaginära delen av ett annat nummer.
  15. Programmet returnerar värdet på det variabla resultatet när det genomförts.
  16. Slutet på definitionen av den nya innebörden av + -operatören, det vill säga överbelastning.
  17. Ring utskriftsmetoden ().
  18. Skriv ut det nya komplexa numret efter tillägget på konsolen.
  19. Slut på funktionen för utskrift ().
  20. Slutet på kroppen i TestClass-klass.
  21. Ringer till huvudfunktionen ().
  22. Skicka värdena för både verkliga och komplexa delar som ska läggas till. Den första delen av c1 läggs till den första delen av c2, det vill säga 9 + 4. Den andra delen av c1 läggs till den andra delen av c, det vill säga 5 + 3.
  23. Utföra en operation med den överbelastade + -operatören och lagra resultatet i variabeln c3.
  24. Skriva ut värdet på variabeln c3 på konsolen.
  25. Slutet på huvudfunktionen ().

Sammanfattning:

  • Du kan ange mer än en mening för en C ++ - operatör i ett omfång.
  • Detta kallas operatörsöverbelastning.
  • Operatörsöverbelastning ger en speciell betydelse för 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 bli överbelastad måste minst en av operanderna vara ett användardefinierat objekt.
  • Endast befintliga operatörer kan överbelastas. Du kan inte överbelasta nya operatörer.