» Найти все предыдущие уроки можно на www.delphi.int.ru в разделе "Статьи".
Последние 3 урока:

9. Pascal - базовые конструкции и переменные
10. Логические выражения
11. События

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

Сегодня мы поговорим о процедурах и функциях. Что такое процедура? Это маленькая программа, выполняющая операции с указанными данными. Различают собственно процедуры и функции. Их основное отличие - процедура просто совершает какие-либо операции, а функция обязательно выдаёт какой-либо результат в результате своей работы. Существует огромное количество стандартных процедур и функций. Подпрограммы (так называют процедуры и функции) можно писать и самостоятельно, но об этом речь пойдёт позже. Сейчас нам нужно научиться работать с готовыми функциями.

Общие сведения о подпрограммах

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

Вызов подпрограмм

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

Обратите внимание: работа с функциями происходит как с обычными переменными, просто их значения вычисляются "на лету".

Функции математических вычислений

Эти функции работают с числовыми данными. Как правило, входным параметром является какое-то число, а выходным - результат вычисления. Практически везде аргумент является либо целым числом (Integer), либо вещественным (Real). Возвращаемое значение - тоже число. Рассмотрим некоторые из этих функций:

Abs(x) - модуль (абсолютное значение) указанного числа x. Пример: Abs(-5) = 5.

Sin(x) - синус числа x. Здесь x - угол в радианах (не в градусах!). Пример: Sin(Pi/2) = 1.

Cos(x) - косинус числа x. Аналогично, x - радианы. Пример: Cos(Pi) = -1.

Exp(x) - экспонента, e^x (e в степени x).

Ln(x) - натуральный логарифм числа x. Пример: Ln(Exp(2)) = 2.

Sqr(x) - квадрат числа x (x²). Пример: Sqr(5) = 25.

Sqrt(x) - квадратный корень числа x. Пример: Sqrt(64) = 8.

Int(x) - целая часть числа x. Пример: Int(1.234) = 1.

Frac(x) - дробная часть числа x. Пример: Frac(1.234) = 0.234.

Round(x) - округление аргумента до ближайшего целого числа. Пример: Round(1.234) = 1.

Trunc(x) - целая часть вещественного числа x. Пример: Trunc(1.234) = 1.

Pred(x) - предыдущее значение x (например, для x = 2 это 1).

Succ(x) - следующее значение x (для x = 2 это 3).

Odd(x) - проверка аргумента на нечётность. Функция возвращает значение True, если аргумент является нечётным числом и False - если чётным. Пример: Odd(5) = True.

Предсказываю вопрос: в чём отличие Int() от Trunc()? А отличие в том, что Int() возвращает число вещественного типа, а Trunc() - целочисленного.

Это лишь часть всех доступных функций. На самом деле их гораздо больше. Но помимо функций есть ещё процедуры.

Процедуры работы с числами

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

Inc(x) - увеличение аргумента на единицу. Фактически, это то же самое, что x:=x+1. Тем не менее, рекомендуется использовать именно эту функцию, так как работает она быстрее.
Примечание: под понятием "быстрее" подразумевается, конечно, быстрота "компьютерная". Компьютер выполняет миллионы операций в секунду и для человека такие вещи незаметны.

Inc(x,n) - увеличение аргумента на число n. Эквивалентно записи x:=x+n.

На самом деле, это не две разные процедуры - просто параметр n является необязательным. Да, бывают необязательные параметры, которые можно указать, а можно и не указывать. Если они отсутствуют, то просто берётся какое-то значение по умолчанию. В данном случае n по умолчанию имеет значение 1.

Dec(x,n) - уменьшение аргумента на n единиц. Точно также, как и в Inc, параметр n является необязательным. Эквивалентно записи x:=x-n.

В документации необязательные параметры обычно заключают в квадратные скобки, т.е. обычно пишут Inc(x , [n]). Обратите внимание: это лишь условное обозначение, которое создано с целью узнавания, что параметр необязательный. В программном коде никаких скобок нет и быть не может.

Не хватает стандартных математических функций?

Существует дополнительный модуль с именем Math, в котором содержится большое число математических функций. Например, если нужно посчитать гиперболический арксеканс числа, то мучаться и описывать способ его вычисления вручную не придётся - есть готовая функция ArcSecH().
Чтобы подключить модуль Math, откройте исходный код модуля. Для этого, когда открыта форма, следует нажать F12, либо выбрать пункт меню View » Toggle Form/Unit. Далее нужно переместиться в самое начала модуля в раздел uses. В этом разделе через запятую описываются имена подключённых модулей. Как можно заметить, даже при наличии пустой формы несколько модулей уже подключены. В этот список и следует добавить Math:

Всё, теперь в Вашем распоряжении большое количество математических функций.

Пример комбинирования функций

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

Нам нужно создать программу, которая бы вычисляла значение этой функции по заданным числам x и y. Рассмотрим поэтапно элементы функции:
1) Возведение числа e в степень, модуль - функции Exp() и Abs() соответственно.
2) Натуральный логарифм - функция Ln().
3) Число e... Часто спрашивают - как получить число e? Ведь это, по сути, такая же константа, как и число пи... Но она не объявлена... А ответ прост: e = e¹, поэтому e - это exp(1).
4) Тангенс - функция Tan().
Всё необходимое у нас есть, поэтому можно приступить к записи. Главное - не забывать заключать в скобки отдельные элементы формулы, чтобы порядок действий сохранился (в нашем примере это не потребуется).

var f,x,y: Real;

f:=Exp(Abs(x-y))+Ln(1+Exp(1))*Tan(Pi-7);

Как возвести число в степень?

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

Способ 1. X^y можно преобразовать к виду e^ln(x)⋅y. Тогда возведение в степень можно записать так:

:= Exp( y * Ln(x) );

Способ 2. В модуле Math есть функция для возведения в степень - Power. У функции 2 аргумента - основание и показатель степени. Запись, соответственно, следующая :=Power(x,y);

Случайные числа

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

В Pascal (и Delphi соответственно) случайные числа генерируются функцией Random. Функция принимает один параметр, да и тот необязательный... Этот параметр позволяет указать границу диапазона, из которого будет выбрано случайное число. Итак: Random([Range: Integer]). Если Range указан, то число выбирается из диапазона 0 <= X < Range (X - само случайное число, которое будет получено). Обратите внимание, что сама граница в диапазон не включается, т.е. Random(10) никогда не выдаст число 10, хотя 0 - запросто. Если диапазон не указан, то он считается равным единице, т.е. 0 <= X < 1.

Пример. Создадим форму с кнопкой, но пусть кнопка каждую секунду изменяет своё положение. Воспользуемся таймером (TTimer, вкладка System палитры компонент). Interval оставим без изменения (1 сек.), а вот в обработчике запрограммируем произвольное изменение положения кнопки на форме. Разберёмся, что нам нужно:
1) Позиция кнопки на форме. Как Вы уже знаете, за положение отвечают свойства Left и Top, которые указывают положение левого верхнего угла кнопки относительно левого верхнего угла формы. Именно этим свойствам мы будем присваивать произвольные значения.
2) Каков будет диапазон для генерации случайных чисел? Очевидно, что кнопка не должна уйти за границы формы... Значит нам нужно подключить размеры самой формы, т.е. её высоту и ширину. В данном случае будем использовать не Width и Height, а ClientWidth и ClientHeight, так как в первые свойства входят заголовок и границы формы, а это лишние пиксели, за которые кнопка может вылезти. Однако и это ещё не всё - из этих размеров мы должны вычесть соответственно ширину и высоту самой кнопки, иначе она может частично скрыться за границами.
Пишем обработчик:

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  Button1.Left:=Random(ClientWidth-Button1.Width);
  Button1.Top:=Random(ClientHeight-Button1.Height)
end;

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

Отчего это происходит? Дело в том, что числа, выдаваемые функцией Random() на самом деле не являются случайными - они псевдослучайны, т.е. наблюдается повторение. К счастью, решение есть - специальная процедура Randomize() инициализирует генератор случайных чисел, который выдаёт действительно случайные числа. Вызвать эту процедуру нужно всего один раз за время работы программы - обычно это делается при запуске (например, в событии OnCreate формы). Процедура не принимает никаких параметров. Вернёмся к нашему примеру:

procedure TForm1.FormCreate(Sender: TObject);
begin
  Randomize
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  Button1.Left:=Random(ClientWidth-Button1.Width);
  Button1.Top:=Random(ClientHeight-Button1.Height)
end;

Теперь кнопка будет прыгать совершенно по разным точкам при каждом запуске программы.

Кстати, можно дописать скобки к названию процедуры - от этого работа не изменится: Randomize; = Randomize(); А запись немного красивее (на мой взгляд).

Дополнительные возможности редактора кода

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

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

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

Если функции или процедуре входные параметры не нужны, подсказка всё равно появится и сообщит об этом:

Если после набора имени и скобки подсказка не появилась, то и при компиляции программы скорее всего возникнет ошибка. Причиной, по которой компилятор не смог найти указанную функцию или процедуру, может быть ошибка при наборе имени, либо модуль, в котором описана подпрограмма, не подключен.
Ошибки при компиляции появляются внизу окна редактора кода с указанием номера строки, где обнаружена ошибка и описанием самой ошибки.
Попробуем запросить процедуру Randomiz (например, мы случайно недописали букву "e" на конце):

Строка с ошибкой выделилась, а внизу появился её номер (28) и описание - Undeclared identifier (неописанный идентификатор).

Заключение

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

Delphi.int.ru Expert
(текущая версия системы: 2.0; последнее обновление: 18.07.2007)

Дальнейшая публикация вопросов и ответов начнётся со следующего выпуска.

Виртуальный ListView

Автор: Вадим К
Для связи: midav(a)land.ru

Содержание

• Введение
• Почему тормозит?
• Оптимизируем
• Виртуальный список
• Замечания
• Приложение

Введение

Часто на форумах слышен вопрос: «Как в TListView (или TListBox) добавить 1000 строк? Уже на 100-200 начинает подтормаживать!». Ответы обычно такие: «А кто будет просматривать тысячи строк? Ошибка дизайна». Приводятся абстрактные примеры, показывающие, за сколько времени человек сможет просмотреть этот список.

Но есть пример, перед которым все поднимают руки. Это Lingvo. Для тех, кто не в курсе – это электронный словарь и на основном окне у него список слов и TEdit для ввода слова. В этой статье вы узнаете, как сделать такое, и почему стандартный подход тормозит.

Почему тормозит?

Давайте для начала рассмотрим простой пример, который прольёт свет на это. Проанализируем следующий код:

function DupChar(c:char;count:integer):string;
  var i:integer;
begin
  Result:='';
  for i:=1 to count do
    Result:=result+c;
end;

Функция предельно проста – она получает на вход символ и количество повторений, а на выходе даёт строку с count символов c. Казалось, всё просто, но попробуйте протестировать эту функцию, когда количество символов достигает 1000-2000. Я сделал это на своём компьютере, смотрим график:

На этом графике видна линейная зависимость. Но при дальнейшем увеличении количества символов она превратится в экспоненциальную зависимость. Почему? Рассмотрим, что происходит при выполнении такой простой строки как s:=s+'*';.

• определяется размер исходной строки s, пусть будет n. Это быстро – пара ассемблерных команд
• определяется размер результирующей строки – это n+1
• выделяется место под новую строку. Очень долгая операция.
• старая строка копируется в новое место. Также не короткая операция.
• дописывается один символ
• удаляется старая строка – быстро, но не так, как хотелось

То есть, когда мы создаём строку на 1000 элементов, мы 1000 раз выделяем и 999 раз удаляем память.

Оптимизируем

А теперь посмотрите на такой вариант кода.

function DupChar(c:char;count:integer):string;
var
i:integer;
begin
SetLength(Result,count);
for i:=1 to count do
Result[i]:=c;
end;

Здесь память выделяется один раз, а потом заполняется вся строка. Казалось бы, малость, а посмотрите на графики теперь:

По моим выкладкам, скорость возросла в 25-30 раз. Неплохо, да? Кто там говорил, что Delphi делает медленный код?

Я думаю, теперь уже становится яснее, почему TListView, TMemo, TListBox при добавлении большого количества строк начинают подтормаживать? Их работа аналогична.

Но с TListView и другими компонентами есть ещё одна проблема. Мы дублируем данные. То есть у нас где то в массиве есть данные и также они есть в TListView. Это ничего, пока мы не начинаем редактировать или сортировать. И тут начинают изобретаться велосипеды. Лично видел код, где в TListView отображались данные, а также на форме были ещё с десяток невидимых TMemo, в которых хранилась вспомогательная информация. При удалении одной строки из списка передёргивались все компоненты. Сортировка была просто ужасной.

Виртуальный список

Выходом из сложившейся ситуации является виртуальный режим. В таком режиме TListView способен удерживать до 2³² элементов. Согласитесь, это уже нечто. Заинтересовались? Тогда вперёд. Давайте сделаем простой пример. В списке будут числа и их квадраты. Числа будут до 10000.

Итак, открываем Delphi и ставим на форму TListView. Дальше настраиваем такие свойства:

object ListView1: TListView
  Left = 152
Top = 168
Width = 250
Height = 150
Columns= <
item
     Caption = #1063#1080#1089#1083#1086
Width = 100
end
item
Caption = #1050#1074#1072#1076#1088#1072#1090
Width = 100
end>
OwnerData = True
TabOrder = 2
Viewstyle="vsReport"
End

Для тех, кому лень настраивать TListView, могут просто скопировать этот текст и, выбрав свою форму, нажать Ctrl+V. Главным свойством здесь является OwnerData. Именно оно переводит лист в виртуальный режим. Теперь список требует от нас, что бы мы указали, сколько будет элементов. Для этого я поставил кнопку и вписал туда строку

ListView1.Items.Count:=1000;

Теперь лист знает сколько элементов. Когда он захочет нарисовать их, он у нас попросит нужные элементы. Замечу, что «просить» их он может в произвольном порядке. Более того, просить он будет только те, которые нужно отрисовать. Если у вас на экране умещается 20 элементов, а в списке 1000, то попросит он только 20! Остальные будут запрашиваться по мере того, как вы будете прокручивать список. И ещё, он умеет их кэшировать. То есть, некоторые элементы повторно не будут запрашиваться.

Все запросы идут через событие OnData. В нём нас интересует параметр item – это переменная, куда мы должны заполнить данные. А номер элемента мы можем узнать через item.index. Итак, для наших целей нужен такой обработчик.

procedure TForm1.ListView1Data(Sender: TObject; Item: TListItem);
begin
item.Caption:=inttostr(item.Index);
item.SubItems.Add(inttostr(sqr(item.Index)));
end;

Для тех, кто раньше работал с TListView, тут нет ничего необычного. Всё! Запускаем и наслаждаемся. На своём компьютере я выставлял 1000000 (миллион!) и всё работало моментально. Попробуйте в качестве эксперимента повторить классическим способом. Я думаю при 1000-2000 вам уже надоест ждать заполнения.

Замечания

Об особенностях виртуально режима.

Сначала о недостатке – он пока один – если выставить свойство CheckBox, то они не появляются. Я пока не разобрался с этим, если у вас есть предложения – готов выслушать. Самое интересное, что место под них выделяется.

Допустим, вы храните данные в массиве и обновили их. А TListView не знает об этом. И на экране будут отображаться устаревшие данные. Для этого подскажем TListView, что данные изменены – вызываем метод UpdateItems(n,m). Где n – начальный элемент для обновления, m – конечный. То есть, если нужно обновить только пятый элемент, то пишем UpdateItems(5,5). Но если элемент не отображается на экране в данный момент, то эта строка проигнорируется TListView’ом.

Так как параметр Item имеет свойство ImageIndex, то можно, подцепив ImageList, и картинки добавлять.

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

Приложение

В приложенном архиве вы найдёте рабочий пример, где есть динамический массив структур.

А дальше?

Если вам интересны подобные темы, пишите свои замечания мне на почту – midav[a]land.ru или на IRC-канал сайта www.delphi.int.ru.

Опрос

На какую тему Вы хотели бы увидеть статью? Можете указать свой вариант, либо выбрать один из подобранных:

1. Как скачать файл
2. Как сделать редактор массива записей на основе виртуального ListView
3. Как "вытянуть новости" с определённого сайта
4. Свой вариант

Вы можете отправить свои статьи по адресу info@delphi.int.ru и они будут опубликованы в ближайших выпусках рассылки и на сайте.

Разделы: Статьи | Компоненты | Plug-in's | Документация | Исходники | Программы | Игры | Изображения

Уважаемые читатели! Отправляйте полезные компоненты/модули, интересные исходники, собственные программы/игры, книги, ученики и они будут размещены на сайте. Отправить можно здесь »

Отправить файл »   

Юмор