Метод Претоварване и параметри по подразбиране в Delphi

Функции и процедури са важна част от езика на Delphi. Започвайки с Delphi 4, Delphi ни позволява да работим с функции и процедури, които поддържат параметрите по подразбиране (създаване на параметри по избор) и позволява на две или повече подпрограми да имат идентично име, но работят като напълно различни съчетания.

Нека да видим как претоварването и параметрите по подразбиране могат да ви помогнат да кодирате по-добре.

Най-просто казано, претоварването декларира повече от една рутина със същото име. Претоварването ни позволява да имаме множество процедури, които споделят едно и също име, но с различен брой параметри и типове.

Като пример, нека разгледаме следните две функции:

{Претоварените процедури трябва да бъдат декларирани. с директивата за претоварване}функция SumAsStr (a, b: цяло число): низ; свръхтовар; започвам Резултат: = IntToStr (a + b); край; функция SumAsStr (a, b: разширен; Цифри: цяло число): низ; свръхтовар; започвам Резултат: = FloatToStrF (a + b, ffFixed, 18, цифри); край; 

Тези декларации създават две функции, наречени SumAsStr, които приемат различен брой параметри и са от два различни типа. Когато извикваме претоварен рутин, компилаторът трябва да е в състояние да каже на коя рутина искаме да се обадим.

Например, SumAsStr (6, 3) извиква първата функция на SumAsStr, тъй като неговите аргументи са целочислени.

Забележка: Delphi ще ви помогне да изберете правилната реализация с помощта на попълване на код и поглед върху кода.

От друга страна, помислете, ако се опитаме да извикаме функцията SumAsStr, както следва:

 SomeString: = SumAsStr (6.0,3.0) 

Ще получим грешка, която гласи: "няма претоварена версия на 'SumAsStr', която може да бъде извикана с тези аргументи.„Това означава, че трябва да включим и параметъра Digits, използван за определяне на броя цифри след десетичната запетая.

Забележка: Има само едно правило при писане на претоварени процедури и това е, че претоварената рутина трябва да се различава поне в един тип параметър. Вместо това типът връщане не може да се използва за разграничаване между две подпрограми.

Да речем, че в единица A имаме една рутина и блок B използва единица A, но декларира рутина със същото име. Декларацията в блок B не се нуждае от директива за претоварване - трябва да използваме името на единица A, за да отговаряме на повикванията към версията на рутината на A от блок B.

Помислете за нещо подобно:

мерна единица Б;... употреби А;... процедура RoutineName; започвам Резултат: = A.RoutineName; край; 

Алтернатива на използването на претоварени процедури е да се използват параметри по подразбиране, което обикновено води до по-малко код за писане и поддържане.

За да опростим някои оператори, можем да дадем стойност по подразбиране за параметъра на функция или процедура и можем да извикаме рутината с или без параметъра, което го прави по избор. За да предоставите стойност по подразбиране, завършете декларацията на параметъра с символа равен (=), последван от постоянен израз.

Например, като се има предвид декларацията

функция SumAsStr (a, b: разширен; Цифри: цяло число = 2): низ; 

следните извиквания на функции са еквивалентни.

 SumAsStr (6.0, 3.0) 

 SumAsStr (6.0, 3.0, 2) 

Забележка: Параметрите със стойности по подразбиране трябва да се появят в края на списъка с параметри и трябва да бъдат предадени по стойност или като const. Референтен (var) параметър не може да има стойност по подразбиране.

Когато извикваме подпрограми с повече от един параметър по подразбиране, не можем да пропуснем параметрите (като в VB):

функция SkipDefParams (Var Струна; B: integer = 5, C: boolean = False): булева;... // това повикване генерира съобщение за грешка
CantBe: = SkipDefParams ('delphi',, True); 

Когато използвате параметри за претоварване на функция или процедура и по подразбиране, не въвеждайте двусмислени рутинни декларации.

Помислете за следните декларации:

процедура DoIt (A: удължен; B: цяло число = 0); свръхтовар; процедура DoIt (A: удължен); свръхтовар; 

Обаждането към DoIt процедура като DoIt (5.0), не се компилира. Поради параметъра по подразбиране в първата процедура, този оператор може да извика и двете процедури, тъй като е невъзможно да се каже коя процедура има за цел да бъде извикана.