Metodeoverbelastning & standardparametre i Delphi

Funktioner og procedurer er en vigtig del af Delphi-sproget. Fra Delphi 4 giver Delphi os mulighed for at arbejde med funktioner og procedurer, der understøtter standardparametre (at gøre parametre valgfrit), og tillader to eller flere rutiner at have et identisk navn, men fungerer som helt forskellige rutiner.

Lad os se, hvordan overbelastning og standardparametre kan hjælpe dig med at kode bedre.

Kort sagt, overbelastning erklærer mere end en rutine med samme navn. Overbelastning giver os mulighed for at have flere rutiner, der deler det samme navn, men med et andet antal parametre og typer.

Lad os som et eksempel overveje følgende to funktioner:

{Overbelastede rutiner skal deklareres. med overbelastningsdirektivet}fungere SumAsStr (a, b: heltal): snor; overbelaste; begynde Resultat: = IntToStr (a + b); ende; fungere SumAsStr (a, b: udvidet; Cifre: heltal): snor; overbelaste; begynde Resultat: = FloatToStrF (a + b, ffFixed, 18, cifre); ende; 

Disse erklæringer skaber to funktioner, begge kaldet SumAsStr, der tager et andet antal parametre og er af to forskellige typer. Når vi kalder en overbelastet rutine, skal kompilatoren kunne fortælle, hvilken rutine vi vil kalde.

For eksempel kalder SumAsStr (6, 3) den første SumAsStr-funktion, fordi dens argumenter er heltalværdier.

Bemærk: Delphi hjælper dig med at vælge den rigtige implementering ved hjælp af kodeudfyldelse og kodeindsigt.

Overvej på den anden side, om vi forsøger at kalde SumAsStr-funktionen som følger:

 SomeString: = SumAsStr (6.0,3.0) 

Vi får en fejl, der lyder: "der er ingen overbelastet version af 'SumAsStr', der kan kaldes med disse argumenter."Dette betyder, at vi også bør inkludere den cifferparameter, der bruges til at specificere antallet af cifre efter decimalpunktet.

Bemærk: Der er kun en regel, når man skriver overbelastede rutiner, og det er, at en overbelastet rutine skal afvige i mindst én parametertype. Returtypen kan i stedet ikke bruges til at skelne mellem to rutiner.

Lad os sige, at vi har en rutine i enhed A, og enhed B bruger enhed A, men erklærer en rutine med samme navn. Erklæringen i enhed B behøver ikke overbelastningsdirektivet - vi skal bruge enhed A's navn til at kvalificere opkald til A's version af rutinen fra enhed B.

Overvej noget lignende:

enhed B;... anvendelser EN;... procedure RoutineName; begynde Resultat: = A.RoutineName; ende; 

Et alternativ til at bruge overbelastede rutiner er at bruge standardparametre, som normalt resulterer i mindre kode at skrive og vedligeholde.

For at forenkle nogle udsagn kan vi give en standardværdi for parameteren til en funktion eller procedure, og vi kan kalde rutinen med eller uden parameteren, hvilket gør den valgfri. For at tilvejebringe en standardværdi skal du afslutte parameterdeklarationen med det samme (=) symbol efterfulgt af et konstant udtryk.

For eksempel i betragtning af erklæringen

fungere SumAsStr (a, b: udvidet; Cifre: heltal = 2): snor; 

følgende funktionskald er ækvivalente.

 SumAsStr (6.0, 3.0) 

 SumAsStr (6.0, 3.0, 2) 

Bemærk: Parametre med standardværdier skal forekomme i slutningen af ​​parameterlisten og skal sendes efter værdi eller som const. En referenceparameter (var) kan ikke have en standardværdi.

Når vi kalder rutiner med mere end en standardparameter, kan vi ikke springe parametre (som i VB):

fungere SkipDefParams (Var A: streng; B: heltal = 5, C: boolsk = falsk): boolsk;... // dette opkald genererer en fejlmeddelelse
CantBe: = SkipDefParams ('delphi', sandt); 

Når du bruger både overbelastning af funktion eller procedure og standardparametre, må du ikke introducere tvetydige rutinedeklarationer.

Overvej følgende erklæringer:

procedure DOIt (A: udvidet; B: heltal = 0); overbelaste; procedure DoIt (A: udvidet); overbelaste; 

Opkaldet til DoIt-procedure som DoIt (5.0) kompileres ikke. På grund af standardparameteren i den første procedure kan denne erklæring muligvis kalde begge procedurer, fordi det er umuligt at fortælle, hvilken procedure der skal kaldes.