Result — Переменная Delphi


Содержание

Delphi-Help

Result

Result

Описание

var Result : Function-Return-Type;

Переменная Result используется, чтобы хранить значение результата, возвращенное функцией.

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

Пример кода

begin
// Получение квадратов некоторых чисел
ShowMessageFmt(‘Квадрат %d = %d’,[2, SquareIt(2)]);
ShowMessageFmt(‘Квадрат %d = %d’,[8, SquareIt(8)]);
end;

// Простая функция, которая возвращает квадрат параметра
function TForm1.SquareIt(value: Integer): Integer;
begin
// Возвращение значения в переменной Result
Result := value * value;
end;

Квадрат 2 = 4
Квадрат 8 = 64

Примечание

Если директива компилятора $ExtendedSyntax выключена, то вы должны использовать старый механизм возвращения — устанавливать результат функции в переменную с тем же самым названием что и функция. Такие переменные только для присвоения.

Функции 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.

Delphi Assembler / RTTI-гуру: Могу ли я получить адрес памяти и введите информацию о подразумеваемой переменной Result в функции?

Рассмотрим следующий типичный код для отслеживания метода (упрощены для иллюстрации):

Это работает как задумано. Выход:

Ввод F1
Делая некоторые вещи .
Выход F1 — Result = Booyah!

Сейчас я ищу способ , чтобы минимизировать количество необходимых параметров для вызова TraceMethod() , в идеале позволяет мне пропустить о Result связанных аргументы вообще. У меня нет опыта работы с ассемблере или стека макет себя , но если я не ошибаюсь, судя по «магии» Я видел другие люди, по крайней мере , адрес памяти , подразумеваемой магии Result -переменную должны быть получены каким — то образом, не следует , что ? И , возможно , один может работать оттуда , чтобы получить на его информации типа тоже?

Конечно, если бы можно было даже определить название «окружающего» функции самой , что устранило бы необходимость передачи аргументов TraceMethod полностью .

Я использую Delphi XE2, так что все введенные недавно язык / рамочные элементы могут быть использованы.

И прежде чем кто — нибудь упоминает это: Мой реальный код уже использует CodeSite.EnterMethod / ExitMethod вместо Writeln -calls. Я также знаю , что это упрощенный пример не может обрабатывать сложные типы и не выполняет обработку ошибок вообще.

Лучше всего действительно просто передать @Result . Если вы этого не сделаете, то нет никакой гарантии , что Result даже есть адрес. Функции возвращаются простые типы , как Integer и Boolean поместить результат в регистр EAX. Если нет никаких причин для результата иметь адрес, то компилятор не будет выделять какую — либо для него памяти. Используя выражение @Result вынуждает компилятор дать ему адрес.

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

Извлечь имя класса от имени метода. Тогда вы можете получить RTTI для этого типа . Это потребовало бы имя методы , чтобы включать в себя уникальное имя для класса ( в том числе единицы имени).

Используя список методов из этого типа, найти RTTI для метода. Это будет осложнено тем фактом , что имя не обязательно однозначно идентифицировать метод. Перегрузки все будет показывать то же самое имя. (Rruz показал , как бороться с RTTI перегруженных методов в контексте Invoke метода.) Кроме того , название метода вы получите от отладочной информации не обязательно будет совпадать с именем RTTI.

Вместо того , чтобы пытаться соответствовать имени, вы могли бы вместо того, чтобы петля над всеми методами класса, в поиски того, чьи CodeAddress свойство совпадает с адресом вызывающего абонента. Определение того, как получить адрес начала вызывающего абонента (вместо обратного адреса) оказывается гораздо труднее найти , чем я ожидал, хотя.

Получить метод возвращаемого типа и использовать Handle свойство , наконец , получить PTypeInfo значение , которое вы хотите.

Некоторые из этой функции уже включены в нашем TSynLog классе , который работает с Delphi 5 до XE2.

Она полна Open Source, и работать с Delphi XE2, поэтому у вас есть все необходимые исходные коды под рукой. И это показывает перехват исключений и трассировки стека.

Это позволяет кодирования след, как это:

Он будет зарегистрирован как таковой:

  • У вас есть номер строки и имя метода;
  • У вас есть точное время consummed в методе (00.002.229);
  • Это очень легко, чтобы отобразить любой результат (здесь, класс даже сериализованная, как JSON непосредственно, и вы можете сделать то же самое с любым типом данных, даже записей);
  • Методы могут быть вложенными, и есть также профилирующий инструмент доступен в нашем просмотрщик — то есть, вы можете получить в какие методы больше всего времени тратится на стороне клиента, из файла журнала;
  • Вы можете добавить трассировки стека, или любую информацию, вы хотите, очень легко;
  • Наш код очень оптимизирован для скорости: например , он использует interface для функции «автоматического отпуска», так же , как вы, но это не будет иметь никакого распределения памяти, так как он использует «фальшивый счетчик ссылок» трюк;
  • Конечно, определение Log переменной в стеке не является обязательным: если вам нужно только проследить вход / выход метода, просто писать TSQLLog.Enter достаточно. Log Локальная переменная используется для легкого гнезда дополнительной информации в рамках метода ( Log.Log(sllInfo,People) ).

Обратите внимание , что информация отладки (то есть имя метода и номера строк) извлекаются из патентованного очень Оптимизирован преобразования .map файла , созданного во время компиляции. Это будет гораздо меньше , чем .map сам (например , 900 КБ .map -> 70 KB .mab , которые могут быть легко встроены в EXE), поэтому меньше , чем формат , используемый JCL или MadExcept, а также меньше информации , вложенной во время компиляции Delphi.

Я не думаю , что , имея в «результате» жестко закодированы в «Enter» метод стоит. Это добавит много кодирования (например , преобразование в TValue отнимает много времени), для ничтожной выгоды — большую часть времени, вы должны будете знать гораздо больше , чем содержание результата.

Урок №9. Создание собственных процедур и функций Delphi

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

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

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

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

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

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

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

begin
//Код процедуры;
end ;

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

Result := результат;
end ;

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

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

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

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

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

implementation

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 .

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

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

Button1.W >//Ширина кнопки
а не
Form1.Button1.W >

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

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

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

Пример вычисления факториала

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

N! = 1*2* . *(N-1) *N = N* (N-1)!

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

Длинные строки и динамические массивы в Delphi

Автор: Вишневский Павел
http://www.nsk.su/

Опубликовано: 12.12.2004
Исправлено: 13.03.2005
Версия текста: 1.0

Среди типов переменных в Delphi есть несколько типов, существенно отличающихся от обычных.

ПРИМЕЧАНИЕ

В данной статье речь по сути идет о Delphi версии 7 и ниже. В Delphi.NET все, что связано с массивами и строками основано на .NET Framework и можно говорить скорее об эмуляции поведения массивов и строк. Их реализация же совершенно отличается от того, что было в Delphi прошлых версий. – прим.ред

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

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

Реализуемый компилятором код выглядит приблизительно так:

Что показывает приведенный пример:

  1. Переменная I, имеющая значение типа Integer, расположена в стеке и содержит случайный мусор. В отличие от переменной простого типа, для переменных S и A (являющихся указателями, также располагающимися в стеке), компилятор всегда вставляет код, инициализирующий их в nil .
  2. При присваивании длинным строкам значений или изменении размера массива компилятор вставляет код, динамически выделяющий область памяти, и присваивает указатель на нее этой переменной. То есть само содержимое строки или массива располагается в динамической памяти.
  3. Перед выходом из процедуры компилятор вставляет специальные функции финализации, ответственные за освобождение выделенной динамической памяти.
  4. И, наконец, компилятор заменяет почти все операции с этими переменными на свои системные функции.

Реализация

В начале выделяемой области памяти содержится заголовок, используемый системными функциями Delphi (определен в System.pas ) для управления переменными обсуждаемых типов. Заголовок описывается записью TPvsDynRec. Вот ее описание:

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

  • sizeFlags содержит размер памяти и некоторые флаги. Это поле прямо никак не связано ни со строкой или массивом, а относится к распределению памяти.
  • refCnt – счетчик ссылок.
  • length — длина строки, или количество элементов массива. Это значение возвращается функцией Length .

Присваивание и передача в качестве параметра

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

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

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

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

Длинные строки

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

Если происходит присваивание локальной переменной:

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

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

Любое изменение строки заменяется на вызов системных функций. Если счетчик строки в этот момент не равен 1 , создается новая строка. Исключением из этого правила является доступ к содержимому строки по указателю (приведение к типу PChar). В этом случае уже ничего не контролируется. Ниже приведены два примера, иллюстрирующих такое поведение.

К изменению строки через PChar нужно относится с осторожностью. Рассмотрим код:

Это код правильно скомпилируется, но при выполнении выдаст ошибку нарушения доступа. Причина в том, что строка S ( refCnt = -1 ) находится в сегменте памяти, защищенном от записи.

Поэтому казалось бы, безобидная процедура:

вызовет ошибку нарушения доступа при передаче в нее строки с refCnt = -1.

Чтобы получить уникальную ссылку для строки, состоящей из некоторой последовательности символов, можно воспользоваться функцией UniqueString. Это позволяет ускорить вычисления со строками, так как при этом можно будет сравнивать строки, просто сравнивая указатели на них. У таких строк refCnt всегда равен 1 .

Динамические массивы

В отличие от строк, динамический массив не может инициализироваться литералами, поэтому он не может иметь refCnt, равный -1 . Причем Delphi уже не контролирует изменение содержимого массива, а создает новый массив только при попытке изменения его размера (причем даже если сам размер не меняется), если refCnt > 1 .

В этом смысле поведение массива и строки принципиально отличается. Для иллюстрации этого различия рассмотрим две процедуры:

После выполнения E8 переданная строка не изменится, так как при S[1] := ‘t’ будет создана новая строка. Вызов же E9 приведет к изменению содержимого массива.

Рассмотрим более интересный пример. Пусть массив A не пуст.

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

Рассмотрим, почему так происходит. При вызове любой из этих процедур A — локальная переменная на стеке, указывающая на переданный массив. Пусть входной массив A = [0,1,2,3,4] .

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

Эта разница особенно заметна при передаче как константным параметром:

Локальная переменная Result

Хотя Result есть реальная локальная переменная, ее реализация в вопросе инициализации несколько отличается от вышесказанного. Причиной является то, что она создается в вызывающей процедуре, а в вызываемую функцию передается как скрытый параметр. Рассмотрим пример:

Результат может показаться неожиданным. Реализуемый Delphi код выглядит примерно так:

В данном случае сама переменная S используется как Result .

Несколько другой пример работает уже, как и ожидается.

Но реализуемый код аналогичен, только вводится временная переменная Tmp исполняющая роль Result

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

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

Переменные типа строки и динамические массивы все-таки указатели

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

Каково значение Str при вызове E16(S) из E17 ? Формально, раз параметр передается в процедуру E16 по значению, а тем более как константа, то изменение глобальной переменной S ничего не должно изменить. Но так как параметр есть только указатель, то изменение глобальной переменной S создаст новую строку, а память под старой будет освобождена (счетчик ссылок равен 1). В данном примере это неминуемо приведет к ошибке доступа к памяти. Можно привести множество подобных примеров, так что следует лучше полагаться на знание реализации таких типов данных, чем на формальные правила языка.

Хранение в переменных другого типа

Спрашивается, куда указывает P после выполнения процедуры E18 ? Естественно на мусор, так как память под строку S по выходе из процедуры будет освобождена. По этой же причине компилятор не позволяет помещать длинные строки и динамические массивы в вариантную часть записи, он просто не знает, что реально там будет и не может вставить код для управления ссылками и памятью.

Тем не менее, иногда возникает такая необходимость.

Для решения данной проблемы нужно присваивать в предыдущем примере

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

Для массива абсолютно аналогично.

Многомерные динамические массивы

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

Например, вызов SetLength(A,2,3) создает 3 массива:

  • массив A — массив указателей размерностью 2
  • два массива A[0] и A[1] — данных размерностью по 3

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

Создает треугольный массив.

Ошибка компилятора Delphi

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

При включенной оптимизации <$O+>и отключения range-checking <$R->, вызов этой функции приводил к ошибке доступа к памяти. Компилятор порождал, очевидно, ошибочный код:

Причем эта ошибка никак не связана с динамическими массивами, то же самое происходило и с функцией:

Когда в Borland узнали об этой ошибке, они ее быстро исправили и в Delphi6.2, она уже отсутствует. Для тех, кто продолжает работать с более старыми версиями, я советую обратить на это внимание. Для правильной работы функции E18 , ее следует несколько изменить:

Такой код, хоть и менее оптимально, правильно компилируется во всех версиях (я надеюсь).

Функции для работы с массивами

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

  • PvsDynArrayClone – создает уникальную копию массива.
  • PvsDynArrayInsert – вставляет новые элементы в любое место массива.
  • PvsDynArrayRemove – удаляет элементы из массива.
  • PvsDynArrayJoin – копирует элементы из одного массива в другой.

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

  • PvsQuickSort – процедура быстрой сортировки для любых данных представляемых как массив.
  • PvsArrayQuickSort — процедура быстрой сортировки для любых массивов как статических, так и динамических.
  • PvsDynArrayQuickSort — процедура быстрой сортировки для динамических массивов.
  • PvsBinaryFind – процедура двоичного поиска в любом массиве.
  • PvsDynArrayBinaryFind — процедура двоичного поиска в динамическом массиве.

Несколько замечаний по применению:

  1. Одним из параметров этих функций является RTTI о типе массива, возвращаемая оператором TypeInfo. И действительно, как можно изменить размер массива, не зная размер его элемента, ведь в заголовке массива размер элемента не хранится. И это не искусственный прием, так поступает сама Delphi. Таких функций, как SetLength или Length фактически не существует, компилятор заменяет их своими системными функциями. В частности вызов SetLength транслируется в DynArraySetLength, с передачей ему RTTI.
  2. Элементами динамического массива могут быть длинные строки, интерфейсы, динамические массивы и т.п. Поэтому при удалении такого элемента требуется выполнить финализацию всех находящихся в нем значений, какой бы вложенности они небыли. Предлагаемые функции корректно выполняют финализацию.
  3. Функции полностью следуют стандартному поведению в отношении учета счетчика ссылок.
  4. Для работы с динамическими массивами используются те же системные процедуры, которые использует сама Delphi.

Переменные Delphi

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

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

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

Заметка. Компилятор языка Delphi, как и компилятор языка Pascal, не различает использование прописных и строчных букв в идентификаторах переменных, то есть используя имена PROGRAM, Program, program, можно ввести обозначение одной и той же переменной. Обычно программисты обозначают переменные Delphi таким образом, чтоб ее имя было более-менее логически связано с ее непосредственным назначением.

Примеры переменных Delphi

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

логично присвоение следующих имен: корням квадратного уравнения — x1 и х2, а свободным коэффициентам — соответственно a, b и c.

Пример 2. Если программа содержит переменные, которым назначено хранение числовых данных о сумме покупки и величине скидки, то эти переменные можно обозначить идентификаторами (именами) соответственно totalsum и skidka. Чтобы использовать переменные в программе, написанной на любых языках программирования, в том числе и Delphi, ее необходимо объявить в разделе переменных var.

Объявление переменных Delphi

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

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

Пример 3:

Здесь двум переменным m и n присвоен тип real, а переменной k тип integer. В тексте исходной программы программист, как правило, объявляет каждую переменную, помещая ее в отдельной строке. Если в коде исходной программы присутствуют несколько переменных, которым присвоен один и тот же тип, то их имена перечисляют в одной строке, разделяя запятыми, и лишь после последней переменной, используя символ «:», указывают тип переменных:

Нужно ли освобождать (очищать) переменные, объявленные в функции?

Когда вызываешь функцию, нужно ли освобождать то что в ней создавал или функции делают все сами?

Можно ли и нужно ли, после Result := Player; ставить Player := nil; ?

Или надо каждый StringList по отдельности освобождать? Или и то и то?

Если из функции, вызвать еще одну и присвоить результат переменной, эту переменную тоже надо освобождать?

UPD

Вот сценарии(я попытался описать вкратце поэтому не ищите логику в действиях):

2 ответа 2

Когда вызываешь функцию, нужно ли освобождать то что в ней создавал или функции делают все сами?

Правильно чётко разделять, кто отвечает за создание и удаление объектов.

По идее, если ваша функция создает объект и отдает его вызывающей стороне, то теперь это обязанность вызывающей стороны — освободить этот объект.

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

Ниже ваш код и замечания/ошибки:

Можно ли и нужно ли, после Result := Player;ставить Player := nil;?

Можно, но лишено смысла и не нужно. В переменной лежит только указатель на объект. Присвоение ему nil (или любого другого значения) никак ни на что не влияет. Исключение — интерфейсы (ISomething) и объекты на новых платформах с ARC. У них есть счетчики ссылок, но вам это пока использовать наверно не нужно.

Или надо каждый StringList по отдельности освобождать? Или и то и то?

Каждый созданный объект надо освобождать — да. Иногда объекты регистрируются в неких структурах, тогда при выходе, структура сама освободит все объекты хранящиеся в ней (например Формы и их контролы сделаны так).

Если из функции, вызвать еще одну и присвоить результат переменной, эту переменную тоже надо освобождать?

  • Переменные не надо освобождать. Освобождать надо созданные объекты.
  • Не имеет смысла создавать объект и освобождать его в функции которая должна его возвращать.


@Kromster я тоже так стараюсь делать, вот вопрос, создал объект, поработал с ним, положил в результат, объект уничтожил, в Result ничего не исчезнет? из-за того, что уничтожил объект, естественно после присвоения

Еще раз, в переменной лежит только адрес объекта. Адреса можно менять, присваивать, копировать, удалять. С самим объектом от этого ничего не происходит. Представьте, что объект это Вы. А переменная с адресом — это запись про вас в телефонной книге. Вы книгу можете ксерить, сжигать, перевыпускать, вырезать и вклеивать цифры. С вами от этого ничего не случится. Но . если вас удалить, например, то запись в книге станет недействительна, как и во всех ее копиях.
Итого — если вы уничтожите объект, то все его «адреса» станут недействительны. Вы получите либо ошибку, либо мусорные данные («звонит кто-то вам, а вас уже нет, и вместо вас отвечает черти кто»)

Кстати, пример не акти получился, на практике все грамотнее, там просто кода много

Усомнюсь. У вас отсутствуют базовые понятия о жизни объектов. Читайте статьи и книге по этой теме!

Result — Переменная 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!

Result — Переменная 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!):

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

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

Result — Переменная Delphi

В этом уроке я расскажу вам об устройстве и применении процедур и функций в языке программирования Pascal/Delphi.

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

[cc lang=’delphi’]procedure shownumbers(n:integer);
var i:integer;
begin
for i:=1 to n do
showmessage(inttostr(i));
end;

procedure showsimplemessages;
begin
showmessage(‘This is a simple message 1!’);
showmessage(‘This is a simple message 2!’);
end;

procedure TForm1.OnCreate(Sender:TObject);
begin
shownumbers(5);
showsimplemessages;
end;[/cc]

Пока не будем изучать синтаксис, сначала разберемся с принципом работы процедур. Как вы уже наверное заметили, все события (например тот же OnCreate) представлены процедурами. Сначала изучим содержимое обработчика события создания формы Form1 (или точнее уже можно говорить — содержимое процедуры «procedure TForm1.OnCreate(Sender:TObject)»). Внутри этой процедуры мы видим «shownumbers(5);» и «showsimplemessages;» — это и есть вызов процедур, находящихся выше чем «procedure TForm1.OnCreate(Sender:TObject)». Как вы уже наверняка поняли, для того чтобы вызвать существующую процедуру, необходимо сначала указать ее название, а затем в скобках перечислить ее параметры. Если параметр один, то достаточно просто указать его значение. Также, процедуры могут не иметь параметров. В таком случае скобки можно опустить. Указывать сами параметры нужно в соответствующем им типе. Например строковые переменные «string» нужно указывать в кавычках ‘ ‘.

Теперь разберем синтаксис самой процедуры. В самом начале процедуры идет ключевое слово «procedure». Затем указывается имя процедуры, а после имени указываются параметры в скобках. Указываются они перечислением через «точку с запятой». Несколько однотипных переменных подряд можно указывать через запятую. На словах это понять достаточно трудно, поэтому приведу пример:

[cc lang=»delphi»]procedure example(a,b,c:integer; d:string; e:real; x1,y1:string);[/cc]

Затем, после объявления параметров процедуры, указывается программный код процедуры между ключевыми словами «begin» и «end» также, как это показано на первом примере. Перед «begin» можно также указать локальные переменные, создав новый раздел var. Эти переменные могут использоваться и обрабатываться только внутри самой процедурой, внутри которой они объявлены. Также внутри программного кода процедуры можно использовать параметры процедуры как обычные переменные указанного в процедуре типа. Только во время вызова процедуры, всем параметрам процедуры будет уже переданы соответствующие значения, указанные в вызове процедуры.

[warning]Очень важно при написании кода учитывать то, что сама процедура должна находиться выше в коде, чем то место где происходит ее вызов! Иначе может произойти ошибка, связанная с тем, что процедура попросту не будет найдена. [/warning]

[note]Любая процедура может вызвать любую другую процедуру, но только если вызываемая процедура стоит выше вызывающей ее процедуры.[/note]

[note]Внутри процедур можно обращаться к глобальным переменным и изменять их значения.[/note]

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

[cc lang=’delphi’]function calc(a,b,c:integer; d:string): integer;
begin
result:=length(d);
inc(a,5);
dec(b,2);
inc(result, a+b-c);
end;

procedure TForm1.OnCreate(Sender:TObject);
var a:integer;
begin
a:=calc(1,2,3,’testing’);
showmessage(‘Результат функции равен ‘+inttostr(a));
end;[/cc]

Кстати, в этом примере мы также разберем две новые процедуры и одну новую для вас функцию, уже предусмотренные в Pascal/Delphi. Эти процедуры — «inc(a;integer;b:integer)» и «dec(a:integer;b:integer)». Первая называется инкрементом, и увеличивает целочисленное число «a» на «б» единиц. Вторая процедура называется декрементом, и делает совершенно обратную операцию инкременту, а именно уменьшает целочисленное число «a» на «b» единиц. Если переменной «b» не указать значение, то вместо числа «b» автоматически будет использоваться единица. Таким образом «inc(a);» — тоже самое что и «inc(a,1);». В качестве «b» могут выступать и отрицательные числа, что приведет к инверсии операции, т.е. «inc(a,-3);» — тоже самое что и «dec(a,3);». Процедуры инкремента и декремента использовать несколько удобнее и работают они относительно быстрее чем присвоение «a:=a+1;».

[note]Функция «length(s:string):integer» подсчитывает количество символов в строке s и возвращает результат в виде целочисленной переменной.[/note]

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

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

[cc lang=’delphi’]function example: string;
begin
result:=’simple function’;
end;[/cc]

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

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

[note]Функции и процедуры могут вызывать сами себя. Такой прием программирования называется рекурсией и используются чаще всего в реализации каких-либо алгоритмов.[/note]

[note]Название процедур и функций может содержать только латинские буквы, цифры и знаки подчеркивания.[/note]

[note]Функции и процедуры с любыми различиями в параметрах считаются абсолютно разными и независимыми друг от друга, даже если у них одинаковые названия. Если существует две функции или процедуры с одинаковыми названиями, но разными параметрами, то при вызове одной из этих процедур или функций будет использоваться автоматически та, которая подходит по параметрам (по их типам и количеству).[/note]

На этом наш урок подошел к концу. Если у вас возникли какие-либо вопросы, то смело задавайте их в комментариях.

Илон Маск рекомендует:  Что такое код globalalloc
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL