Programmering

Sådan arbejder du med operatøroverbelastning i C #

Polymorfisme er et af de grundlæggende principper i OOP (Object Oriented Programming). Ordet polymorfisme er afledt af to ord - "poly" betyder mange og "morph" betyder former. Derfor indebærer polymorfisme eksistensen af ​​det samme, men i forskellige former.

Operatøroverbelastning er et eksempel på statisk polymorfisme. Du kan udnytte operatøroverbelastning eller tilføje funktionalitet til operatører for at arbejde med brugerdefinerede typer på samme måde som du arbejder med grundlæggende datatyper.

Hvad er operatørerne, og hvad er de operatører, der kan overbelastes?

I et udtryk har du typisk operatorer og operander. Operatører er dem, der arbejder på operander, og de er alle en del af et udtryk. Som et eksempel er det følgende et udtryk, der indeholder to operander og en operator. Operanderne er X og Y, og operatøren er +.

X + Y

Operatører klassificeres som unary, binær, sammenligning, tildeling osv. Afhængigt af deres formål og antallet af operander, som operatørerne vil arbejde på. Selvom de fleste operatører kan overbelastes, gælder der visse begrænsninger. I det væsentlige kan ikke alle operatører overbelastes.

De unære operatører, dvs. operatører, der arbejder med en operand, kan overbelastes. Du kan også overbelaste binære operatorer og sammenligningsoperatorer som ==,! =,, =. Du kan dog ikke overbelaste operatorerne =,?, ->, new, is, sizeof eller typeof. Du kan ikke overbelaste de betingede operatører som && og || let. Også matrixindekseringsoperatøren [] kan ikke overbelastes.

Du kan lære mere om, hvad alle operatører kan overbelastes fra denne MSDN-artikel.

Implementering af operatøroverbelastning i C #

I dette afsnit vil vi undersøge, hvordan vi kan implementere overbelastning af operatører i C #. Overvej følgende klasse med navnet DistanceCalculator.

offentlig klasse DistanceCalculator

   {

Int32 fod = 0, tomme = 0;

offentlig DistanceCalculator (Int32 fod = 0, Int32 tomme = 0)

       {

dette. fødder = fødder;

this.inch = tomme;

       }

   }

Se kodelisten ovenfor. Klassen DistanceCalculator indeholder to dataelementer af typen Int32, nemlig fødder og tomme. Vi vil nu tilføje flere metoder til denne klasse for at illustrere, hvordan operatører kan overbelastes.

Når du arbejder med overbelastning af operatører, skal du huske visse punkter. Operatøren, der skal overbelastes, skal have en tilsvarende metode, der er markeret med nøgleordsoperatøren. Argumenterne for operatørfunktionen er operander, og din operatørfunktion kan returnere en værdi. Operatørfunktionen skal være statisk, og den skal være et medlem af den indeholdende type.

Følgende kodestykke illustrerer, hvordan en typisk operatørfunktion vil se ud. Dette eksempel viser, hvordan operatorerne == og! = Kan overbelastes.

offentlig statisk bool-operator == (DistanceCalculator obj1, DistanceCalculator obj2)

       {

returnere obj1.Value == obj2.Value;

       }

offentlig statisk bool-operator! = (DistanceCalculator obj1, DistanceCalculator obj2)

       {

returnere obj1.Value! = obj2.Value;

       }

Bemærk, at værdi er en egenskab, der returnerer værdien udtrykt i tomme.

offentlig Int32-værdi

       {

           {

retur (fødder * 12) + tomme;

           }

       }

Her er den komplette kodeliste for DistanceCalculator-klassen.

offentlig klasse DistanceCalculator

   {

Int32 fod = 0, tomme = 0;

offentlig DistanceCalculator (Int32 fod = 0, Int32 tomme = 0)

       {

dette. fødder = fødder;

this.inch = tomme;

       }

offentlig statisk bool-operator == (DistanceCalculator obj1, DistanceCalculator obj2)

       {

returnere obj1.Value == obj2.Value;

       }

offentlig statisk bool-operator! = (DistanceCalculator obj1, DistanceCalculator obj2)

       {

return obj1.Value! = obj2.Value;

       }

offentlig tilsidesættelse af bool er lig (objekt obj)

       {

DistanceCalculator distanceCalculator = obj som DistanceCalculator;

hvis (distanceCalculator! = null)

           {

returnere (distanceCalculator == dette);

           }

returner falsk;

       }

offentlig tilsidesættelse af GetHashCode ()

       {

returnere Value.GetHashCode ();

       }

offentlige Int32 fødder

       {

få {retur fødder; }

       }

offentlige Int32 tommer

       {

få {retur tomme; }

       }

offentlig Int32-værdi

       {

           {

retur (fødder * 12) + tomme;

           }

       }

   }

Følgende kodestykke illustrerer, hvordan du kan bruge klassen DistanceCalculator.

statisk ugyldigt Main (streng [] args)

       {

DistanceCalculator obj1 = ny DistanceCalculator (1, 2);

DistanceCalculator obj2 = ny DistanceCalculator (1, 2);

Console.WriteLine ((obj1 == obj2) .ToString ());

Console.Read ();

       }

Følgende kodestykke viser, hvordan du kan overbelaste + -operatøren for at tilføje to objekter.

offentlig statisk DistanceCalculator operator + (DistanceCalculator obj1, DistanceCalculator obj2)

       {

Int32 totalInches = obj1.Value + obj2.Value;

Int32 fod = total tommer / 12;

Int32 inch = totalInches% 12;

DistanceCalculator temp = ny DistanceCalculator (fod, tomme);

retur temp;

       }

Lad os tilføje følgende to egenskaber til klassen DistanceCalculator. Følgende kodestykke viser, hvordan du kan tilføje to objekter af typen DistanceCalculator og returnere det resulterende objekt som den samme type, dvs. det returnerede objekt er af typen DistanceCalculator.

offentlige Int32 fødder

       {

få {retur fødder; }

       }

offentlige Int32 tommer

       {

få {retur tomme; }

       }

Her er hvordan du kan oprette to forekomster af klassen DistanceCalculator og drage fordel af den overbelastede operatørfunktion til at tildele resultatet til et andet objekt af samme type.

statisk ugyldigt Main (streng [] args)

       {

DistanceCalculator obj1 = ny DistanceCalculator (1, 11);

DistanceCalculator obj2 = ny DistanceCalculator (1, 2);

DistanceCalculator obj3 = obj1 + obj2;

Console.WriteLine ("Fødder:" + obj3.Feet.ToString ());

Console.WriteLine ("Inch:" + obj3.Inch.ToString ());

Console.Read ();

       }