Metodöverbelastning och standardparametrar i Delphi

Funktioner och procedurer är en viktig del av Delphi-språket. Från och med Delphi 4 tillåter Delphi oss att arbeta med funktioner och procedurer som stöder standardparametrar (att göra parametrar valfritt), och tillåter två eller flera rutiner att ha ett identiskt namn men fungerar som helt annorlunda rutiner.

Låt oss se hur överbelastning och standardparametrar kan hjälpa dig att koda bättre.

Enkelt uttryckt förklarar överbelastning mer än en rutin med samma namn. Överbelastning tillåter oss att ha flera rutiner som har samma namn, men med ett annat antal parametrar och typer.

Låt oss som exempel överväga följande två funktioner:

{Överbelastade rutiner måste deklareras. med överbelastningsdirektivet}fungera SumAsStr (a, b: heltal): sträng; överbelastning; Börja Resultat: = IntToStr (a + b); slutet; fungera SumAsStr (a, b: förlängd; Siffror: heltal): sträng; överbelastning; Börja Resultat: = FloatToStrF (a + b, ffFixed, 18, siffror); slutet; 

Dessa deklarationer skapar två funktioner, båda kallade SumAsStr, som tar ett annat antal parametrar och är av två olika typer. När vi kallar en överbelastad rutin måste kompilatorn kunna berätta vilken rutin vi vill ringa.

Exempelvis kallar SumAsStr (6, 3) den första SumAsStr-funktionen, eftersom dess argument är heltalvärderade.

Notera: Delphi hjälper dig att välja rätt implementering med hjälp av kodfyllning och kodinsikt.

Å andra sidan, överväga om vi försöker kalla SumAsStr-funktionen enligt följande:

 SomeString: = SumAsStr (6.0,3.0) 

Vi får ett fel som lyder: "det finns ingen överbelastad version av 'SumAsStr' som kan kallas med dessa argument."Detta betyder att vi också bör inkludera siffran Parametern som används för att ange antalet siffror efter decimalpunkten.

Notera: Det finns bara en regel när man skriver överbelastade rutiner, och det är att en överbelastad rutin måste skilja sig åt i åtminstone en parametertyp. Returtypen kan istället inte användas för att skilja mellan två rutiner.

Låt oss säga att vi har en rutin i enhet A, och enhet B använder enhet A, men förklarar en rutin med samma namn. Förklaringen i enhet B behöver inte överbelastningsdirektivet - vi bör använda enhet A: s namn för att kvalificera samtal till A: s version av rutinen från enhet B.

Tänk på något liknande:

enhet B;... användningar A;... procedur RoutineName; Börja Resultat: = A.RoutineName; slutet; 

Ett alternativ till att använda överbelastade rutiner är att använda standardparametrar, vilket vanligtvis resulterar i mindre kod att skriva och underhålla.

För att förenkla vissa uttalanden kan vi ge ett standardvärde för parametern för en funktion eller procedur, och vi kan ringa rutinen med eller utan parametern, vilket gör det valfritt. För att tillhandahålla ett standardvärde, avsluta parameterdeklarationen med symbolen lika (=) följt av ett konstant uttryck.

Till exempel med tanke på deklarationen

fungera SumAsStr (a, b: förlängd; Siffror: heltal = 2): sträng; 

följande funktionssamtal är likvärdiga.

 SumAsStr (6.0, 3.0) 

 SumAsStr (6.0, 3.0, 2) 

Notera: Parametrar med standardvärden måste inträffa i slutet av parameterlistan och måste skickas efter värde eller som const. En referensparameter (var) kan inte ha ett standardvärde.

När vi ringer rutiner med mer än en standardparameter, kan vi inte hoppa över parametrar (som i VB):

fungera SkipDefParams (var A: sträng; B: heltal = 5, C: booleskt = falskt): booleskt;... // detta samtal genererar ett felmeddelande
CantBe: = SkipDefParams ('delphi',, sant); 

När du använder både överbelastning av funktioner eller procedurer och standardparametrar ska du inte införa tvetydiga rutinedeklarationer.

Tänk på följande förklaringar:

procedur DoIt (A: förlängd; B: heltal = 0); överbelastning; procedur DoIt (A: utökad); överbelastning; 

Samtalet till DoIt-proceduren som DoIt (5.0) sammanställs inte. På grund av standardparametern i den första proceduren kan detta uttalande anropa båda procedurerna, eftersom det är omöjligt att säga vilken procedur som är tänkt att anropas.