Tomorrow — Функция Delphi

Tomorrow — Функция Delphi

Подскажите как можно определить время выполнения функции.
есть одно предположение:
время после выполнения команды минус время перед выполнением команды, но как определить время.

В моем случае выполняется сортировка массива, нужно определить за какое время она выполняется
Есть функция Time и GetTime но я чето никак не разберусь с ними, хэлп не рулит. там я вообще ничего не пойму.

Кто знает — подскажите.

З.Ы.Дэлфи-консольное приложение. так что если дополнительные подули нужны — напишите плиз.

Модуль DateUtils.pas (в поставке Delphi).
Из этого модуля можно применить функцию MilliSecondsBetween.

procedure TestingFunc;
var T1 : TDateTime; MS : Integer (или Int64);
begin
T1 := Now;
. //тело тестируемой функции
MS := MilliSecondsBetween(Now, T1);
end;

Sanya
именно ими и надо мерять. RDTSC назвается и есть у всех процессоров, начиная с первого пентиума. Скорость выполнения большинства функций gettickcount ом не засечешь, даже если 1000 раз подряд фукнцию вызовешь. Получить текущее значение такта можно так:
function GetCPUTick: int64; assembler;
asm
db 0fh,31h; //rdtsc
end;

Получив этой фукнцией до выолнения и после выполнения ты получишь ПОЧТИ точное кол-во тактов на выполнение фукнции. Почти, потому что время второго вызова RDTSC тоже немножко отжирает. Совсем чуток :)
Darthman1145111327
Кстати, именно этой фукнцией офигенно удобно отлаживать критические к скорости процедуры и куски кода. Отлаживать всмысле смотреть ускорил ты, или замедлил :)

implementation
var t1,diff:Tdatetime ;

procedure TForm1.Button1Click(Sender: TObject);
begin
t1:=now;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
diff:=now-t1;
edit1.text:=TimeTostr(diff);
end;
в результате в поле edit1 отображается время прошедшее между последовательными нажатиями button1 и button2 в следующем формате hh:mm:ss Пойдет?

если вместо TimeTostr(diff) использовать FormatFloat(‘0.00’,diff*24*60*60);
то промежуток времени будет выражен в секундах с сотыми долями. sysutils коорый используется функией now ввключается в uses лист форм по умолчанию.

MilliSecondsBetween(Now, T1);
стало быть функция MilliSecondsBetween(x1,x2)=24*60*60*1000*(x1-x2) :)

Функции Delphi модуля DateUtils

Предлагаем список функций модуля DateUtils , используемого в среде разработки Delphi.

Модуль DateUtils

DayOfTheMonth Дает день месяца для значения TDateTime (ISO 8601)
DayOfTheWeek Возвращает индекс дня недели для значения TDateTime (ISO 8601)
DayOfTheYear Выдает день года для значения TDateTime (ISO 8601)
DaysBetween Выдает целый число дней между 2 датами
DaysInAMonth Выдает число дней в месяце
DaysInAYear Выдает число дней в году
DaySpan Выдает дробное число дней между 2 датами
EncodeDateTime Формирует значение TDateTime из значений времени и дня
EndOfADay Генерирует значение TDateTime, установленное на самый конец дня
EndOfAMonth Генерация значения TDateTime, установленное на самый конец месяца
IncDay Приращивает переменную типа TDateTime на + или — число дней
IncMillisecond Приращивает переменную типа TDateTime на + или — число миллисекунд
IncMinute Приращивает переменную типа TDateTime на + или — число минут.
IncSecond Приращивает переменную типа TDateTime на + или — число секунд
IncYear Увеличивает TDateTime переменную на количество лет
RecodeDate Изменяет только дату переменной TDateTime
RecodeTime Изменяет только время переменной TDateTime
Tomorrow Возвращает дату завтрашнего дня
MonthOfTheYear Выдает месяц года для значения TDateTime
Yesterday Выдает вчерашнюю дату

Функции Delphi модуля DateUtils : 3 комментария

Давно искала подобное, спасибо очень интересно!

Типы, функции и процедуры Delphi для работы с датой и временем.

Содержание:


Функции и процедуры Delphi для работы с датой и временем.


Тип TDateTime.


Тип TTimeStamp.


Тип TSQLTimeStamp.


Функции и процедуры Delphi для работы с датой и временем.


Таблица стандартных процедур и функций для работы с датой и временем

Значения символических констант для обозначения дней недели в соответствии с ISO 8601. Используйте эти константы для работы с функциями, работающими в соответствии со стандартом ISO 8601 (функции из модуля DateUtils).

Внимание: Не используйте эти константы с функцией DayOfWeek, которая трактует Воскресение (Sunday) как первый день недели.

Возвращает день недели из значения TDateTime. Возвращаемое функцией значение находится в промежутке между 1 и 7, где 1 соответствует Понедельнику (Monday), а 7 — Воскресение (Sunday).

Внимание: Значения DayOfTheWeek соответствуют ISO 8601 (где Понедельник (Monday) является первым днем недели). Если хотите чтобы первым днем недели считалось Воскресение (Sunday) используйте функцию DayOfWeek вместо функции DayOfTheWeek.

Совет: Чтобы сделать возвращаемые значения более читабельными, используйте константы Day of week.

Возвращает день недели из значения TDateTime. Возвращаемое функцией значение находится в промежутке между 1 и 7, где Воскресение (Sunday) является первым днем недели, а Суббота (Saturday) — седьмым.

Внимание: Значения DayOfWeek не соответствуют ISO 8601 (где Понедельник (Monday) является первым днем недели). Если хотите чтобы первым днем недели считался Понедельник (Monday) используйте функцию DayOfTheWeek вместо функции DayOfWeek.

Наименование Вид
модуль
Описание
CheckSqlTimeStamp процедура
SqlTimSt
Проверяет соответствует ли значение TSQLTimeStamp правильной дате и времени.
CompareDate функция
DateUtils
Сравнивает два значения TDateTime между собой по значению даты.
CompareDateTime функция
DateUtils
Сравнивает два значения TDateTime между собой.
CompareTime функция
DateUtils
Сравнивает два значения TDateTime между собой по значению времени.
CurrentYear функция
SysUtils
Возвращает текущий год.
Date функция
SysUtils
Возвращает текущую дату.
DateDelta константа
SysUtils
Определяет различие между значениями TDateTime и TTimeStamp.
DateOf функция
DateUtils
«Вырезает» значение времени из TDateTime (устанавливает значение времени в 0, что означает полночь).
DateTimeToFileDate функция
SysUtils
Конвертирует объект TDateTime в формат времени операционной системы.
DateTimeToSQLTimeStamp функция
SqlTimSt
Конвертирует значение TDateTime в TSQLTimeStamp.
DateTimeToStr функция
SysUtils
Конвертирует значение TDateTime в строку.
DateTimeToString процедура
SysUtils
Конвертирует значение TDateTime в строку, используя указаный формат строки.
DateTimeToSystemTime процедура
SysUtils
Конвертирует значение TDateTime в системное время Win32 API.
DateTimeToTimeStamp функция
SysUtils
Конвертирует значение TDateTime в соответствующее значение TTimeStamp.
DateToStr функция
SysUtils
Конвертирует значение даты из TDateTime в строку.
Day of week константы
DateUtils
DayOf функция
DateUtils
Возвращает день месяца из значения TDateTime. Возвращаемое функцией значение находится в промежутке между 1 и 31.
DayOfTheMonth функция
DateUtils
Возвращает день месяца из значения TDateTime. Возвращаемое функцией значение находится в промежутке между 1 и 31.
DayOfTheWeek функция
DateUtils
DayOfTheYear функция
DateUtils
Возвращает количество дней между значением, указаным в TDateTime и 31 Декабря предыдущего года.
DayOfWeek функция
SysUtils
DaysBetween функция
DateUtils
Возвращает количество полных дней из промежутка времени, заданного двумя значениями TDateTime.
DaysInAMonth функция
DateUtils
Возвращает количество дней в указаном месяце указаного года.
DaysInAYear функция
DateUtils
Возвращает количество дней в указаном году.
DaysInMonth функция
DateUtils
Возвращает количество дней в месяце, заданом в значении TDateTime.
DaysInYear функция
DateUtils
Возвращает количество дней в году, заданом в значении TDateTime.
DaySpan функция
DateUtils
Возвращает количество дней, включая дробную часть, из промежутка времени, заданного двумя значениями TDateTime.
DecodeDate процедура
SysUtils
Возвращает значения Год, Месяц, День для значения TDateTime.
DecodeDateDay процедура
DateUtils
Возвращает год и день года для значения, указаного в TDateTime.
DecodeDateFully функция
SysUtils
Возвращает значения Год, Месяц, День, День_Недели для значения TDateTime.
DecodeDateMonthWeek процедура
DateUtils
Возвращает значения Год, Месяц, Неделя_Месяца, День_Недели для значения TDateTime.
DecodeDateTime процедура
DateUtils
Возвращает значения Год, Месяц, День, Час, Минута, Секунда, Милисекунда для значения TDateTime.
DecodeDateWeek процедура
DateUtils
Возвращает значения Год, Неделя_Года, День_Недели для значения TDateTime.
DecodeDayOfWeekInMonth процедура
DateUtils
Для заданного значения TDateTime возвращает Год, Месяц, День_Недели и Число_Дней_в_Этой_Неделе_для_Этого_Месяца.
DecodeTime процедура
SysUtils
Разбивает значение TDateTime на часы, минуты, секунды и милисекунды.
EncodeDate функция
SysUtils
Возвращает значение TDateTime, заданое как Год, Месяц, День.
EncodeDateDay функция
DateUtils
Возвращает значение TDateTime, заданое как указаный день указаного года.
EncodeDateMonthWeek функция
DateUtils
Возвращает значение TDateTime, заданое как указаный день указаной недели в указаном месяце и году.
EncodeDateTime функция
DateUtils
Возвращает значение TDateTime, заданое как Год, Месяц, День, Час, Секунда, Милисекунда.
EncodeDateWeek функция
DateUtils
Возвращает значение TDateTime, заданое как указаный день указаной недели в указаном году.
EncodeDayOfWeekInMonth функция
DateUtils
Возвращает значение TDateTime, заданое как положение дня недели в указаном месяце и году.
EncodeTime функция
SysUtils
Возвращает значение TDateTime, заданое как часы, минуты, секунды и милисекунды.
EndOfADay функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду указаного дня.
EndOfAMonth функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду последнего дня указаного месяца.
EndOfAWeek функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду последнего дня указаной недели.
EndOfAYear функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду последнего дня указаного года.
EndOfTheDay функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду дня, указаного в TDateTime.
EndOfTheMonth функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду последнего дня месяца, указаного в TDateTime.
EndOfTheWeek функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду последнего дня недели, указаной в TDateTime.
EndOfTheYear функция
DateUtils
Возвращает значение TDateTime которое представляет последнюю милисекнду последнего дня года, указаного в TDateTime.
FormatDateTime функция
SysUtils
Возвращает значение TDateTime в виде форматной строки. Если форматная строка не задана, то принимается та, которая основана на текущей локализации системы.
HourOf функция
DateUtils
Возвращает час дня, из значения TDateTime.
HourOfTheDay функция
DateUtils
Возвращает час дня, из значения TDateTime.
HourOfTheMonth функция
DateUtils
Возвращает количество часов между указаным в значении TDateTime и 12:00 AM первого дня месяца.
HourOfTheWeek функция
DateUtils
Возвращает количество часов между указаным в значении TDateTime и 12:00 AM первого дня недели.
HourOfTheYear функция
DateUtils
Возвращает количество часов между указаным в значении TDateTime и 12:00 AM первого дня года.
HoursBetween функция
DateUtils
Возвращает количество полных часов между двумя значениями TDateTime.
HourSpan функция
DateUtils
Возвращает количество часов, включая дробную часть, между двумя значениями TDateTime.
IncAMonth процедура
SysUtils
Увеличивает дату на один месяц.
IncDay функция
DateUtils
Возвращает дату, сдвинутую на указаное число дней.
IncHour функция
DateUtils
Возвращает дату/время, сдвинутую на указаное число часов.
IncMilliSecond функция
DateUtils
Возвращает дату/время, сдвинутую на указаное число милисекунд.
IncMinute функция
DateUtils
Возвращает дату/время, сдвинутую на указаное число минут.
IncMonth функция
SysUtils
Возвращает дату, сдвинутую на указаное число месяцев.
IncSecond функция
DateUtils
Возвращает дату/время, сдвинутую на указаное число секунд.
IncWeek функция
DateUtils
Возвращает дату, сдвинутую на указаное число недель.
IncYear функция
DateUtils
Возвращает дату, сдвинутую на указаное количество лет.
IsInLeapYear функция
DateUtils
Показывает, принадлежит ли значение, указаное в TDateTime, високосному году.
IsLeapYear функция
SysUtils
Показывает, является ли указаный год високосным.
IsPM функция
DateUtils
Показывает, принадлежит ли значение времени, указаное в TDateTime, второй половине дня .
IsSameDay функция
DateUtils
Показывает, принадлежит ли значение, указаное в TDateTime, заданой дате.
IsToday функция
DateUtils
Показывает, принадлежит ли значение, указаное в TDateTime, текущей дате.
IsValidDate функция
DateUtils
Проверяет, являются ли указаные год, месяц и день допустимой датой.
IsValidDateDay функция
DateUtils
Проверяет, являются ли указаные год и день года допустимой датой.
IsValidDateMonthWeek функция
DateUtils
Проверяет, являются ли указаные год, месяц, неделя месяца и день недели допустимой датой.
IsValidDateTime функция
DateUtils
Проверяет, являются ли указаные год, месяц, день, час, минута, секунда и милисекунда допустимыми значениями даты и времени.
IsValidDateWeek функция
DateUtils
Проверяет, являются ли указаные год, неделя года и день недели допустимой датой.
IsValidTime функция
DateUtils
Проверяет, являются ли указаные час, минута, секунда и милисекунда допустимыми значениями даты и времени.
MilliSecondOf функция
DateUtils
Возвращает милисекунды из значения TDateTime.
MilliSecondOfTheDay функция
DateUtils
Возвращает количество милисекунд, прошедшее между значением указаным в TDateTime и началом этого самого дня.
MilliSecondOfTheHour функция
DateUtils
Возвращает количество милисекунд, прошедшее между значением указаным в TDateTime и началом этого самого часа.
MilliSecondOfTheMinute функция
DateUtils
Возвращает количество милисекунд, прошедшее между значением указаным в TDateTime и началом этой самой минуты.
MilliSecondOfTheMonth функция
DateUtils
Возвращает количество милисекунд, прошедшее между значением указаным в TDateTime и началом месяца.
MilliSecondOfTheSecond функция
DateUtils
Возвращает милисекунды из значения TDateTime.
MilliSecondOfTheWeek функция
DateUtils
Возвращает количество милисекунд, прошедшее между значением указаным в TDateTime и 12:00:00:00 AM первого дня недели.
MilliSecondOfTheYear функция
DateUtils
Возвращает количество милисекунд, прошедшее между значением указаным в TDateTime и 12:00:00:00 AM первого дня года.
MilliSecondsBetween функция
DateUtils
Возвращает количество милисекунд между двумя значениями TDateTime.
MilliSecondSpan функция
DateUtils
Возвращает количество милисекунд между двумя значениями TDateTime. Но в качестве результата вместо целого типа испльзуется число с плавающей точкой.
MinuteOf функция
DateUtils
Возвращает минуты из значения TDateTime.
MinuteOfTheDay функция
DateUtils
Возвращает количество минут между значением указаным в TDateTime и 12:00 AM того же дня.
MinuteOfTheHour функция
DateUtils
Возвращает количество минут, прошедшее между значением указаным в TDateTime и началом этого самого часа.
MinuteOfTheMonth функция
DateUtils
Возвращает количество минут, прошедшее между значением указаным в TDateTime и 12:00 AM первого дня месяца.
MinuteOfTheWeek функция
DateUtils
Возвращает количество минут, прошедшее между значением указаным в TDateTime и 12:00 AM первого дня недели.
MinuteOfTheYear функция
DateUtils
Возвращает количество минут, прошедшее между значением указаным в TDateTime и 12:00 AM первого дня года.
MinutesBetween функция
DateUtils
Возвращает количество полных минут между двумя значениями TDateTime.
MinuteSpan функция
DateUtils
Возвращает количество минут, включая дробную часть, между двумя значениями TDateTime.
MonthOf функция
DateUtils
Возвращает месяц года из значения TDateTime.
MonthOfTheYear функция
DateUtils
Возвращает месяц года из значения TDateTime.
MonthsBetween функция
DateUtils
Возвращает количество полных месяцев между двумя значениями TDateTime.
MonthSpan функция
DateUtils
Возвращает количество месяцев, включая дробную часть, между двумя значениями TDateTime.
MSecsToTimeStamp функция
SysUtils
Конвертирует указаное количество милисекунд в значение TTimeStamp.
Now функция
SysUtils
Возвращает текущие дату и время.
NthDayOfWeek функция
DateUtils
Возвращает сколько дней, с таким же порядковым номером дня недели, было в текущем месяце, представленом значением TDateTime.
NullSQLTimeStamp константа
SqlTimSt
Значение NULL для TSQLTimeStamp.
OneHour Constant;
OneMillisecond Constant;
OneMinute Constant;
OneSecond Constant
константы
DateUtils
Обратные константы времени в модуле Delphi.
RecodeDate функция
DateUtils
Меняет в TDateTime значение даты на новые значения Год, Месяц, День. В случае неудачи вызывает исключение EConvertError.
RecodeDateTime функция
DateUtils
Выборочно изменяет в TDateTime значения Год, Месяц, День, Час, Секунда, Милисекунда на заданые. В случае неудачи вызывает исключение EConvertError.
RecodeDay функция
DateUtils
Меняет значение День месяца в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
RecodeHour функция
DateUtils
Меняет значение Час дня в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
RecodeMilliSecond функция
DateUtils
Меняет значение Милисекунда в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
RecodeMinute функция
DateUtils
Меняет значение Минута часа в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
RecodeMonth функция
DateUtils
Меняет значение Месяц года в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
RecodeSecond функция
DateUtils
Меняет значение Секунда часа в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
RecodeTime функция
DateUtils
Меняет в TDateTime значение времени на новые значения Час, Минута, Секунда, Милисекунда. В случае неудачи вызывает исключение EConvertError.
RecodeYear функция
DateUtils
Меняет значение Год в TDateTime на заданое. В случае неудачи вызывает исключение EConvertError.
ReplaceDate процедура
SysUtils
Заменяет значение даты в TDateTime на заданое.
ReplaceTime процедура
SysUtils
Заменяет значение времени в TDateTime на заданое.
SameDate функция
DateUtils
Показывает, представляют ли два значения TDateTime тот же самый год, месяц и день.
SameDateTime функция
DateUtils
Показывает, представляют ли два значения TDateTime те же самые год, месяц, день, час, секунда, милисекунда.
SameTime функция
DateUtils
Показывает, совпадают ли значения времени в двух значениях TDateTime.
SecondOf функция
DateUtils
Возвращает количество секунд минуты из значения TDateTime.
SecondOfTheDay функция
DateUtils
Возвращает количество секунд между значением указаным в TDateTime и 12:00:00 AM того же самого дня.
SecondOfTheHour функция
DateUtils
Возвращает количество секунд между значением указаным в TDateTime и началом того же самого часа.
SecondOfTheMinute функция
DateUtils
Возвращает количество секунд между значением указаным в TDateTime и началом той же самой минуты.
SecondOfTheMonth функция
DateUtils
Возвращает количество секунд между значением указаным в TDateTime и 12:00:00 AM первого дня месяца.
SecondOfTheWeek функция
DateUtils
Возвращает количество секунд между значением указаным в TDateTime и 12:00:00 AM первого дня недели.
SecondOfTheYear функция
DateUtils
Возвращает количество секунд между значением указаным в TDateTime и 12:00:00 AM первого дня года.
SecondsBetween функция
DateUtils
Возвращает количество секунд между двумя значениями TDateTime.
SecondSpan функция
DateUtils
Возвращает количество секунд, включая дробную часть, между двумя значениями TDateTime.
SQLDayOfWeek функция
SqlTimSt
Возвращает день недели из значения TSQLTimeStamp. Возвращаемое функцией значение находится в промежутке между 1 и 7, где Воскресение (Sunday) является первым днем недели, а Суббота (Saturday) — седьмым.
SQLTimeStampToDateTime функция
SqlTimSt
Конвертирует значение TSQLTimeStamp в TDateTime.
SQLTimeStampToStr функция
SqlTimSt
Конвертирует значение TSQLTimeStamp в строку.
StartOfADay функция
DateUtils
Возвращает значение TDateTime которое представляет 12:00:00:00 AM указаного дня.
StartOfAMonth функция
DateUtils
Возвращает значение TDateTime которое представляет 12:00:00:00 AM первого дня указаного месяца.
StartOfAWeek функция
DateUtils
Возвращает значение TDateTime которое представляет первый момент указаного дня указаной недели.
StartOfAYear функция
DateUtils
Возвращает значение TDateTime которое представляет первый момент первого дня указаного года.
StartOfTheDay функция
DateUtils
Возвращает значение TDateTime которое представляет 12:00:00:00 AM дня, заданого значением TDateTime.
StartOfTheMonth функция
DateUtils
Возвращает значение TDateTime которое представляет 12:00:00:00 AM первого дня месяца, заданого значением TDateTime.
StartOfTheWeek функция
DateUtils
Возвращает значение TDateTime которое представляет 12:00:00:00 AM первого дня недели, заданой значением TDateTime.
StartOfTheYear функция DateUtils Возвращает значение TDateTime которое представляет 12:00:00:00 AM первого дня года, заданого значением TDateTime.
StrToDate функция
SysUtils
Конвертирует строку с датой в TDateTime. В случае неудачи вызывает исключение EConvertError.
StrToDateDef функция
SysUtils
Конвертирует строку с датой в TDateTime со значением по умолчанию в случае ошибки.
StrToDateTime функция
SysUtils
Конвертирует строку в значение TDateTime. В случае неудачи вызывает исключение EConvertError.
StrToDateTimeDef функция
SysUtils
Конвертирует строку в значение TDateTime со значением по умолчанию в случае ошибки.
StrToSQLTimeStamp функция
SqlTimSt
Конвертирует строку в значение TSQLTimeStamp. В случае неудачи вызывает исключение EConvertError.
StrToTime функция
SysUtils
Конвертирует строку со временем в значение TDateTime. В случае неудачи вызывает исключение EConvertError.
StrToTimeDef функция
SysUtils
Конвертирует строку со временем в значение TDateTime со значением по умолчанию в случае ошибки.
SystemTimeToDateTime функция
SysUtils
Конвертирует значение системного времени в значение TDateTime.
Time модульные константы
SysUtils
Значения констант для вычисления времени.
Time,
GetTime
функции
SysUtils
Возвращают текущее время.
TimeOf функция
DateUtils
Убирает значение даты из значения TDateTime.
TimeStampToDateTime функция
SysUtils
Конвертирует значение TTimeStamp в соответствующее значение TDateTime.
TimeStampToMSecs функция
SysUtils
Конвертирует значение TTimeStamp в TTimeStamp в абсолютное число милисекунд.
TimeToStr функция
SysUtils
Конвертирует значение времени из TDateTime в строку.
Today функция
DateUtils
Возвращает значение TDateTime, представляющее текущую дату.
Tomorrow функция
DateUtils
Возвращает значение TDateTime, представляющее следующий день.
TryEncodeDate функция
SysUtils
Создает значение TDateTime, предсталяющее указаный Год, Месяц, День. В случае неудачи возвращает False.
TryEncodeDateDay функция
DateUtils
Вычисляет значение TDateTime которое представляет указаный день для указаного года. В случае неудачи возвращает False.
TryEncodeDateMonthWeek функция
DateUtils
Вычисляет значение TDateTime которое представляет указаный день указаной недели в указаном месяце и году. В случае неудачи возвращает False.
TryEncodeDateTime функция
DateUtils
Вычисляет значение TDateTime которое представляет указаные год, месяц, день, час, минуту, секунду и милисекунду. В случае неудачи возвращает False.
TryEncodeDateWeek функция
DateUtils
Вычисляет значение TDateTime которое представляет указаный день указаной недели в указаном году. В случае неудачи возвращает False.
TryEncodeDayOfWeekInMonth функция
DateUtils
Вычисляет значение TDateTime которое представляет указаный день недели в указаном месяце и году. В случае неудачи возвращает False.
TryEncodeTime функция
SysUtils
Создает значение TDateTime для заданых значений Час, Минута, Секунда и Милисекунда. В случае неудачи возвращает False.
TryRecodeDateTime функция
DateUtils
Выборочно меняет значения Год, Месяц, День, Час, Секунда, Милисекунда в указаном TDateTime. В случае неудачи возвращает False.
TryStrToDate функция
SysUtils
Конвертирует строку с датой в TDateTime. В случае неудачи возвращает False.
TryStrToDateTime функция
SysUtils
Конвертирует строку в значение TDateTime. В случае неудачи возвращает False.
TryStrToSQLTimeStamp функция
SqlTimSt
Конвертирует строку в значение TSQLTimeStamp. В случае неудачи возвращает False.
TryStrToTime функция
SysUtils
Конвертирует строку со временем в значение TDateTime. В случае неудачи возвращает False.
UnixDateDelta константа
SysUtils
Определяет разницу между значениями TDateTime и TIME_T. Тип TIME_T используется в системах Unix и Lnux, а так же в стандартных библиотеках C.
WeekOf функция
DateUtils
Возвращает неделю года из значения TDateTime.
WeekOfTheMonth функция
DateUtils
Возвращает неделю месяца из значения TDateTime.
WeekOfTheYear функция
DateUtils
Возвращает неделю года из значения TDateTime.
WeeksBetween функция
DateUtils
Возвращает количество полных недель между двумя значениями TDateTime.
WeeksInAYear функция
DateUtils
Возвращает количество недель в указаном году.
WeeksInYear функция
DateUtils
Возвращает количество недель в году из значения TDateTime.
WeekSpan функция
DateUtils
Возвращает количество недель, включая дробную часть, между двумя значениями TDateTime.
WithinPastDays функция
DateUtils
Показывает, находятся ли две даты в заданом промежутке дней относительно друг друга.
WithinPastHours функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке часов относительно друг друга.
WithinPastMilliSeconds функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке милисекунд относительно друг друга.
WithinPastMinutes функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке минут относительно друг друга.
WithinPastMonths функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке месяцев относительно друг друга.
WithinPastSeconds функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке секунд относительно друг друга.
WithinPastWeeks функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке недель относительно друг друга.
WithinPastYears функция
DateUtils
Показывает, находятся ли два значения даты/времени в заданом промежутке лет относительно друг друга.
YearOf функция
DateUtils
Возвращает Год из значения TDateTime.
YearsBetween функция
DateUtils
Возвращает приблизительное количество лет между двумя значениями TDateTime.
YearSpan функция
DateUtils
Возвращает приблизительное количество лет, включая дробную часть, между двумя значениями TDateTime.
Yesterday функция
DateUtils
Возвращает значение TDateTime которое соответствует предыдущему дню.

Содержание

Тип TDateTime.

Тип TDateTime — это основной тип в Delphi для работы с датой и временем. Он является числом с плавающей запятой, целая часть которого содержит число дней, отсчитанное от некоторого начала календаря, а дробная часть равна части 24-часового дня, т.е. характеризует время и не относится к дате. Для 32-разрядных версий Delphi за начало календаря принята дата 12/30/1899, 12 часов.

Ниже приведены несколько примеров значения TDateTime и соответсвующие им дата и время:

12/30/1899 12:00 am
2.75 1/1/1900 6:00 pm
-1.25 12/29/1899 6:00 am
35065 1/1/1996 12:00 am

Чтобы найти количество дней, включая дробную часть, между двумя датами, просто вычтите два значения, если только одно из них не является отрицательным. Аналогично, если значение TDateTime не отрицательное, то, чтобы увеличить значение даты и времени на определенное кличество дней, включая дробную часть, достаточно прибавить количество дней, включая дробную часть, к значению TDateTime.

Когда обрабатываются отрицательные значения TDateTimes, то вычисление дробной части производится отдельно. Дробная часть отражает часть 24-часового дня не зависимо от знака значения TDateTime. Например, 6:00 am on 12/29/1899 это –1.25, а неt –1 + 0.25, что составило бы –0.75. Значений TDateTime между –1 и 0 не существует. Cовет: В модулях SysUtils и DateUtils для работы с датой и временем имеется большое количество процедур и функций на все случаи жизни. Не заморачивайтесь с обственными вычислениями, не изобретайте велосипед, а пользуйтесь уже готовыми наработками разработчиков Delphi. (См. Функции и процедуры Delphi для работы с датой и временем.) Оно надежнее.

Примечание: В Delphi 1 за начало отсчета принят год 1, т.е. для перевода даты Delphi 1 в дату последующих версий Delphi надо вычесть из даты число 693594.

Содержание

Тип TTimeStamp.

TTimeStamp представляет значения дата и время.

Используйте TTimeStamp если требуется повышеная точность представления значения времени в знчениях дата/время. Если нет необходимости сохранять значение времени с точностью до милисекунд, используйте более компактное TDateTime. Если необходима еще большая точность, то используйте TSQLTimeStamp (но НЕ назначайте его типом Variant).

Поле Time field показывает количество милисекунд, прошедших с полуночи.

Поле Data показывает число календарных дней от начала календаря (число дней с 1/1/0001 плюс один).

Содержание

Тип TSQLTimeStamp.

TSQLTimeStamp представляет значения даты и времени с очень высокой точностью.

Драйвера баз данных dbExpress используют TSQLTimeStamp когда работают со значениями даты и времени.

  • Year определяет год от 1 до 9999.
  • Month определяет месяц от 1 до 12.
  • Day определяет день месяца, от 1 до 28, 29, 30, или 31, в зависимости от значения Month.
  • Hour определяет час от 0 до 23.
  • Minute и Second могут колебаться от 0 до 59.
  • Fractions определяет милисекунды от 0 до 999.

Используя функцию VarSQLTimeStampCreate, Вы можете создать тип Variant который представляет значение TSQLTimeStamp. Фактически, простейший путь манипулирования значениями SQLTimeStamp это создать подобный Variant и использовать встроеные операторы, обеспечивающие работу с Variant.

FAQ — Сводка функций модуля Math

Сводка функций модуля Math

Здесь я привожу полный список всех функций и процедур модуля Math. При переходе от Delphi 2 к Delphi 3 модуль Math почти не изменился, фирма Borland ввела в него только три новые функции: MaxIntVal ue, MInIntValue и Sumint. Эти функции отличаются от своих прототипов (MaxValue, MI nVal ue и Sum) лишь тем, что работают исключительно с целыми числами, не принимая и не возвращая величин с плавающей точкой. Что касается остальных функций, то большинство из них вполне очевидно. Если вам покажется иначе — что ж, садитесь за исследования. И не надейтесь, что все тайны Delphi достанутся вам на блюдечке в виде help-файла!

Тригонометрические функции и процедуры

  • ArcCos — Арккосинус
  • ArcCosh — Пиперболический арккосинус
  • ArcSIn — Арксинус
  • ArcSInh — Гиперболический арксинус
  • ArcTahn — Гиперболический арктангенс
  • ArcTan2 — Арктангенс с учетом квадранта (функция ArcTan, не учитывающая квадрант, находится в модуле System)
  • Cosh — Гиперболический косинус
  • Cotan — Котангенс
  • CycleToRad — Преобразование циклов в радианы
  • DegToRad — Преобразование градусов в радианы
  • GradToRad — Преобразование градов в радианы
  • Hypot — Вычисление гипотенузы прямоугольного треугольника по длинам катетов
  • RadToCycle — Преобразование радианов в циклы
  • RadToDeg — Преобразование радианов в градусы
  • RacIToGrad — Преобразование радианов в грады
  • SinCos — Вычисление синуса и косинуса угла. Как и в случае SumAndSquares и MeanAndStdDev, одновременная генерация обеих величин происходит быстрее
  • Sinh — Гиперболический синус
  • Tan — Тангенс
  • Tanh — Гиперболический тангенс

Функции delphi

Здравствуй, дорогой читатель. Сегодня я планирую рассказать о таком значимом элементе программирования как функции. А если быть точным, будем разбирать функции Delphi.

Начнем с общего определения:

Функция – фрагмент программного кода, который имеет свое имя. По этому имени данный фрагмент можно вызвать из любого места программы. Результатом выполнения функции Delphi является значение.

Объясню доступным языком, зачем нужны функции. Представьте себе ситуацию, что Вам в программе нужно несколько раз вычислять площадь квадрата. Вместо того, чтобы каждый раз писать один и тот же код, Вы можете объявить функцию и просто вызывать её в нужном месте. Если ещё не совсем понятно зачем все это нужно, советую прочесть статью до конца и на примерах станет все ясно.

Давайте разберем как определить функцию.

Итак, в начале идет ключевое слово function, затем имя функции. Далее в круглых скобках список параметров. Также необходимо указать тип возвращаемого результата. При необходимости можно определить локальные переменные. Между операторных скобок (begin..end;) необходимо записать требуемые инструкции.

В каждой функции Delphi автоматически создает переменную с именем result, переменная имеет тот же тип, что и возвращаемое значение функции. С помощью этой переменной мы и будем возвращать значения. (Есть еще одна возможность вернуть значение, её я продемонстрирую на примере).

В функцию можно передавать параметры разных типов: значения, константы, переменные, выходные параметры. Но это тема отдельной статьи, которую я напишу чуть позже.

Разберем применение функций Делфи на простом примере.

Создайте новое приложение и на форме разместите три кнопки (Button).

Далее откройте код и будем писать функцию, цель которой будет возвращать квадрат числа. Описание у нас будет вне класса после строк:

Сама же функция будет иметь следующий вид:

Название – square, параметр всего один – x типа Double, результат тоже будет Double.

Делфи позволяет возвращать значения через переменную, название которой совпадает с названием функции Delphi. В нашем случае это выглядит так: square:=x*x;(закомментированный код).

Теперь посмотрим как можно использовать написанный код. Напишем обработчик события Onclickдля каждой из кнопок.

  • Для первой кнопки — ShowMessage(FloatToStr(square(1)));
  • Для второй — ShowMessage(FloatToStr(square(2)));
  • Для третей — ShowMessage(FloatToStr(square(3)));

У меня получился следующий Unit

Как можно заметить мы однажды определили функцию, а использовали её трижды. Если функция была бы побольше, мы бы сэкономили уйму времени и сил, сократили количество вводимого текста. Модифицировать программу также легче, если Вы используете функции – поправив тело функции вы изменяете логику на всех участках, где она используется.

Подведем итог. Функции делают разработку на Делфи проще и быстрее, код читабельнее, правку проще. Используйте фунуции Delphi.

Возращение функцией 2 и более результата

26.03.2020, 10:16

Более одного результата за один подход к БД
Прошу прощения за неоднозначное название, думал над ним минут 10, безрезультатно. Вопрос вот в.

Вывод результата в строку, не более 10 элементов
Здравствуйте. Начал изучать С++ по книге. Задание: Написать программу запрашивающую 2 числа и.

Выборка из таблицы и отображение более одного результата
Прошу понять и простить, но вопрос в следующем: запрашивается из таблицы по id пользователя его.

Перевод в СС. Как добиться более точного результата
Имеется Конвертер чисел , его дело целое число переводить в 2ич , 8рич 10рич 16рич систему! Но.

Tomorrow — Функция Delphi

Изучив основные «кирпичики», из которых составляются программные инструкции, а именно — переменные и операторы, мы можем приступить к исследованию вопросов их эффективного расположения в теле программы. Для этих целей рассмотрим вопрос использования подпрограмм.

О подпрограммах в Object Pascal

Важной составной частью программирования в Object Pascal является использование подпрограмм — специальным образом оформленных и логически законченных блоков инструкций. Подпрограмму можно вызывать любое число раз из других мест программы, или из других подпрограмм. Таким образом, использование подпрограмм позволяет сделать исходный код более стройным и наглядным.

Структура подпрограммы похожа на программу в миниатюре: она содержит заголовок, блок объявления переменных и блок инструкций. Из отличий можно выделить лишь невозможность подключать модули (блок uses), а так же ограничения на объявления типов данных: если локальные простые и даже составные типы в подпрограммах вполне допустимы, то более сложные типы — объекты, классы и интерфейсы, локальными быть не могут, а потому в подпрограммах их объявлять нельзя.

Использование подпрограммы состоит из 2 этапов: сначала подпрограмму описывают, а затем, уже в блоке инструкций программы, вызывают. Отметим, что в библиотеке Delphi имеется описание тысяч готовых подпрограмм, описывать которые, разумеется, уже не надо. А их вызовом мы уже неоднократно занимались — достаточно взглянуть на любой пример, где мы встречали инструкции, подобные таким:

write(‘Hello, world!’); readln;

Здесь и write, и readln — стандартные подпрограммы Object Pascal. Таким образом, с вызовом подпрограмм мы уже знакомы. Осталось узнать, как создавать собственные, или пользовательские, подпрограммы. Но прежде отметим, что все подпрограммы делятся на 2 лагеря: процедуры и функции. Мы уже использовали эти термины, и даже давали им описание, однако повторимся: процедуры — это такие подпрограммы, которые выполняют предназначенное действие и возвращают выполнение в точку вызова. Функции в целом аналогичны процедурам, за тем исключением, что они еще и возвращают результат своего выполнения. Результатом работы функции могут быть данные любого типа, включая объекты.

Вместе с тем, значение, возвращаемое функцией, можно проигнорировать, в таком случае она ничем не будет отличаться от процедуры. Разумеется, при этом функция все-таки должна выполнить какое-либо действие, сказывающееся на выполнении программы, иначе она потеряет всякий смысл. С другой стороны, процедуры могут возвращать значения через свои параметры — например, как это делает DecodeDate. Таким образом, различия между процедурами и функциями в современном программировании весьма призрачны.

Как процедурам, так и функциям могут передаваться данные для обработки. Делается это при помощи списка параметров. Список параметров в описании подпрограммы и список аргументов, указываемых при ее вызове должен совпадать. Иначе говоря, если в описании определено 2 параметра типа Integer, то, вызывая такую подпрограмму, в качестве аргументов так же следует указать именно 2 аргумента и именно типа Integer или совместимого (скажем, Word или Int64).

ПРИМЕЧАНИЕ
На самом деле, Object Pascal позволяет довольно гибко обращаться с аргументами, для чего имеются различные методы, включая «перегружаемые» функции, значения параметров по умолчанию и т.д. Тем не менее, в типичном случае, количество, тип, и порядок перечисления аргументов при объявлении и при вызове процедуры или функции, должны совпадать.

Любые подпрограммы выполняются до тех пор, пока не будет выполнена последняя инструкция в блоке подпрограммы, или пока в ее теле не встретится специальная процедура exit. Процедура exit досрочно прерывает выполнение подпрограммы и возвращает управление инструкции, следующей за вызовом данной подпрограммы.

Процедуры

Итак, начнем исследование подпрограммы с процедур. Как уже было отмечено, процедуру надо описать. Описание процедуры состоит из заголовка и тела процедуры.

Заголовок состоит из ключевого слова procedure, за которым следует имя процедуры и, при необходимости, список параметров, заключенных в круглые скобки:

Вслед за заголовком может следовать блок объявления локальных меток, типов и переменных. Локальными они называются потому, что предназначены исключительно для этой процедуры.

ПРИМЕЧАНИЕ
Вопросы локальных и глобальных переменных, и вообще видимости в программах, будет рассмотрен позже в этой главе.

После заголовочной части следует тело процедуры, заключаемое в begin и end. Таким образом, исходный код процедуры может выглядеть примерно таким образом:

procedure TriplePrint(str: string); var i: integer; begin for i := 1 to 3 do begin writeln(‘»‘+str+'»‘); end; // конец цикла for end; // конец процедуры TriplePrint

Здесь мы определили процедуру TriplePrint, которая будет трижды выводить переданную ей в качестве аргумента строку, заключенную в двойные кавычки. Как видно, данная процедура имеет все составные части: ключевое слово procedure, имя, список параметров (в данном случае он всего один — строковая переменная str), блок объявления собственных переменных (целочисленная переменная i), и собственное тело, состоящее из оператора цикла for.

Для использования данной процедуры в любом месте программы достаточно написать инструкцию вызова процедуры, состоящую из имени процедуры и списка аргументов, например:

Отметим так же, что рассмотренная нами процедура сама содержит вызов другой процедуры — writeln. Процедуры могут быть встроенными. Иначе говоря, объявление одной процедуры можно помещать в заголовочную часть другой. Например, наша процедура TriplePrint может иметь вспомогательную процедуру, которая будет «подготавливать» строку к выводу. Для этого перед объявлением переменной i, разместим объявление еще одной процедуры. Назовем ее PrepareStr:

procedure PrepareStr; begin str := ‘»‘+str+'»‘; end;

Отметим, что переменная str, хотя и не передается этой процедуре в качестве параметра, тем не менее может в ней использоваться, поскольку данная процедура является составной частью процедуры TriplePrint, внутри которой данная переменная доступна для использования.

Таким образом, мы получаем две процедуры, одна из которых (TriplePrint) может использоваться во всей программе, а другая (PrepareStr) — только внутри процедуры TriplePrint. Чтобы преимущество использования процедур было очевидно, рассмотрим их на примере программы, которая будет использовать ее неоднократно, для чего обратимся к листингу 6.1 (см. так же пример в Demo\Part1\Procs).

Листинг 6.1. Использование процедур

program procs; <$APPTYPE CONSOLE>procedure TriplePrint(str: string); procedure PrepareStr; begin str := ‘»‘+str+'»‘; end; var i: integer; begin PrepareStr; for i := 1 to 3 do begin writeln(str); end; end; // конец процедуры TriplePrint begin // начало тела основной программы TriplePrint(‘Hello. ‘); // первый вызов TriplePrint TriplePrint(‘How are you. ‘); // 2-й вызов TriplePrint(‘Bye. ‘); // 3-й readln; end.

Очевидно, что если бы не процедура, то нам трижды пришлось бы писать цикл, свой для каждого слова. Таким образом, процедуры позволяют использовать единожды написанный код многократно, что существенно облегчает написание программ.

Функции

Подобно процедурам, описание функции состоит из заголовка и тела. Однако описание заголовка имеет 2 отличия: прежде всего, для функций используется ключевое слово function. Кроме того, поскольку функции всегда возвращают результат, завершается строка заголовка типом возвращаемого значения. Таким образом, для объявления функции мы получаем следующий синтаксис:

Возвращаемое значение может быть любого типа, кроме файлового. Что касается дальнейшего описания функции, то оно полностью аналогично таковому для процедур. Единственным дополнением является то, что в теле функции обязательно должна присутствовать хотя бы одна операция присваивания, в левой части которой должно быть либо имя функции, либо ключевое слово result. Именно это выражение и определяет возвращаемое функцией значение.

Рассмотрим пример функции, которая будет возвращать куб числа, переданного ей в качестве аргумента:

function cube(value: integer) : integer; result := value * value * value; >

Здесь определена функция, имеющая параметр value типа целого числа, которое она возводит в третью степень путем троекратного умножения, и результат присваивается специальной переменной result. Таким образом, чтобы в любом месте программы вычислить значение числа в 3-й степени, достаточно написать такое выражение:

В результате выполнения этого выражения переменной x будет присвоено значение 27. Данный пример иллюстрирует использование функций в классическом случае — для явного вычисления значения переменной. Однако функции могут использоваться в выражениях и напрямую. Например, можно поставить вызов функции cube в каком-либо месте арифметического выражения подобно обычной переменной:

Подобно процедурам, функции так же могут быть встроенными. Кроме того, функции могут включать в себя не только локальные функции, но и процедуры. Впрочем, верно и обратное — в процедурах могут использоваться локальные функции. Например, в той же процедуре TriplePrint можно было бы использовать не процедуру, а функцию PrepareStr, которая принимала бы строку и возвращала ее же в кавычках:

procedure TriplePrint(str: string); function PrepareStr(s: string) : string; begin result := ‘»‘+s+'»‘; end; var i: integer; begin for i := 1 to 3 do begin writeln(PrepareStr(str)); // функция использована как переменная end; end;

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

function cube(value: integer) : integer; cube := value * value * value; >

В данном случае оба варианта будут вести себя полностью аналогично. Различия проявляются лишь в том случае, если использовать такую переменную в выражениях в теле функции. В подобных случаях следует использовать именно переменную result, а не имя функции, поскольку использ0овании имени функции в выражении внутри самой функции приведет к ее рекурсивному вызову.

Рекурсия

Таким образом мы подошли к теме рекурсии — вызову подпрограммы из самой себя. Это не является ошибкой, более того, целый ряд алгоритмов решить без рекурсии вообще было бы затруднительно.

Рассмотрим вопрос рекурсии на следующем примере:

function recfunc(x: integer) : integer begin dec(x); // функция декремента, уменьшает целое на 1 if x > 5 then x := recfunc(x); result := 0; // возвращаемое значение тут не используется end;

Здесь мы объявили функцию recfunc, принимающую один аргумент, и вызывающую саму себя до тех пор, пока значение этого аргумента больше 5. Хотя на первый взгляд может показаться, что такое поведение функции похоже на обычный цикл, на самом деле все работает несколько по-иному: если вы вызовите ее со значением 8, то она выдаст вам 3 сообщения в следующей последовательности: 5, 6, 7. Иначе говоря, функция вызывала саму себя до тех пор, пока значение x было больше 5, и собственно вывод сообщений начала 3-я по уровню получившейся вложенности функция, которая и вывела первое сообщение (в данном случае им стало 5, т.е. уменьшенное на единицу 6).

Чтобы представить себе более наглядно, как работает рекурсивный вызов, дополним эту функцию выводом комментариев, а так же счетчиком глубины рекурсии. Для этого мы, во-первых, задействуем возвращаемое функцией значение, а во-вторых, добавим еще один параметр, который и будет счетчиком. Результат проделанной работы приведен в листинге 6.2.

Листинг 6.2. Рекурсия с комментариями

program recurse; <$APPTYPE CONSOLE>function recfunc(x, depth: integer) : integer; begin dec(x); if x > 5 then begin write(‘Current recursion depth is: ‘); write(depth); write(‘, current x value is: ‘); writeln(x); inc(depth); depth:=recfunc(x, depth); end else writeln(‘End of recursive calls. ‘); write(‘Current recursion depth is: ‘); write(depth); write(‘, current x value is: ‘); writeln(x); dec(depth); result := depth; end; begin recfunc(8,0); readln; end.

Исходный код находится в Demo\Part1\Recurse, там же находится и исполняемый файл recurse.exe, результат работы которого вы можете увидеть на своем экране.

Использование параметров

Параметры в процедурах и функциях могут применяться не только по своему прямому предназначению — для передачи данных подпрограмме, но так же могут быть использованы для возвращения значений. Подобное их использование может быть вызвано, например, необходимостью получить более одного значения на выходе функции. Синтаксис объявления параметров в таком случае несколько отличается от стандартного — перед именем параметра следует использовать ключевое слово var:

procedure Circle (square: real; var radius, length: real);

Данная процедура принимает «на обработку» одно значение — площадь (square), а возвращает через свои параметры два — радиус (radius) и длину окружности (length). Практическая ее реализация может выглядеть таким образом:

procedure Circle (square: real; var radius, length: real); begin radius := sqrt(square / pi); // функция pi возвращает значение числа ? length := pi * radius * 2; end;

Теперь, чтобы воспользоваться этой функцией, следует объявить в программе 2 переменные, которые будут переданы в качестве аргументов этой процедуре и получат результаты. Их имена не важны, важно лишь, чтобы они были такого же, или совместимого типа, т.е. вещественные, например:

var r,l: real; . Circle(100,r,l);

После вызова функции Circle, переменные r и l получат значения радиуса и длины окружности. Остается их вывести при помощи writeln. Исходный код программы приведен в листинге 6.3.

Листинг 6.3. Процедура с параметрами

program params; <$APPTYPE CONSOLE>procedure Circle (square: real; var radius, length: real); begin //функция sqrt извлекает корень, а функция pi возвращает значение числа ? radius := sqrt(square / pi); length := pi * radius * 2; end; var r,l: real; begin Circle(100,r,l); writeln(r); writeln(l); readln; end.

Запустив такую программу, можно убедиться, что она работает и выводит верные результаты, однако вид у них получается довольно-таки неудобочитаемый, например, длина окружности будет представлена как «3,54490770181103E+0001». Чтобы сделать вывод более удобным для восприятия, нам понадобится функция FloatToStrF. С ее помощью мы можем определить вывод числа на свое усмотрение, например:

Кроме того, не помешало бы указать, где радиус, а где — длина окружности. Для этого модернизируем строки вывода результатов следующим образом:

writeln(‘Radius is: ‘+FloatToStrF(r,ffFixed,12,8)); writeln(‘Length is: ‘+FloatToStrF(l,ffFixed,12,8));

Наконец, не помешало бы сделать программу более полезной, для чего предусмотрим возможность ввода значения площади круга пользователем. В этих целях нам понадобится еще одна переменная (назовем ее s) и выражение для считывания ввода. Не помешает так же приглашение, объясняющее пользователю, что надо делать. В итоге основной блок программы получит следующий вид:

. var s,r,l: real; begin write(‘Input square: ‘); readln(s); Circle(s,r,l); writeln(‘Radius is: ‘+FloatToStrF(r,ffFixed,12,8)); writeln(‘Length is: ‘+FloatToStrF(l,ffFixed,12,8)); readln; end.

В принципе, это уже лучше, однако не помешало бы добавить обработку возможных ошибок ввода. Скажем, площадь должна быть больше 0. Проверку на то, является ли значение s больше нуля, можно производить непосредственно в основном коде программы, но в целях создания более универсального кода, вынесем ее в подпрограмму. Для этого первой инструкцией процедуры Circle должна быть проверка значения площади:

Таким образом, в случае, если введенное пользователем значение окажется нулевым или отрицательным, выполнение процедуры будет прекращено. Но возникает другой вопрос: как сообщить программе о том, что вычисления не были выполнены? Пожалуй, в данном случае следовало бы заменить процедуру функцией, которая возвращала бы истину, если вычисления произведены, и ложь в противном случае. Вот что у нас получится:

function Circle(square: real; var radius, length: real) : boolean; begin result := false; if (square

В начале функции мы определили возвращаемое значение как ложь. В результате, если параметр square не проходит проверку, то функция будет завершена и возвратит именно это значение. Если же проверка будет пройдена, то функция выполнится до конца, т.е. как раз до того момента, когда ее результатом станет истина.

Поскольку программа теперь может получить сведения о том, выполнились ли преобразования на основании возвращаемого функцией Circle булевского значения, остается добавить такую проверку в тело программы. В качестве условия для условного оператора в таком случае подойдет сама функция Circle (на самом деле, условием будет выступать не функция, а как раз возвращаемое ей значение):

if Circle(s,r,l) then begin // вывод end else // сообщить об ошибке

Результатом проделанной работы будет программа, приведенная в листинге 6.4. Она же находится в Demo\Part1\Params.

Листинг 6.4. Функция с параметрами

program params; <$APPTYPE CONSOLE>uses sysutils; //этот модуль соджержит функцию FloatToStrF function Circle(square: real; var radius, length: real) : boolean; begin result := false; if (square

Итак, при помощи ключевого слова var в списке параметров подпрограммы мы можем добиться использования передаваемых аргументов в том блоке, где был произведен вызов данной подпрограммы. В несколько другом аспекте используется ключевое слово const. Фактически, оно объявляет локальную константу, т.е. значение, которое нельзя изменять внутри данной процедуры или функции. Это бывает полезным в том случае, когда такое изменение недопустимо по логике программы и служит гарантией того, что такое значение не будет изменено.

При этом открывается еще одна возможность, связанная с константами, а именно — использование предопределенных значений. Например, можно определить функцию следующим образом:

function MyBetterFunc(val1: integer; const val2: integer = 2); begin result := val1*val2; end;

Обращение же к такой функции может иметь 2 варианта: с указанием только одного аргумента (для параметра val1), или же с указанием обоих:

x := MyBetterFunc(5); // получим 10 x := MyBetterFunc(5,4); // получим 20

Оба вызова будут верными, просто в первом случае для второго параметра будет использовано значение, заданное по умолчанию.

Области видимости

Еще одной важной деталью, касающейся использования подпрограмм, является видимость переменных. Само понятие видимости подразумевает под собой тот факт, что переменная, объявленная в одном месте программы может быть доступна, или наоборот, недоступна, в другом. Прежде всего, это касается подпрограмм: как мы уже успели отметить, переменные, объявленные в заголовке процедур или функций, только в данной процедуре (функции) и будут доступны — на то они и называются локальными:

program Project1; procedure Proc1; var a: integer; begin a := 5; //верно. Локальная переменная a здесь видна end; begin a := 10; //Ошибка! Объявленная в процедуре Proc1 переменнаая здесь не видна end.

В то же время переменные, объявленные в основном заголовке программы, доступны во всех входящих в нее подпрограммах. Потому они и называются глобальными. Единственное замечание по этому поводу состоит в том, что глобальная переменная должна быть объявлена до функции, т.е. выше ее по коду программы:

program Project2; var a: integer; // глобальная переменная a procedure Proc1; begin a := 5; // верно b := 10; // Ошибка! Переменая b на этот момент еще не объявлена end; var b: integer; // глобальная переменная b begin a := 10; // верно b := 5; // тоже верно. Здесь видны все г var a: integer; // глобальная переменная end.

Теперь рассмотрим такой вариант, когда у нас имеются 2 переменных с одним и тем же именем. Разумеется, компилятор еще на стадии проверки синтаксиса не допустит, чтобы в программе были объявлены одноименные переменные в рамках одного диапазона видимости (скажем, 2 глобальных переменных X, или 2 локальных переменных X в одной и той же подпрограмме). Речь в данном случае идет о том, что произойдет, если в одной и той же программе будет 2 переменных X, одна — глобальная, а другая — локальная (в какой-либо подпрограмме). Если с основным блоком программы все ясно — в нем будет присутствовать только глобальная X, то как быть с подпрограммой? В таком случае в действие вступает правило близости, т.е. какая переменная ближе (по структуре) к данному модулю, та и есть верная. Применительно к подпрограмме ближней оказывается локальная переменная X, и именно она будет задействована внутри подпрограммы.

program Project3; var X: integer; procedure Proc1; var X: integer; begin X := 5; // Здесь значение будет присвоено локальной переменной X end; begin X := 10; // Здесь же значение будет присвоено голобальной переменной X end.

Таким образом, мы внесли ясность в вопрос видимости переменных. Что касается видимости подпрограмм, то она определяется аналогичным образом: подпрограммы, объявленные в самой программе, видны всюду. Те же подпрограммы, которые объявлены внутри процедуры или функции, доступны только внутри нее:

program Project1; procedure Proc1; procedure SubProc; begin end; begin SubProc; // Верно. Вложенная процедура здесь видна. end; begin Proc1; // Верно. Процедура Proc1 объявлена в зоне глобальной видимости SubProc; // Ошибка! Процедура SubProc недоступна за пределами Proc1. end.

Наконец в том случае, когда имена встроенной и некой глобальной процедуры совпадают, то, по аналогии с переменными, в области видимости встроенной процедуры, именно она и будет выполнена.

Видимость в модулях

Все то, что мы уже рассмотрели, касалось программ, умещающихся в одном единственном файле. На практике же, особенно к тому моменту, когда мы перейдем к визуальному программированию, программы будут включать в себя множество файлов. В любом случае, программа на Object Pascal будет иметь уже изученный нами файл проекта — dpr, или основной модуль программы. Все прочие файлы будут располагаться в других файлах, или модулях (units), с типичным для Pascal расширением pas. При объединении модулей в единую программу возникает вопрос видимости переменных, а так же процедур и функций в различных модулях.

Для начала вернемся к рассмотрению структуры модуля, которая имеет ряд отличий от структуры программы. Итак, в простейшем случае, модуль состоит из названия, определяемого при помощи ключевого слова unit, и 2 секций — interface и implementation. Так вот как раз первая секция, interface, и служит для определения (декларации) типов данных, переменных, функций и процедур данного модуля, которые должны быть доступны за пределами данного модуля.

Чтобы лучше в этом разобраться, создадим программу, состоящую из 2 модулей — основного (dpr) и дополнительного (pas). Для этого сначала создайте новый проект типа Console Application, а затем добавьте к нему модуль, для чего из подменю File ‘ New выберите пункт Unit. После этого сохраните проект, щелкнув по кнопке Save All (или File ‘ Save All). Обратите внимание, что первым будет предложено сохранить не файл проекта, а как раз файл дополнительного модуля. Назовем его extunit.pas, а сам проект — miltiunits (см. Demo\Part1\Visibility). При этом вы увидите, что в части uses файла проекта произошло изменение: кроме постоянно добавляемого модуля SysUtils, появился еще один модуль — extunit, т.е. код стал таким:

uses SysUtils, extunit in ‘extunit.pas’;

Мы видим, что Delphi автоматически добавила пояснение, в каком файле находится подключаемый модуль. Это вызвано тем, что если о расположении собственных модулей Delphi все известно, то пользовательские модули могут находиться где угодно на жестком диске ПК. Но в данном случае мы сохранили и файл программы, и подключаемый модуль в одном каталоге, следовательно, их пути совпадают, и данное указание можно было бы опустить:

uses SysUtils, extunit;

Тем не менее, оставим код как есть, и приступим к разработке модуля extunit. В нем, в части implementation, напишем 2 процедуры — ExtProc1 и ExtProc2. Обе они будут делать одно и то же — выводить строку со своим названием. Например, для первой:

Теперь вернемся к главному модулю программы и попробуем обратиться к процедуре ExtProc1:

. begin ExtProc1; end.

Попытка компиляции или запуска такой программы приведет к ошибке компилятора «Undeclared identifier», что означает «неизвестный идентификатор». И действительно, одного лишь описания процедуры недостаточно, чтобы она была доступна вне своего модуля. Так что перейдем к редактированию extunit и в секции interface напишем строку:

Такая строка, помещенная в секцию interface, является объявлением процедуры ExtProc1, и делает ее видимой вне данного модуля. Отметим, что в секции interface допускается лишь объявлять процедуры, но не определять их (т.е. тело процедуры здесь будет неуместно). Еще одним полезным эффектом от объявления процедур является то, что таким образом можно обойти такое ограничение, как необходимость определения подпрограммы до ее вызова. Иначе говоря, поскольку в нашем файле уже есть 2 процедуры, ExtProc1и ExtProc2, причем они описаны именно в таком порядке — сначала ExtProc, а потом ExtProc2, то выведя объявление ExtProc2 в interface, мы сможем обращаться к ExtProc2 из ExtProc1, как это показано в листинге 6.5:

Листинг 6.5. Объявление процедур в модуле

unit extunit; interface procedure ExtProc1; procedure ExtProc2; implementation procedure ExtProc1; begin writeln(‘ExtProc1’); ExtProc2; // Если объявления не будет, то компилятор выдаст ошибку end; procedure ExtProc2; begin writeln(‘ExtProc2’); end; end.

Отметим, что теперь процедуры ExtProc2, так же, как и ExtProc1, будет видна не только по всему модулю extunit, но и во всех использующей этот модуль программе multiunits.

Разумеется, все, что было сказано о процедурах, верно и для функций. Кроме того, константы и переменные, объявленные в секции interface, так же будут видны как во всем теле модуля, так и вне него. Остается лишь рассмотреть вопрос пересечения имен, т.е. когда имя переменной (константы, процедуры, функции) в текущем модуле совпадает с таковым в подключенном модуле. В этом случае вновь вступает в силу правило «кто ближе, тот и прав», т.е. будет использоваться переменная из данного модуля. Например, если в extunit мы объявим типизированную константу Z, равную 100, а в multiunits — одноименную константу, равную 200, то обратившись к Z из модуля extunit, мы получим значение 100, а из multiunits — 200.

Если же нам в multiunits непременно понадобится именно та Z, которая находится в модуле extunit, то мы все-таки можем к ней обратиться, для чего нам пригодится точечная нотация. При этом в качестве имени объекта указывают название модуля:

Именно таким образом можно явно ссылаться на переменные, функции и процедуры, находящиеся в других модулях.

Некоторые стандартные функции

В Object Pascal, как уже отмечалось, имеются огромное количество стандартных процедур и функций, являющихся составной частью языка, и с некоторыми мы уже знакомы (например, приведенные в табл. 5.1 и 5.2 функции преобразования). Детальное описание всех имеющихся в Object Pascal процедур и функций можно получить в справочной системе Delphi, однако мы все-таки рассмотрим здесь некоторые из них, чтобы составить общее представление — см. таблицу 6.1.

Таблица 6.1. Некоторые стандартные процедуры и функции Delphi

Синтаксис Группа Модуль Описание
function Abs(X); арифметические System Возвращает абсолютное значение числа
procedure ChDir(const S: string); управления файлами System Изменяет текущий каталог
function Concat(s1 [, s2. sn]: string): string; строковые System Объединяет 2 и более строк в 1
function Copy(S; Index, Count: Integer): string; строковые System Возвращает часть строки
function Cos(X: Extended): Extended; тригонометрические System Вычисляет косинус угла
procedure Delete(var S: string; Index, Count: Integer); строковые System Удаляет часть строки
function Eof(var F): Boolean; ввод-вывод System Проверяет, достигнут ли конец файла
procedure Halt [ ( Exitcode: Integer) ]; управления System Инициирует досрочное прекращение программы
function High(X); диапазона System Возвращает максимальное значение из диапазона
procedure Insert(Source: string; var S: string; Index: Integer); строковые System Вставляет одну строку в другую
function Length(S): Integer; строковые System Возвращает длину строки или количество элементов массива
function Ln(X: Real): Real; арифметические System Возвращает натуральный логарифм числа (Ln(e) = 1)
function Low(X); диапазона System Возвращает минимальное значение из диапазона
procedure New(var P: Pointer); размещения памяти System Создает новую динамическую переменную и назначает указатель для нее
function ParamCount: Integer; командной строки System Возвращает количество параметров командной строки
function ParamStr(Index: Integer): string; командной строки System Возвращает указанный параметр из командной строки
function Pos(Substr: string; S: string): Integer; строковые System Ищет вхождение указанной подстроки в строку и возвращает порядковый номер первого совпавшего символа
procedure RmDir(const S: string); ввод-вывод System Удаляет указанный подкаталог (должен быть пустым)
function Slice(var A: array; Count: Integer): array; разные System Возвращает часть массива
function UpCase(Ch: Char): Char; символьные System Преобразует символ в верхний регистр
function LowerCase(const S: string): string; строковые SysUtils Преобразует ASCII-строку в нижний регистр
procedure Beep; разные SysUtils Инициирует системный сигнал
function CreateDir(const Dir: string): Boolean; управления файлами SysUtils Создает новый подкаталог
function CurrentYear: Word; даты и времени SysUtils Возвращает текущий год
function DeleteFile(const FileName: string): Boolean; управления файлами SysUtils Удаляет файл с диска
function ExtractFileExt(const FileName: string): string; имен файлов SysUtils Возвращает расширение файла
function FileExists(const FileName: string): Boolean; управления файлами SysUtils Проверяет файл на наличие
function IntToHex(Value: Integer; Digits: Integer): string; форматирования чисел SysUtils Возвращает целое в шестнадцатеричном представлении
function StrPCopy(Dest: PChar; const Source: string): PChar; строковые SysUtils Копирует Pascal-строку в C-строку (PChar)
function Trim(const S: string): string; строковые SysUtils Удаляет начальные и конечные пробелы в строке
function TryStrToInt(const S: string; out Value: Integer): Boolean; преобразования типов SysUtils Преобразует строку в целое
function ArcCos(const X: Extended): Extended; тригонометрические Math Вычисляет арккосинус угла
function Log2(const X: Extended): Extended; арифметические Math Возвращает логарифм по основанию 2
function Max(A,B: Integer): Integer; арифметические Math Возвращает большее из 2 чисел
function Min(A,B: Integer): Integer; арифметические Math Возвращает меньшее из 2 чисел

Те функции, которые имеются в модуле System, являются основными функциями языка, и для их использования не требуется подключать к программе какие-либо модули. Все остальные функции и процедуры можно назвать вспомогательными, и для их использования следует подключить тот или иной модуль, указав его в uses, например, как это делает Delphi уже при создании новой программы с SysUtils:

Что касается практического применения той или иной функции, то оно определяется, прежде всего, той группой, к которой данная функция относится. Например, арифметические функции используются для различных математических расчетов, строковые используются для манипуляций со строками и т.д. Разумеется, в каждой категории имеется множество других функций, помимо тех, что приведены в таблице 6.1, однако по ней можно получить общее представление о том, что есть в распоряжении Delphi-программиста.

Функции в действии

В целом мы уже ознакомились с несколькими десятками предопределенных процедур и функций, а так же умеем создавать собственные. Пора применить полученные знания на практике, для чего вновь вернемся к программе, рассмотренной в главе, посвященной операторам — игре «Угадай-ка». В ней, по сути, был реализован только один из рассмотренных в самом начале книги алгоритмов — угадывания числа. Что касается алгоритма управления, то на тот момент мы оставили его без внимания.

Но прежде, чем вносить в программу изменения, определимся с тем, что мы все-таки хотим получить в итоге. Допустим, что мы хотим сделать следующие вещи:

  1. Реализовать-таки возможность повторного прохождения игры без перезапуска программы;
  2. Добавить немного «геймплея». Иначе говоря, введем уровни сложности и подсчет очков. Новые уровни можно реализовать как повторное прохождение игры с увеличением сложности (скажем, за счет расширения диапазона загадываемых значений);
  3. В продолжение п. 2 добавить еще и таблицу рекордов, которая будет сохраняться на диске.

Поскольку часть работы уже выполнена, то для того, чтобы приступить к разработке новой версии игры (назовем ее «Угадай-ка 2.0»), мы не будем как обычно создавать новый консольный проект в Delphi, а откроем уже существующий (Ugadaika) и сохраним его под новым именем, скажем, Ugadaika2, и в новом каталоге. Таким образом, мы уже имеем часть исходного кода, отвечающую за угадывание, в частности, цикл while (см. листинг 4.5). Этот фрагмент логичнее всего выделить в отдельную процедуру, вернее даже функцию, которая будет возвращать число попыток, сделанное пользователем. Для этого создадим функцию, которая будет принимать в качестве аргумента число, которое следует угадать, а возвращаемым значением будет целое, соответствующее числу попыток. Ее объявление будет таким:

function GetAttempts(a: integer):integer;

Данная функция так же должна иметь в своем распоряжении переменную, необходимую для ввода пользователем своего варианта ответа. Еще одна переменная нужна для подсчета результата, т.е. количества попыток. В качестве первой можно было бы использовать глобальную переменную (b), однако во избежание накладок, для локального использования в функции следует использовать локальную же переменную. Что касается переменной-счетчика, то для нее как нельзя лучше подходит автоматическая переменная result. Еще одним изменением будет использование цикла repeat вместо while. Это вызвано тем, что с одной стороны, тем, что хотя бы 1 раз пользователь должен ввести число, т.е. условие можно проверять в конце цикла, а с другой мы можем избавиться от присвоения лишнего действия, а именно — присвоения заведомо ложного значения переменной b. Ну и еще одно дополнение — это второе условие выхода, а именно — ограничение на число попыток, которое мы установим при помощи константы MAXATTEMPTS:

const MAXATTEMPTS = 10;

В результате код функции получится таким, как представлено в листинге 6.6.

Листинг 6.6. Функция GetAttempts

function GetAttempts(a: integer):integer; var b: integer; begin Result:=0; repeat inc(Result); // увеличиваем счетчик числа попыток write(#13+#10+’?:’); read(b); if (b>a) then begin write(‘Too much!’); continue; end; if (b

Теперь, когда подготовительная работа сделана, можно браться за реализацию намеченных изменений. Прежде всего, в теле программы нам потребуется цикл, который как раз и будет обеспечивать логику исполнения программы. Для него нам так же понадобятся переменные. В частности, нужны счетчик цикла, устанавливающий текущий уровень сложности, так же нужны переменные для хранения набранных очков и числа попыток, и, кроме того, не помешает заранее определить файловую переменную для таблицы рекордов и строковую — для ввода имени «рекордсмена». Итого мы получаем следующий список переменных перед основным блоком программы:

var level, score, attempt: integer; f: TextFile; s: string;

Теперь инициализируем счетчик псевдослучайных чисел (т.е. оставим randomize на месте) и инициализируем нулем значения счета и уровня:

Наконец, напишем цикл для основного блока программы. Этот цикл должен быть выполнен хотя бы один раз и будет продолжать выполняться до тех пор, пока число попыток в последнем уровне было меньше максимально допустимого. В результате получаем цикл repeat со следующим условием:

В самом цикле нам потребуется, прежде всего, выводить информацию о текущем уровне, а так же о диапазоне отгадываемых чисел. После этого надо будет получить число попыток при помощи функции GetAttempts, вычислить набранные очки и сообщить о них пользователю, после чего увеличить счетчик цикла на 1 и перейти к следующей его итерации. В результате мы получим следующий фрагмент кода:

repeat writeln(‘Level ‘+IntToStr(level)+’:’); writeln(‘From 0 to ‘+IntToStr(level*100)); attempt:=GetAttempts(random(level*100+1)); score:=score+(MAXATTEMPTS-attempt)*level; writeln(#10+’You current score is: ‘+IntToStr(score)); inc(level); until attempt>MAXATTEMPTS;

После завершения работы цикла, т.е. когда пользователь хоть раз истратит на отгадывание все 10 попыток, следует сообщить итоговый результат и сравнит его с предыдущим значением, которое следует считать из файла. Файл мы назовем records.txt, и сопоставим с переменной f:

Но прежде, чем попытаться что-либо прочитать из этого файла, необходимо убедиться, что такой файл уже есть, а если нет — то создать его, записав в него некий минимальный результат.

if not FileExists(‘record.txt’) then begin Rewrite(f); writeln(f,’0′); // первая строка содержит число-рекорд writeln(f,’None’); // а вторая — имя последнего победителя CloseFile(f); end;

Теперь можно считать этот файл. Правда, мы упустили из виду, что нам здесь тоже нужна переменная — для считывания предыдущего рекорда. В то же время, на данный момент мы уже имеем 2 ненужных для дальнейшей работы программы переменных — attempt и level, так что вполне можно воспользоваться любой из них для этих целей. Таким образом, мы получим следующий код:

Reset(f); readln(f, attempt); readln(f,s); writeln(#10+’BEST SCORE: ‘+IntToStr(attempt)+’ by ‘+s); CloseFile(f);

Ну и последнее, чего нам остается — это проверить, является ли новое значение выше рекорда, и если да — то записать новый рекорд в файл, не забыв спросить имя игрока:

Вот, собственно, и все. Полный код получившейся программы можно увидеть на листинге 6.7, или же в файле проекта в каталоге Demo\Part1\Ugadaika2.

Листинг 6.7. Программа угадай-ка, окончательный вариант

В завершение отметим, что эта программа использует использование не только функций, но и констант, глобальных и локальных переменных, а так же циклов и операций файлового ввода-вывода. Таким образом, на текущий момент мы познакомились со всеми основами обычного, процедурного программирования. Пора двигаться дальше — к объектно-ориентированному программированию в Object Pascal!

Использование замыканий и функций высших порядков в Delphi

Данная статья является продолжением предыдущей публикации, которая была посвящена анонимным методам. В этот раз речь пойдет о примерах использования функций высших порядков и замыканий, показавшихся автору интересными.

Delphi не является языком функционального программирования, но тот факт, что программы на нем могут манипулировать функциями как объектами означает, что в Delphi можно использовать приемы функциональной парадигмы. Цель статьи — не подтолкнуть к использованию этого стиля, но обозначить некоторые примеры и возможности.

Конструирование функций

Функции высшего порядка (ФВП) – это функции, которые оперируют функциями, принимая одну или более функций и возвращая новую функцию.
Следующий пример показывает, как с помощью ФВП можно конструировать другие функции.

Функция Negate в примере выше, является ФВП, потому что она принимает функцию IsOdd в виде аргумента и возвращает новую функцию IsEven, которая передает свои аргументы Negate и возвращает логическое отрицание значения, возвращаемого функцией IsOdd.

Так как использование обобщенных типов не способствует ясности изложения, в последующих примерах будем по возможности их избегать.

Композиция функций

Ниже приводится пример еще одной, более универсальной функции, которая принимает две функции, F и G, и возвращает новую функцию, которая возвращает результат F(G()).

Здесь функция Compose вычисляет F(G(X, Y)). Возвращаемая функция передает все свои аргументы функции G, затем передает значение, полученное от G, функции F и возвращает результат вызова F.

Частичное применение

Этот термин описывает преобразование функции с несколькими аргументами в функцию, которая принимает меньшее количество аргументов, при этом значения для опущенных аргументов задаются заранее. Этот прием вполне адекватен своему названию: он «частично применяет» некоторые аргументы функции, возвращая функцию, принимающую остающиеся аргументы.
Функция BindLeft в примере ниже берет функцию Calc, принимающую n аргументов, связывает первые k из них с наперед заданными значениями и возвращает функцию Partial, которая может принять (n-k) аргументов (первые k аргументов будут уже применены к ней).

Здесь интересен момент, когда после вызова BindLeft локальная переменная StoredArgs не прекращает свое существование и используется далее, сохраняя в себе значения аргументов, которые потом используются при вызове Partial и передаются в Calc. Этот эффект называется замыканием. При этом каждый вызов BindLeft будет порождать новые «экземпляры» StoredArgs. Замыкания использовались и в предыдущих примерах, когда в них сохранялись аргументы ФВП.
Определить частичное применение справа можно следующим образом:

Карринг

В то время как частичное применение преобразует функцию с n параметрами в функцию с n-k параметрами, применяя k аргументов, карринг декомпозирует функцию на функции от одного аргумента. Мы не передаем никаких дополнительных аргументов в метод Curry, кроме преобразуемой функции:

  • Curry(F) возвращает функцию F1, такую что.
  • F1(A) возвращает функцию F2, такую что.
  • F2(B) возвращает функцию F3, такую что.
  • F3(С) вызывает F(A, B, C)
Мемоизация

Мемоизованная функция — это функция, которая сохраняет ранее вычисленные результаты. Другими словами, для функции создаётся таблица результатов, и, будучи вычисленным при определённых значениях параметров, результат заносится в эту таблицу. В дальнейшем результат берётся из данной таблицы. Эта техника позволяет за счёт использования дополнительной памяти ускорить работу программы. Разумеется, мемоизируемая функция должна работать без побочных эффектов и ей желательно иметь дискретную область определения.
В следующем примере демонстрируется функция Memoize высшего порядка, которая принимает функцию в виде аргумента и возвращает ее мемоизованную версию.

Функция Memoize создает объект TCache для использования в качестве кэша и присваивает его локальной переменной, благодаря чему он остается доступным (через замыкание) только для возвращаемой функции. Возвращаемая функция преобразует свой аргумент в ключ. Если значение присутствует в кэше, оно просто возвращается в качестве результата. В противном случае вызывается оригинальная функция, вычисляющая значение для заданного аргумента; полученное значение помещается в кэш и возвращается.

Программа с мемоизованной функцией, периодически вызываемой с одинаковыми аргументами, должна выполняться быстрее, чем аналогичная программа без применения мемоизации. Проверим разницу:

Генераторы

Здесь под генератором понимается ФВП, которая возвращает функцию, вызов которой приводит к получению следующего члена некоторой последовательности. В примере ниже создаются два генератора: для последовательности Фибоначчи и генератор факториалов. Предыдущие элементы генераторов запоминаются в замыкании.

Польза генераторов заключается в том, что для вычисления каждого следующего элемента не требуется вычислять всю последовательность с самого начала. Генераторы позволяют работать даже с бесконечными последовательностями, но они обеспечивают только последовательный доступ к своим элементам и не позволяют обращаться к своим элементам по индексу: чтобы получить n-e значение придется выполнить n-1 итераций.

Отложенные вычисления

Генераторы бывает удобно использовать для последовательной обработки данных — элементов списка, строк текста, лексем в лексическом анализаторе и т.д. Генераторы можно объединять в цепочки, подобно конвейеру команд в Unix. Самое интересное в этом подходе заключается в том, что он следует принципу отложенных вычислений: значения «извлекаются» из генератора (или из конвейера) по мере необходимости, а не все сразу. Эту особенность демонстрирует следующий пример, в котором исходный текст фильтруется, построчно проходя через цепочку генераторов.

Tomorrow — Функция Delphi

Подпрограммы — процедуры и функции в языке Delphi служат для выполнения специализированных операций. Delphi имеет множество стандартных подпрограмм, но всё равно приходится создавать собственные для выполнения часто повторяющихся операций с данными, которые могут меняться.

Вообще, существует методика программирования «сверху вниз». Методика программирования «сверху вниз» разбивает задачу на несколько более простых, которые оформляются в виде подпрограмм. Те, в свою очередь, при необходимости также делятся до тех пор, пока стоящие перед программистом проблемы не достигнут приемлемого уровня сложности (то есть простоты!). Таким образом, эта методика программирования облегчает написание программ за счёт создания так называемого скелета, состоящего из описателей подпрограмм, которые в дальнейшем наполняются конкретными алгоритмами. Пустое описание подпрограммы иначе называется «заглушкой».

И процедуры, и функции позволяют добиться одинаковых результатов. Но разница всё же есть.

Процедура Delphi просто выполняет требуемые операции, но никаких результатов своих действий не возвращает. Результат — в тех изменениях, которые произошли в программе в процессе выполнения этой процедуры. В частности, процедура может поменять значения переменных, записать новые значения в ячейки компонентов, сделать запись в файл и т.д.

Функция Delphi также позволяет выполнить всё перечисленное, но дополнительно возвращает результат в присвоенном ей самой значении. То есть вызов функции может присутствовать в выражении справа от оператора присваивания. Таким образом, функция — более универсальный объект!

Описание подпрограммы состоит из ключевого слова procedure или function, за которым следует имя подпрограммы со списком параметров, заключённых в скобки. В случае функции далее ставится двоеточие и указывается тип возвращаемого значения. Обычная точка с запятой далее — обязательна! Сам код подпрограммы заключается в «логические скобки» begin/end. Для функции необходимо в коде присвоить переменной с именем функции или специальной зарезервированной переменной Result (предпочтительно) возвращаемое функцией значение. Примеры:

function Имя_функции(параметры): тип_результата;
begin
Код функции;
Result:= результат;
end;

procedure Имя_процедуры(параметры);
begin
Код процедуры;
end;

Описанная таким образом подпрограмма должна быть размещена в основной программе до первого её вызова. Иначе при компиляции получите извещение о том, что «неизвестный идентификатор. » Следить за этим не всегда удобно. Есть выход — разместить только заголовок подпрограммы там, где размещают .

Параметры — это список идентификаторов, разделённых запятой, за которым через двоеточие указывается тип. Если списков идентификаторов разных типов несколько, то они разделяются точкой с запятой. Всё, как и в случае обычного описания данных. Это так называемые формальные параметры. При вызове подпрограммы они заменяются на фактические — следующие через запятую данные того же типа, что и формальные.
Параметры в описании подпрограммы могут и отсутствовать, тогда она оперирует данными прямо из основной программы.

Теперь нужно ввести понятие локальных данных. Это данные — переменные, константы, подпрограммы, которые используются и существуют только в момент вызова данной подпрограммы. Они так же должны быть описаны в этой подпрограмме. Место их описания — между заголовком и началом логического блока — ключевым словом begin. Имена локальных данных могут совпадать с именами глобальных. В этом случае используется локальная переменная, причём её изменение не скажется на глобальной с тем же именем.
Совершенно аналогично локальным типам, переменным, константам могут быть введены и локальные процедуры и функции, которые могут быть описаны и использованы только внутри данной подпрограммы.

Теперь пример. Напишем программу суммирования двух чисел. Она будет состоять из Формы, на которой будет кнопка (компонент Button), по нажатию на которую будет выполняться наша подпрограмма, и двух строк ввода (компоненты Edit), куда будем вводить операнды. Начнём с процедуры.

var
Form1: TForm1;
A, B, Summa: Integer;
procedure Sum(A, B: Integer);

procedure TForm1.Button1Click(Sender: TObject);
begin
A:=StrToInt(Edit1.Text);
B:=StrToInt(Edit2.Text);
Sum(A, B);
Caption:=IntToStr(Summa);
end;

procedure Sum(A, B: Integer);
begin
Summa:=A+B;
end;

Наша процедура находится после обработчика нажатия кнопки, где осуществляется её вызов. И программа работает именно потому, что заголовок процедуры вынесен в блок описания данных. Но всё же операция суммирования в данном случае производится как-то невнятно.
Теперь сделаем то же самое с помощью функции.

var
Form1: TForm1;
A, B, Summa: Integer;
function Sum(A, B: Integer): Integer;

procedure TForm1.Button1Click(Sender: TObject);
begin
A:=StrToInt(Edit1.Text);
B:=StrToInt(Edit2.Text);
Summa:=Sum(A, B); // На мой взгляд, сейчас более понятно, откуда что берётся
Caption:=IntToStr(Summa);
end;

function Sum(A, B: Integer): Integer;
begin
Result:=A+B;
end;

Есть особенности в использовании в качестве параметров больших по объёму структур данных, например, массивов, состоящих из нескольких тысяч (и больше) элементов. При передаче в подпрограмму данных большого объёма могут быть большие расходы ресурсов и времени системы. Поэтому используется передача не самих значений элементов (передача «по значению», как в предыдущих примерах), а ссылки на имя переменной или константы (передача «по имени»). Достигается это вставкой перед теми параметрами, которые мы хотим передать по имени, ключевого слова var.

function Sum(A, B: Integer; var Arr: array[1..1000000] of Integer): Integer;

Если взглянуть на описание нашей подпрограммы и описание обработчика нажатия кнопки (это тоже подпрограмма!), который был создан Delphi, то видим, что перед именем обработчика (Button1Click) стоит TForm1. Как мы знаем, в Delphi точкой разделяется объект и его атрибуты (свойства и методы). Таким образом, Delphi создаёт Button1Click как метод объекта Form1. Причём, буква T перед объектом говорит о том, что Button1Click не просто метод объекта, а метод класса объекта. Не будем этим пока заморачиваться, а просто будем поступать также. Описав свою процедуру или функцию как метод класса TForm1, мы получаем возможность использовать в ней объекты класса без указания его имени, что гораздо удобнее. То есть, если мы используем в нашей подпрограмме какие-либо компоненты, размещённые на Форме (например, Button1), то мы пишем

Button1.W >
а не
Form1.Button1.W >

Также появляется возможность использовать встроенные переменные, такие как параметр Sender. В каждом обработчике этот объект указывает на источник, то есть тот объект, который вызывает данную подпрограмму. Например, в нашей процедуре суммирования Sender = Button1. Проанализировав эту переменную, можно принять решение о тех или иных действиях.

Описав подпрограмму как метод класса, её описание мы должны поместить туда же, куда их помещает описание класса TForm1. Смотрите сами, где находится описание процедуры Button1Click. Для этого, поставив курсор внутрь подпрограммы Button1Click, нажмите CTRL+Shift и кнопку управления курсором «Вверх» или «Вниз» одновременно. Произойдёт переход к описанию подпрограммы (чтобы вернуться обратно, повторите это действие ещё раз). Ставьте описание своей подпрограммы рядом, с новой строки. Обратите внимание, что TForm1 уже не пишется.

Рекурсия — важное и мощное свойство процедур и функций в Delphi. Рекурсия это возможность подпрограммы в процессе работы обращаться к самой себе. Без использования рекурсии приходилось бы применять циклы, а это усложняет чтение программы. Рекурсивный вызов подпрограммы сразу проясняет смысл происходящего. Естественно, приходится следить за тем, чтобы в подпрограмме обязательно было условие, при выполнении которого дальнейшая рекурсия прекращается, иначе подпрограмма зациклится.

Пример. Вычисление факториала

Вычисление факториала — классическая в программировании задача на использование рекурсии. Факториал числа N — результат перемножения всех чисел от 1 до N (обозначается N!):

Создавая программу вычисления факториала числа, мы можем применить и функции, и рекурсию. Можно скачать проект данной программы.

Удобство применения рекурсии особенно наглядно при вычислении дискриминанта матрицы. Дискриминант матрицы можно подсчитать методом Гаусса — приведением матрицы к треугольному виду, что требует использования нескольких вложенных циклов. Алгоритм получается достаточно громоздкий. Используя вместо этого рекурсию, получается очень элегантный алгоритм: вычисление дискриминанта матрицы с использованием рекурсии.

Tomorrow — Функция Delphi

Продолжаем обучение Delphi и в этом уроке мы познакомимся с функциями. Представьте, что вы написали очень большую программу в которой более 2000 строк и у вас десятки раз повторяется один и тот же участок кода. Функция позволяет избегать такие повторения. То есть мы выносим повторяющийся код в функцию, а на месте тех десятков кода просто вызываем нашу функцию.

Синтаксис функции: Рассмотрим подробнее на примере программы. Запускаем Delphi, создаем проект и кидаем кнопку и лабел на форму. Далее в редакторе кода находим слово Private.

После слова Private объявляем функцию: Сейчас нажимаем комбинацию клавиш Ctrl+Shift+C и Delphi автоматически создает загатовку: И между ключевыми словами begin и end пишем то, что будет делать наша функция, а функция будет делать простейшее — сложение переменных a и b, которые мы уже записали, когда объявляли функцию.

Тело функции: Если сейчас запустить программу, то ничего не произойдет, так как функция у нас нигде не вызывается, да и значение переменным a и b мы не указали.

Создаем событие OnClick на кнопке и пишем: Разберем строчку, где происходит суммирование. Пишем имя функции, потом в скобках значения для переменных a и b и результат присваиваем переменной i, которую потом выводим в лабел.

Конечно я привел самый простой и понятный пример. В функцию можно записать громадную формулу, по которой вы будете вычислять конец света и что бы потом не переписывать эту формулу можно просто указывать имя функции и вводить значения переменным.

Ну вот и всё! Удачи!
Встретимся в следующем уроке!

Источник: www.thedelphi.ru
Автор: Савельев Александр
Опубликовано: 13 Июля 2012
Просмотров: 37653

Зарегистрируйтесь или авторизуйтесь, чтобы добавлять комментарии.

Илон Маск рекомендует:  Asp кэшируйте часто используемые данные в объектах application или session
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL