Object Pascal для программистов Michalis Kamburelismichalis/tmp/... · 1....

Краткое введение в современный

Object Pascal для программистов

Michalis Kamburelis

Table of Contents

1. Введение: Для чего это нужно? ......................................................................... 22. Основы ................................................................................................................. 4

2.1. Программа "Hello world!" ........................................................................... 42.2. Функции, процедуры, простейшие типы .................................................. 52.3. Условные операторы (if) ........................................................................... 72.4. Логические операторы, операторы отношений и побитовые(поразрядные) операторы ................................................................................ 82.5. Проверка одного выражения на множественные значения (операторcase) ................................................................................................................. 102.6. Перечисляемый и порядковый типы, наборы и массивы постояннойдлины ............................................................................................................... 112.7. Циклы (for, while, repeat, for .. in) ............................................................ 122.8. Вывод информации и логов ................................................................... 152.9. Преобразование данных в строчный тип .............................................. 17

3. Модули (Unit-ы) .................................................................................................. 183.1. Перекрёстные ссылки между unit-ами ................................................... 203.2. Определение идентификаторов с указанием имени unit-а ................... 213.3. Передача идентификаторов одного unit-а через другой ....................... 24

4. Классы ................................................................................................................ 254.1. Основы ..................................................................................................... 254.2. Наследование (Inheritance), проверка (is), и приведение типов (as) ... 264.3. Свойства ................................................................................................... 284.4. Исключения .............................................................................................. 314.5. Уровни видимости ................................................................................... 324.6. Предок по умолчанию ............................................................................. 33

5. Освобождение памяти классов ........................................................................ 335.1. Всегда необходимо освобождать экземпляры класса .......................... 335.2. Каким образом освобождать память ..................................................... 345.3. Ручное и автоматическое освобождение памяти ................................. 355.4. Free notification ......................................................................................... 38

1

Краткое введение в современныйObject Pascal для программистов

6. Run-time library ................................................................................................... 416.1. Ввод/вывод с помощью потоков ............................................................. 416.2. Списки ...................................................................................................... 426.3. Клонирование классов: TPersistent.Assign ............................................ 43

7. Различные полезные возможности языка ....................................................... 457.1. Местные (вложенные) процедуры .......................................................... 457.2. Колбэки#—#они же события, они же указатели на функции, они жепроцедурные переменные ............................................................................. 477.3. Generic-и ................................................................................................... 497.4. Overload .................................................................................................... 517.5. Предобработка кода ................................................................................ 527.6. Record ....................................................................................................... 557.7. Устаревшие object ................................................................................... 567.8. Pointer-ы ................................................................................................... 577.9. Перегрузка операторов ........................................................................... 58

8. Дополнительные возможности классов ........................................................... 618.1. Различие private и strict private ............................................................... 618.2. Class method ............................................................................................ 618.3. Дополнительные возможности объявления классов и локальныеклассы .............................................................................................................. 628.4. Ссылки на класс ...................................................................................... 638.5. Class helper .............................................................................................. 668.6. Виртуальные constructor-ы, destructor-ы ................................................ 688.7. Ошибки при исполнении constructor-а ................................................... 68

9. Интерфейсы ....................................................................................................... 709.1. Хорошие (CORBA) интерфейсы ............................................................. 709.2. CORBA и COM интерфейсы ................................................................... 729.3. GUID-ы интерфейсов .............................................................................. 749.4. Некрасивые (COM) интерфейсы ............................................................ 749.5. Использование COM интерфейсов с отключённым reference-counting ............................................................................................................ 779.6. Приведение типов интерфейсов без оператора "as" ............................ 79

10. Про этот документ ........................................................................................... 80

1. Введение: Для чего это нужно?

В мире существует множество книг о Паскале, однако, многие из них говорят об"устаревшем" Паскале, без классов, модулей, generic-ов (дженериков) и многихдругих современных методов и приёмов программирования.

2


С целью заполнения этой бреши и было написано это краткое введение отом, что часто называется современным объектным Паскалем. Чаще егоназывают просто "Паскаль" или "Наш Паскаль". Впрочем, представляя язык,важно подчеркнуть, что это современный, объектно-ориентированный язык,который был существенно усовершенствован по сравнению со старым (Turbo)Pascal, который когда-то давно изучали в школах и институтах. Сегодня еговполне можно сравнивать с такими известными языками программирования, какC++, Java или C#.

• Паскаль имеет все современные особенности, которые можно ожидать-- классы, модульную структуру, интерфейсы, generic-и…

• Паскаль компилируется в быстрый машинный код.

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

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

Он так же имеет превосходный кроссплатформенный портативный компилятор соткрытым исходным кодом: Free Pascal Compiler (http://freepascal.org/). Для негосуществует несколько IDE (включающих в себя редактор, отладчик, библиотекикомпонентов, дизайнер форм), одна из наиболее известных называется Lazarus(http://lazarus.freepascal.org/). Автора данной книги является создателем CastleGame Engine (http://castle-engine.sourceforge.net/) - который является мощнымпортативным двух- и трёхмерным игровым движком, использующим этот язык,для создания игр под многие платформы: Windows, Linux, MacOSX, Android, iOS,web плагины.

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

Прим.перев. Здесь и далее мы будем использовать оригинальные английскиепонятия такие как unit, constructor, override, reference-counting в случаях, еслиони являются ключевыми словами языка либо не имеют общепринятыхпереводов на русский язык. Мы также часто предпочитаем использоватьоригинальное английское слово его транслитерации, как в случае с понятием"generic" выше.

3

http://freepascal.org/

http://lazarus.freepascal.org/

http://castle-engine.sourceforge.net/


2. Основы

2.1. Программа "Hello world!"

По доброй традиции знакомство с языком начинают с самой базовой и простойпрограммы "Hello world". На Паскале она выглядит следующим образом:

{$mode objfpc}{$H+}{$J-} // Эту строку необходимо использовать во всех

современных программах

program MyProgram; // Сохраните этот файл под названием myprogram.lpr

begin

Writeln('Hello world!');

end.

Это — полноценная программа, которую можно скомпилировать и запустить.

• Это можно сделать с помощью командной строки FPC, просто создав новыйфайл myprogram.lpr с кодом программы внутри и выполнив команду fpcmyprogram.lpr .

• Если используется Lazarus, то необходимо создать новый проект (в строкеменю: Project → New Project → Simple Program). Сохраните его как myprogramи скопируйте в него этот исходный код. Компиляция выполняется используяпункт Run → Compile в меню (горячая клавиша F9).

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

Остальная часть этой книги рассказывает о самом объектном Паскале, поэтомуне ожидайте чего-либо большего, чем консольных приложений. Если хочетсявзглянуть на что-либо более "крутое", можно просто создать новый GUIпроект в Lazarus (Project → New Project → Application). Вуаля! — рабочеекроссплатформенное GUI приложение, с нативным видом, использующееудобные визуальные библиотеки. Lazarus и Free Pascal Compiler имеютмножество готовых компонент для сетей, GUI, баз данных, чтения и записиразличных форматов файлов (XML, json, изображения…), управления потокамии всем, что только может понадобиться программисту. Ярким тому примеромявляется Castle Game Engine, о котором упоминалось ранее :)

4


2.2. Функции, процедуры, простейшие типы

{$mode objfpc}{$H+}{$J-}

program MyProgram;

procedure MyProcedure(const A: Integer);

begin

Writeln('A + 10 составляет: ', A + 10);

end;

function MyFunction(const S: string): string;

begin

Result := S + 'строки управляются автоматически';

end;

var

X: Single;

begin

Writeln(MyFunction('примечание: '));

MyProcedure(5);

// деление с помощью оператора "/" всегда даёт результат с плавающей

запятой

// для целочисленного деления необходимо использовать "div"

X := 15 / 5;

Writeln('X составляет: ', X); // отобразить в научном формате вида

3.0000000E+000

Writeln('X составляет: ', X:1:2); // отобразить 2 знака после запятой

end.

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


begin

Result := S + ' Добавим что-нибудь';

Result := Result + ' и ещё что-нибудь!';

Result := Result + ' И ещё немножко!';

end;

5


Можно рассматривать имя функции ( MyFunction в примере выше) какпеременную, которую можно использовать как самую обычную переменную. Нолично я бы не советовал так делать, поскольку это выглядит не очень "прозрачно",особенно в случае, если это значение используется с правой стороны выражения.Лучше всегда использовать Result , в случае, если необходимо использоватьили устанавливать возвращаемое значение функции.

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

function ReadIntegersUntilZero: string;

var

I: Integer;

begin

Readln(I);

Result := IntToStr(I);

if I <> 0 then

Result := Result + ' ' + ReadIntegersUntilZero();

end;

Функция Exit служит для завершения выполнения процедуры или функциидо того, как она достигнет завершающего end; . Если Exit вызватьбез параметров, она вернёт последнее значение, присвоенное Result .Так же можно использовать конструкцию Exit(X) , чтобы установитьрезультат функции и завершить её исполнение немедленно — это эквивалентноконструкции return X в С-подобных языках.

function AddName(const ExistingNames, NewName: string): string;

begin

if ExistingNames = '' then

Exit(NewName);

Result := ExistingNames + ', ' + NewName;

end;

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

6


var count: Integer;

myCount: Integer;

function CountMe: Integer;

begin

inc(count);

result := count;

end;

begin

count := 10;

CountMe; //результат функции будет отброшен, однако функция выполняется

myCount := CountMe; //обычное применение функции

end.

2.3. Условные операторы (if)

Конструкции if .. then или if .. then .. else запускают определённыйкод, когда выполняется указанное условие. В отличии от C-подобных языков, вПаскале нет строгого требования ставить условие в скобки.

var

A: Integer;

B: boolean;

begin

if A > 0 then

DoSomething;

if A > 0 then

begin

DoSomething;

AndDoSomethingMore;

end;

if A > 10 then

DoSomething

else

DoSomethingElse;

// идентично предыдущему примеру

B := A > 10;

if B then

DoSomething

7


else

DoSomethingElse;

end;

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

if A <> 0 then

if B <> 0 then

AIsNonzeroAndBToo

else

AIsNonzeroButBIsZero;

Впрочем, заключение вложенного if внутри блока begin … end; являетсялучшим вариантом, чем предыдущий пример, поскольку он более читабельный,даже если нарушены отступы или большой объём кода и комментариевзатрудняет понимание. Таким образом, всегда очевидно к какому if относитсяданный else - относительно A или относительно B - и, соответственно, кудаменьше шансов допустить ошибку при написании кода или при его правках.

if A <> 0 then

begin

if B <> 0 then

AIsNonzeroAndBToo

else

AIsNonzeroButBIsZero;

end;

2.4. Логические операторы, операторы отношений и

побитовые (поразрядные) операторы

Логические операторы представлены в Паскале операторами and , or , not ,xor . Их значение в большинстве случаев очевидно для людей, знакомых скомпьютерной грамотой. Разве что, за исключением оператора xor , которыйв русской литературе обычно называется "исключающее или". Эти операторыпринимают булевские аргументы (boolean), и возвращаемое значение имеет тотже тип boolean. Они также могут работать как побитовые операторы, в случае,если оба аргумента целого типа (integer, byte или подобные), в этом случае онитакже возвращают значение идентичного целого типа.

8


Операторы отношения (сравнения) - представлены следующими комбинациямисимволов: = , <> , > , < , <= , >= , значение которых вполне очевидно. Следуетотметить, что в отличии от синтаксиса С-подобных языков, в Паскале операторсравнения выглядит как один знак "равно" A = B (в отличии от С, гдеиспользуется код A == B ). Специальным оператором присваивания в Паскалеявляется := .

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

Следующий пример вызовет ошибку компиляции:

var

A, B: Integer;

begin

if A = 0 and B <> 0 then ... // так делать НЕЛЬЗЯ

Ошибка связана с тем, что компилятор в первую очередь пытается выполнитьпобитовый оператор and в середине выражения и в результате получается (0and B) - побитная операция, возвращающая целочисленную величину. Далеекомпилятор выполняет оператор "равно" и получает булевскую величину A = (0and B) . Финальная ошибка оказывается связана с попыткой сравнить булевскуювеличину A = (0 and B) с целочисленной величиной 0 .

Правильно записывать это условие в следующем виде:

var

A, B: Integer;

begin

if (A = 0) and (B <> 0) then ...

Паскаль использует "короткую оценку (short-circuit evaluation)" - мощнуюоптимизацию, позволяющую не вычислять выражение целиком, если какая-либоего часть полностью определяет результат. Рассмотрим пример:

if MyFunction(X) and MyOtherFunction(Y) then...

• Значение функции MyFunction(X) всегда рассчитывается первым.

9


• И если MyFunction(X) вернёт значение false , это означает, что мы ужезнаем результат всего выражения - какое бы ни было второе значение, привыполнении false and что-нибудь мы всегда получим false . Такимобразом MyOtherFunction(Y) вообще не будет выполняться.

• Идентичная ситуация и с выражением or . В данном случае, если мы наперёдзнаем, что результат будет true потому что первый аргумент имеет значениеtrue , второй аргумент не влияет на результат и не будет рассчитываться.

• Это особенно полезно если нужно записать выражение типа:

if (A <> nil) and A.IsValid then...

В данном случае не возникнет ошибки даже в случае если A имеет значениеnil (т.е. нулевой указатель).

2.5. Проверка одного выражения на множественные

значения (оператор case)

Если в зависимости от разных значений определённого выражения должныбыть выполнены разные действия, тогда может оказаться удобной конструкцияcase .. of .. end .

case SomeValue of

0: DoSomething;

1: DoSomethingElse;

2: begin

IfItsTwoThenDoThis;

AndAlsoDoThis;

end;

3..10: DoSomethingInCaseItsInThisRange;

11, 21, 31: AndDoSomethingForTheseSpecialValues;

else DoSomethingInCaseOfUnexpectedValue;

end;

Условие else опционально (и соответствует default в C-подобных языках).В случае, если текущее значение анализируемого выражения не совпадает ни содним из описанных случаев и нет условия else , то программа просто пропуститвсю конструкцию case и будет выполняться далее.

Программисты С-подобных языков могут сравнить case с весьма подобнойконструкцией switch в этих языках. Стоит отметить, что case в

10


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

2.6. Перечисляемый и порядковый типы, наборы и

массивы постоянной длины

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

type

TAnimalKind = (akDuck, akCat, akDog);

Общепринято, что префикс перечисляемого типа состоит из двух буквсокращения имени типа, следовательно ak = сокращение для "Animal Kind".Это полезное соглашение, так как имена перечисляемых типов находятсяв глобальном пространстве переменных unit-а. Таким образом, с помощьюпрефикса ak автоматически уменьшаются шансы на случайный конфликт сдругими идентификаторами.

ПРИМЕЧАНИЕ: Конфликты в именах не приводят к неработоспособностипрограммы. Вполне допустимо в различных unit-ах определять одинаковыеидентификаторы. Однако, желательно избегать подобных конфликтов везде, гдеэто возможно, чтобы код был прост для понимания и анализа.

ПРИМЕЧАНИЕ: Можно избежать попадания имён перечисляемых типов вглобальное пространство с помощью директивы компилятора {$scopedenumson} . В таком варианте будет необходимо обращаться к ним через имятипа следующим образом: TAnimalKind.akDuck . В результате отпадаетнеобходимость в префиксе ak , и можно просто оставить исходные названияDuck, Cat, Dog . Такое исполнение подобно тому, как работают перечисляемыесписки в C#.

Прозрачность перечисляемого типа означает, что он не совместим напрямуюс целочисленными величинами. Тем не менее, если такая совместимостьнеобходима, можно использовать Ord(MyAnimalKind) , чтобы вручнуюпривести список к целочисленному типу. Обратная операция будет выглядеть

11


как приведение типа TAnimalKind(MyInteger) и превратит целое числов соответствующий перечисляемый тип. В последнем случае необходимотакже быть уверенным, что MyInteger является частью диапазона от 0 доOrd(High(TAnimalKind))) .

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

type

TArrayOfTenStrings = array [0..9] of string;

TArrayOfTenStrings1Based = array [1..10] of string;

TMyNumber = 0..9;

TAlsoArrayOfTenStrings = array [TMyNumber] of string;


TAnimalNames = array [TAnimalKind] of string;

Они также могут использоваться для создания наборов (они же set-ы, они жевнутренние битовые поля):

type


TAnimals = set of TAnimalKind;

var

A: TAnimals;

begin

A := [];

A := [akDuck, akCat];

A := A + [akDog];

A := A * [akCat, akDog];

Include(A, akDuck);

Exclude(A, akDuck);

end;

2.7. Циклы (for, while, repeat, for .. in)


{$R+} // включаем проверку на диапазон величин, очень полезно для отладки

var

MyArray: array [0..9] of Integer;

I: Integer;

12


begin

// инициализация

for I := 0 to 9 do

MyArray[I] := I * I;

// отображение

for I := 0 to 9 do

Writeln('Квадрат составляет ', MyArray[I]);

// делает то же самое, что и предыдущий вариант

for I := Low(MyArray) to High(MyArray) do


// делает то же самое

I := 0;

while I < 10 do

begin


I := I + 1; // это идентично "I += 1" или "Inc(I)"

end;


I := 0;

repeat


Inc(I);

until I = 10;


// обратите внимание, тут переменная I перечисляет значения элементов

массива, а не его индексы

for I in MyArray do

Writeln('Квадрат составляет ', I);

end.

Примечания:

• Может показаться, что различие между циклами while и repeat лишь"косметические" с единственным отличием, что условие записано "с точностьюдо наоборот": в случае while .. do выполнение продолжается, покаусловие истинно, а при repeat .. until - выполнение прекращается,когда условие истинно. Впрочем, есть ещё одно важное отличие: в случаеrepeat , условие проверяется не в начале, а в конце цикла. Поэтомусодержимое цикла repeat всегда выполняется как минимум один раз.

13


• Конструкция for I := .. to .. do … похожа на C-подобный цикл for . Темне менее, она более ограничена, поскольку невозможно указать произвольноедействие/условие чтобы контролировать итерации цикла. В Паскале forиспользуется строго для итерации через последовательные числа (илидругие порядковые типы). Единственной уступкой является возможностьиспользования downto вместо to , чтобы производить счёт в обратномпорядке.

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

Следует также обратить внимание, что переменная, которая использоваласьдля цикла (в примере выше - I ) становится неопределённой после окончанияцикла кроме случая досрочного выхода из цикла с помощью команд Breakили Exit . Цикл for I in .. do .. такой же как конструкция foreach вмногих других языках и хорошо понимает организацию всех встроенных типов:

• Он может перебирать все значения массива (см. пример выше).

• Он может перебирать все возможные значения перечисляемого типа:

var

AK: TAnimalKind;

begin

for AnimalKind in TAnimalKind do...

◦ Он может перебирать все элементы набора:

var

Animals: TAnimals;

AK: AnimalKind;

begin

Animals := [akDog, akCat];

for AK in Animals do ...

◦ И так же работает на всех пользовательских типах, включая generic-и,например, TObjectList или TFPGObjectList .


uses SysUtils, FGL;

14


type

TMyClass = class

I, Square: Integer;

end;

TMyClassList = specialize TFPGObjectList<TMyClass>;

var

List: TMyClassList;

C: TMyClass;

I: Integer;

begin

List := TMyClassList.Create(true); // значение true означает, что

List владеет всеми дочерними объектами

try

for I := 0 to 9 do

begin

C := TMyClass.Create;

C.I := I;

C.Square := I * I;

List.Add(C);

end;

for C in List do

Writeln('Квадрат ', C.I, ' составляет ', C.Square);

finally FreeAndNil(List) end;

end.

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

2.8. Вывод информации и логов

Для простого вывода строки в Паскале используется процедура Write илиWriteln . Во втором случае в конце автоматически добавляется символпереноса строки.

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

15


Writeln('Hello world!');

Writeln('Можно вывести целое число: ', 3 * 4);

Writeln('Отформатировать его: ', 666:10);

Writeln('А также вывести число с плавающей запятой: ', Pi:1:4);

Чтобы явным образом добавить перенос строки можно использовать константуLineEnding (из библиотеки FPC RTL). (Castle Game Engine имеет также болеекраткий вариант NL ). В отличии от HTML и других подобных синтаксисовразметок в Паскале обратная косая ( \ ) не позволяет вставлять специальныесимволы в строке, например:

Writeln('Первая строка.\nВторая стока.'); // НЕВЕРНЫЙ пример

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

Writeln('Первая строка.' + LineEnding + 'Вторая строка.');

или так:

Writeln('Первая строка.');

Writeln('Вторая строка.');

Стоит отметить, что функции write / writeln будут работать только вконсольных приложениях. Для этого необходимо указывать {$apptype

CONSOLE} (но не {$apptype GUI} ) в главном файле программы. На некоторыхОС консоль явно или скрыто присутствует всегда (Unix) и эта директива неиспользуется. А в некоторых системах попытка выполнения write / writeln изGUI приложения приведёт к ошибке (например, в Windows).

В Castle Game Engine не советуется использовать Writeln , поскольку дляэтого есть специальная функция WritelnLog или WritelnWarning длявывода логов и отладочной информации. Их результат всегда будет направленв полезном направлении: для Unix-подобных систем это будет стандартныйвывод в консоль. Для Windows GUI приложений это будет лог-файл. В Androidвывод будет направлен в Android logging facility (инструмент логов Андроида),который можно просматривать с помощью команды adb logcat . ИспользоватьWriteln есть смысл лишь в ограниченном наборе случаев, например, дляконсольных приложений (исполняемых из командной строки) в которых можно

16


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

2.9. Преобразование данных в строчный тип

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

• Некоторые конкретные типы можно преобразовать в строку используяспециальные функции, такие как IntToStr и FloatToStr . В дальнейшемсуммировать (concatenation) строки в Паскале можно просто используя знаксложения. Таким образом можно создавать составные строки: 'Моё целоечисло ' + IntToStr(MyInt) + ', а значение числа пи составляет

' + FloatToStr(Pi) .

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

◦ Второе преимущество: они почти всегда имеют обратную функцию. Чтобыпреобразовать строку (например, введённую пользователем) в целое илидробное число можно использовать StrToInt , StrToFloat и подобные(например, StrToIntDef ).

◦ Недостаток: длинная сумма множества XxxToStr и строк выглядитнекрасиво.

• Функция Format используется в виде Format('%d %f %s', [MyInt,

MyFloat, MyString]) . Она подобна функции sprintf в C-подобныхязыках. Она вставляет аргументы в соответствующие placeholder-ы согласнозаданному образцу. Эти placeholder-ы могут использовать специальныйсинтаксис, влияющий на форматирование, например %.4f это дробныйформат с 4 знаками после запятой.

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

◦ Второе преимущество: не используются "волшебные" свойствакомпилятора. Можно использовать идентичный синтаксис дляпередачи произвольного количества аргументов произвольного типа

17


в пользовательских процедурах (для этого определите принимаемыйпараметр как array of const ). Затем можно передать эти аргументыфункции Format , или разобрать на список параметров и делать с ним всё,что угодно.

◦ Недостаток: компилятор не проверяет, соответствует ли строка-образецаргументам. Используя неверный тип placeholder-а приведёт к ошибкеEConvertError , впрочем, гораздо более понятной, чем segmentation fault(наиболее часто SIGSEGV).

• В Паскале также существует функция WriteStr(TargetString, …) вомногом подобна базовой функции Write(…) , с одним отличием - результатсохраняется в TargetString .

◦ Преимущество: эта функция имеет все возможности функции Write , втом числе и специальный "волшебный" синтаксис для форматирования, какнапример Pi:1:4 .

◦ Недостаток: такой специальный синтаксис для форматирования является"волшебным", т.е. он написан специально для конкретной процедуры. Частоэто приводит к проблемам, например, невозможно создать свою функциюMyStringFormatter(…) которая бы принимала такой синтаксис, какPi:1:4 . Именно по этому, а также из-за того, что эта функция долгое времяне была доступна в основных компиляторах, такая конструкция не оченьпопулярна.

3. Модули (Unit-ы)

Unit-ы позволяют группировать общие функции и объекты (любые элементыязыка, которые могут быть объявлены), для использования другими unit-ами ипрограммами. Они эквивалентны модулям и пакетам в других языках. Они имеютсекцию interface , где объявляются доступные для других unit-ов и программпеременные, функции и т.п., и секцию implementation , где описано, как ониработают. Unit MyUnit можно сохранить под именем myunit.pas (названиедолжно состоять из строчных букв с расширением .pas ).


unit MyUnit;

interface



18


implementation


begin

Writeln('A + 10 составляет: ', A + 10);

end;


begin

Result := S + 'строки управляются автоматически';

end;

end.

Файл основной программы чаще всего сохраняется в виде файлов типаmyprogram.lpr ( lpr = Lazarus program file; в Delphi используются .dpr ).Следует отметить, что возможны и другие расширения, например, некоторыепроекты используют расширение .pas для основного файла программы. Дляunit-ов изредка используются расширение .pp . Лично же я предпочитаюиспользовать стандартные .pas для unit-ов и .lpr для FPC/Lazarus программ.

Программа может подключать unit с помощью ключевого слова uses :


program MyProgram;

uses MyUnit;

var

X: Single;

begin

Writeln(MyFunction('Примечание: '));

MyProcedure(5);

end.

Ещё одной полезной особенностью unit-ов являются под-секцииinitialization и finalization внутри секции implementation которыевыполняются при запуске и завершении выполнения программы.


unit initialization_finalization;

19


interface

implementation

initialization

writeln('Hello world!');

finalization

writeln('Goodbye world!');

end.

3.1. Перекрёстные ссылки между unit-ами

Не только основная программа, но и unit-ы также могут ссылаться на другие unit-ы. Другой unit может войти в секцию interface или только в implementation. Первыйвариант позволяет создавать новые определения (процедуры, типы…), используяили наследуя информацию из другого unit-а. Во втором варианте возможностиболее ограничены - если использовать unit в секции implementation, то применитьего идентификаторы возможно лишь в рамках implementation данного unit-а.


unit AnotherUnit;

interface

uses Classes;

{ Тип класса "TComponent" определён в unit-е Classes.

По этому необходимо использовать uses Classes, как видно выше. }

procedure DoSomethingWithComponent(var C: TComponent);

implementation

uses SysUtils;

procedure DoSomethingWithComponent(var C: TComponent);

begin

{ Процедура FreeAndNil определена в unit-е SysUtils.

Поскольку мы лишь ссылаемся на её имя в разделе implementation,

вполне допустимо использовать SysUtils в секции "implementation". }

FreeAndNil(C);

end;

20


end.

Запрещено применять кольцевую взаимозависимость (cyclic reference) вразделе interface. Т.е. два unit-а не могут использовать друг друга в разделеinterface. Причина такого ограничения заключается в том, что для того,чтобы "понять" секцию interface unit-а, компилятор анализирует и "понимает"все unit-ы, перечисленные в uses в секции interface. В Паскале этоправило придерживается строго, что позволяет достичь высокой скоростикомпиляции и полностью автоматическое определение компилятором чтоименно необходимо перекомпилировать. В Паскале нет необходимостисоздания сложных Makefile для выполнения простой задачи компиляции, атакже нет нужды перекомпилировать всё лишь для того, чтобы удостовериться,что все зависимости правильно обновились.

Вполне возможно создавать кольцевые зависимости между unit-ами когда одиниз них "используется" только в implementation. Поэтому нормально для A

использовать B в interface, и затем unit B использует A в implementation.

3.2. Определение идентификаторов с указанием имени

unit-а

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

Однако, возможно недвусмысленно определить unit предоставляющийидентификатор, с помощью конструкции MyUnit.MyIdentifier . Этостандартное решение ситуации, когда используемый идентификатор из MyUnitскрыт идентификатором из другого unit-а. Для достижения этой же цели можнопросто перестроить порядок unit-ов в списке uses, однако это повлияет на всеидентификаторы, что не всегда желательно.


program showcolor;

// unit-ы Graphics и GoogleMapsEngine определяют свой тип TColor.

uses Graphics, GoogleMapsEngine;

21


var

{ Это сработает не так, как ожидается, поскольку TColor

определяется последним unit-ом в списке - GoogleMapsEngine. }

// Color: TColor;

{ А так будет правильно. }

Color: Graphics.TColor;

begin

Color := clYellow;

Writeln(Red(Color), ' ', Green(Color), ' ', Blue(Color));

end.

В случае unit-ов следует также помнить, что они могут иметь два списка uses :один - в секции interface , другой - в implementation . Основное правилов этом случае звучит как: "позднейшие unit-ы скрывают все что было доэтого" и применяется последовательно, что в свою очередь означает, что unit-ы использованные в секции implementation могут скрывать идентификаторы изunit-ов использованных в секции interface. Кроме того, не стоит забывать, что впроцессе обработки секции interface данного unit-а компилятором, влияют лишьunit-ы использованные в секции interface. Это может сбить с толку в ситуациях,когда два на вид одинаковых объявления обрабатываются компилятором по-разному:


unit UnitUsingColors;

// НЕВЕРНЫЙ пример

interface

uses Graphics;

procedure ShowColor(const Color: TColor);

implementation

uses GoogleMapsEngine;


begin

// Writeln(ColorToString(Color));

end;

22


end.

Unit Graphics (из набора библиотек Lazarus LCL) определяет тип TColor .Но компилятор указывает на ошибку в этом unit-е, указывая на то,что заявленная в секции Interface процедура ShowColor не описана.Проблема в том, что unit GoogleMapsEngine также определяет тип TColor ,который используется только в секции implementation , следовательноон перекрывает определение TColor в секции implementation . Т.е.компилятор видит это буквально как:



// НЕВЕРНЫЙ пример

// демонстрирующий, как предыдущий пример "видит" компилятор

interface

uses Graphics;

procedure ShowColor(const Color: Graphics.TColor);

implementation


procedure ShowColor(const Color: GoogleMapsEngine.TColor);

begin


end;

end.

В данном случае решение тривиальное: необходимо просто изменитьimplementation , чтобы явно использовать TColor из unit-а Graphics . Этотакже можно исправить, переместив GoogleMapsEngine в секцию interface доunit-а Graphics . Впрочем, это может привести к другим последствиям внутриunit-а UnitUsingColors , так как коснётся всех его определений.



23


interface

uses Graphics;


implementation


procedure ShowColor(const Color: Graphics.TColor);

begin


end;

end.

3.3. Передача идентификаторов одного unit-а через

другой

Иногда возникает необходимость взять идентификатор из одного unit-а ипередать его через другой unit. Т.е. в результате использование нового unit-адолжно сделать доступным старый идентификатор в пространстве имён.

В некоторых случаях это делается из-за необходимости сохранить обратнуюсовместимость с предыдущими версиями unit-а. А иногда таким образом удобно"скрыть" какой-либо unit для внутреннего пользования.

Это может быть осуществлено с помощью повторного объявленияидентификатора в новом unit-е.


unit MyUnit;

interface

uses Graphics;

type

{ Используем TColor из unit-а Graphics для определения TMyColor. }

TMyColor = TColor;

{ Как вариант, можно переопределить его под тем же именем.

24


В таком варианте необходимо будет явно указать наименование unit-а,

иначе получится несогласованное определение "TColor = TColor". }

TColor = Graphics.TColor;

const

{ С константами это тоже работает. }

clYellow = Graphics.clYellow;

clBlue = Graphics.clBlue;

implementation

end.

Стоит отметить, что данный трюк не пройдёт с глобальными процедурами,функциями и переменными. В таком случае возникнет необходимость объявитьпостоянный указатель на процедуру в другом unit-е (см. Section 7.2, “Колбэки#—#они же события, они же указатели на функции, они же процедурныепеременные”), но такой код выглядит не совсем чисто.

Более оптимальным решением является создание тривиальной "функции-обёртки", которая под видом простого вызова функции из внешнего unit-а, простопередаёт ему параметры и возвращает принимаемые значения обратно.

Чтобы проделать тоже с глобальными параметрами иногда используютсяглобальные (на уровне unit-а) свойства, см. ???.

4. Классы

4.1. Основы

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

• поля (field) (иными словами "переменная внутри класса"),• методы (method) (иными словами "процедура или функция внутри класса"),• свойства (property) (удобный синтаксис для конструкции подобной полю,

однако в действительности являющейся парой методов, используемых длячтения (getter) и записи (setter) чего-либо; детальнее см. ???).

• Вообще говоря, в классах можно разместить очень много различныхвещей, см. Section 8.3, “Дополнительные возможности объявления классов илокальные классы”, но об этом пойдёт речь чуть позже.

25


type

TMyClass = class

MyInt: Integer; // это "поле"

property MyIntProperty: Integer read MyInt write MyInt; // это

"свойство"

procedure MyMethod; // это "метод"

end;

procedure TMyClass.MyMethod;

begin

Writeln(MyInt + 10);

end;

4.2. Наследование (Inheritance), проверка (is), и

приведение типов (as)

Паскаль поддерживает наследование и виртуальные методы объектно-ориентированного программирования.


program MyProgram;

uses SysUtils;

type

TMyClass = class

MyInt: Integer;

procedure MyVirtualMethod; virtual;

end;

TMyClassDescendant = class(TMyClass)

procedure MyVirtualMethod; override;

end;

procedure TMyClass.MyVirtualMethod;

begin

Writeln('TMyClass отображает MyInt + 10: ', MyInt + 10);

end;

procedure TMyClassDescendant.MyVirtualMethod;

begin

Writeln('TMyClassDescendant отображает MyInt + 20: ', MyInt + 20);

end;

26


var

C: TMyClass;

begin


try

C.MyVirtualMethod;

finally FreeAndNil(C) end;

C := TMyClassDescendant.Create;

try

C.MyVirtualMethod;


end.

По умолчанию методы не являются виртуальными и для объявления ихвиртуальными необходимо использовать ключевое слово virtual . Перекрытиеили замещение виртуального метода осуществляется с помощью ключевогослова override , иначе компилятор выдаст ошибку. Чтобы скрыть метод безперекрытия используется ключевое слово reintroduce , впрочем, без особыхна то причин, так делать не стоит.

Чтобы узнать, является ли некоторый класс из семейства классов конкретнымего наследником можно использовать оператор is . Для выполнения приведениятипа класса к конкретному классу следует использовать оператор as .


program is_as;

uses SysUtils;

type

TMyClass = class

procedure MyMethod;

end;


procedure MyMethodInDescendant;

end;


begin Writeln('Это MyMethod') end;

procedure TMyClassDescendant.MyMethodInDescendant;

27


begin Writeln('Это MyMethodInDescendant') end;

var

Descendant: TMyClassDescendant;

C: TMyClass;

begin

Descendant := TMyClassDescendant.Create;

try

Descendant.MyMethod;

Descendant.MyMethodInDescendant;

{ производные классы сохраняют все функции родительского класса

TMyClass, по этому можно таким образом создавать ссылку }

C := Descendant;

C.MyMethod;

{ так не сработает, поскольку в TMyClass не определён этот метод }

//C.MyMethodInDescendant;

{ правильно записать следующим образом: }

if C is TMyClassDescendant then

(C as TMyClassDescendant).MyMethodInDescendant;

finally FreeAndNil(Descendant) end;

end.

Вместо приведения типа в виде X as TMyClass , можно использоватьприведение типа без проверки с помощью выражения TMyClass(X) . Такойкод будет работать чуть-чуть быстрее, но может привести к неопределённомуповедению в случае если X не является наследником TMyClass . По этомуконструкцию TMyClass(X) лучше не применять кроме тех случаев, когдаабсолютно очевидно, что X действительно является наследником TMyClass ,например, если до этого тип класса был проверен с помощью оператора is :

if A is TMyClass then

(A as TMyClass).CallSomeMethodOfMyClass;

// вариант ниже - работает незначительно быстрее

if A is TMyClass then

TMyClass(A).CallSomeMethodOfMyClass;

4.3. Свойства

Свойства (Properties) являются "синтаксическим сахаром" (прим. перев.syntax sugar - жаргон, означающий синтаксические возможности, применение

28


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

1. Сделать что-то внешнее похожее на поле (может быть прочитано иустановлено), но реализовано вызовом функций считывания значения (getter)и установки значения (setter). Самое стандартное применение такого подхода- автоматическое выполннение дополнительных действий каждый раз, когданекоторое значение изменяется.

2. Сделать что-то внешне похожее на поле, но доступное только для чтения -нечто, похожее на константу или функцию без параметров.

type

TWebPage = class

private

FURL: string;

FColor: TColor;

function SetColor(const Value: TColor);

public

{ Значение URL невозможно установить напрямую.

Следует вызвать метод вроде Load('http://www.freepascal.org/'),

для загрузки страницы и установки значения этого свойства. }

property URL: string read FURL;

procedure Load(const AnURL: string);

property Color: TColor read FColor write SetColor;

end;

procedure TWebPage.Load(const AnURL: string);

begin

FURL := AnURL;

NetworkingComponent.LoadWebPage(AnURL);

end;

function TWebPage.SetColor(const Value: TColor);

begin

if FColor <> Value then

begin

FColor := Value;

{ Например, требовать обновления объекта, каждый раз,

когда изменяется значение его цвета:

Repaint;

{ Ещё пример: обеспечить чтобы нечто изменялось синхронно

с установкой цвета, например }

RenderingComponent.Color := Value;

29


end;

end;

Стоит обратить внимание, что вместо того, чтобы указать метод для чтенияили записи, можно напрямую указать читаемое/записываемое поле (котороеобычно является private и весьма часто имеет название идентичное property сдополнительным префиксом f (от field - поле)) чтобы непосредственно получатьили устанавливать значение. В примере выше, свойство Color используетsetter-метод SetColor . Однако, для получения значения свойство Color

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

При объявлении свойства указывается:

1. Может ли оно быть прочитано, и как (с помощью прямого чтения поля, или сиспользованием метода getter ).

2. Может ли оно быть установлено, и как (с помощью прямой записи поля, иливызовом метода setter ).

3. Имеет ли оно значение по умолчанию и какое (с помощью указания значенияпо умолчанию после ключевого слова default ).

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

С технической точки зрения, методы "getter" и "setter" - обычные методы и онимогут делать абсолютно что угодно (включая массу дополнительных функций).Всё же правилом хорошего тона является создание таких свойств, которые ведутсебя более-менее подобно обычному полю:

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

Следует отметить, что вполне нормально если выполнение getter имеет некиеневидимые последствия, например, сохранение в кеше результатов какого-

30


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

• Функция setter должна всегда устанавливать значение таким образом,чтобы getter вернул его же обратно. Не стоит автоматически отбрасыватьневерные значения "setter", а в случае, когда это необходимо, следуетвызвать exception. Также не желательно конвертировать или масштабироватьзапрашиваемое значение. Главная идея заключается в том, чтобы послеустановки MyClass.MyProperty := 123; можно было с уверенностьюсказать, что MyClass.MyProperty = 123 .

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

• Поле, к которому обращаются свойства почти всегда находится в разделеprivate, поскольку главная идея свойств - служить обёрткой и методом доступак нему.

• Технически, возможно создать свойства, которые только устанавливаютзначение, но не читают его. Впрочем, хороших примеров такой реализациилично мне ещё не встречалось :)

ПРИМЕЧАНИЕ: Свойства так же могут быть определены вне класса, на уровнеunit-а. Они служат аналогичной цели: они внешне выглядят как глобальныепеременные, но доступ к ним вызывает соответствующие функции getter и setter.

4.4. Исключения

В паскале можно вызывать и использовать исключения. Их можно "ловить" спомощью конструкции try … except … end , также можно применять секцию"выполнить в конце" try … finally … end .


program MyProgram;

uses SysUtils;

31


type

TMyClass = class

procedure MyMethod;

end;


begin

if Random > 0.5 then

raise Exception.Create('Вызываем exception!');

end;

var

C: TMyClass;

begin

randomize;


try

C.MyMethod;


end.

Обратите внимание, что раздел finally будет выполнен даже в случае, есливыполнение будет прекращено командой Exit (из функции, процедуры илиметода), операторами Break или Continue (внутри тела цикла).

4.5. Уровни видимости

Как и в большинстве других объектно-ориентированных языков, в Паскалеимеются визуальные спецификаторы для ограничения "видимости" полей /методов / свойств.

Основные уровни видимости являются следующими:

public

предоставлен доступ из любого участка кода, включая код в других unit-ах.

private

доступен только в этом классе.

protected

доступен только в этом классе и всех его наследниках.

Краткое описание private и protected , данное выше, не полностью верно.Код в текущем unit-е может преодолевать эти границы, и получать доступ к

32


секции private и protected . Иногда это полезная особенность, позволяющаяреализовывать тесно связанные классы. В остальных же случаях следуетиспользовать strict private или strict protected для организацииполной недоступности данных методов, полей или свойств извне класса.Детальнее этот вопрос рассматривается в разделе Section 8.1, “Различие privateи strict private”.

По умолчанию, если видимость не указана явно, то она соответствует public .исключение составляют классы, которые объявляются при включённой директиве{$M+} , либо наследники классов, которые были скомпилированы при {$M+} , что включает в себя всех потомков TPersistent , включая потомковTComponent , который сам является потомком TPersistent . Для такихклассов по умолчанию видимость принимается published , которая подобнаpublic , однако позволяет работать с ними с помощью потоковой (stream)системы.

Однако, не каждому типу поля или свойства позволено быть в секцииpublished - не каждый тип может быть конвертирован в поток (stream), и лишьклассы, состоящие из простых полей, могут передаваться потоком. Если нетнеобходимости создавать потоки, но нужно просто сделать что-то доступное длявсех пользователей, то следует использовать public .

4.6. Предок по умолчанию

Если явно не объявить родительский класс, то по умолчанию каждый classнаследует TObject .

5. Освобождение памяти классов

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

Чтобы избежать утечек памяти, все экземпляры класса должны бытьосвобождены вручную. Хорошей практикой является использование опциикомпилятора FPC -gl -gh, чтобы обнаруживать утечки памяти (более подробно см.http://castle-engine.sourceforge.net/tutorial_optimization.php#section_memory ).

Следует обратить внимание, что это не касается вызванных исключений (raisedexceptions). Не смотря на то, что при вызове исключения действительносоздаётся класс (и это вполне обычный класс, для этих целей также можносоздавать и свои классы), такой экземпляр класса освобождается автоматически.

33

http://castle-engine.sourceforge.net/tutorial_optimization.php#section_memory


5.2. Каким образом освобождать память

Самым удобным методом освобождения класса является операцияFreeAndNil(A) из unit-а SysUtils вызванная для данного экземпляракласса. Она проверяет, не имеет ли A значение nil , и если нет — вызываетего деструктор (destructor), и устанавливает значение A в nil . Таким образомповторный вызов данной процедуры не приведёт к ошибке.

Приблизительно это соответствует следующему:

if A <> nil then

begin

A.Destroy;

A := nil;

end;

Впрочем, эта аналогия немного упрощена, поскольку процедура FreeAndNilсовершает ещё одно полезное действие, сразу устанавливая A значение nil дотого как будет вызван destructor данного класса. Это позволяет избежать целойгруппы ошибок благодаря тому, что "внешний" код не сможет случайно получитьдоступ к не до конца уничтоженному экземпляру класса.

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

if A <> nil then

A.Destroy;

Т.е. освобождает класс A , если он не равен nil .

Стоит отметить, что в нормальных условиях никогда не стоит вызывать методкласса, ссылка на который может оказаться nil . По этому A.Free можетвыглядеть подозрительно на первый взгляд, поскольку A вполне может иметьзначение nil . Однако, метод Free является исключением из этого правила.Это выглядит немного "грязновато" — а именно, выполняется проверка Self <>nil . Такой фокус работает только для не-виртуальных методов (т.е. в случае,если не вызываются виртуальные методы и не требуется доступ к полям класса).

По этому лучше всегда использовать FreeAndNil(A) , без исключений, иникогда не использовать метод Free или напрямую деструктор Destroy . Такойконцепции придерживается Castle Game Engine. Это позволяет быть уверенным,

34


что все ссылки либо равны nil , либо указывают на существующий рабочийэкземпляр класса.

5.3. Ручное и автоматическое освобождение памяти

Во многих ситуациях, освобождение экземпляра класса не является чем-тосложным. Просто пишется destructor, как пара соответствующему constructor-у, иосвобождает все объекты, память для которых была выделена в constructor-е (а,точнее, в продолжении всего времени существования класса). Важно следить затем, чтобы освобождать каждый объект лишь один раз. Хорошей практикой будетвсегда присваивать освобождённой ссылке значение nil , а наиболее удобносделать это, вызвав команду FreeAndNil(A) .

Например:

uses SysUtils;

type

TGun = class

end;

TPlayer = class

Gun1, Gun2: TGun;

constructor Create;

destructor Destroy; override;

end;

constructor TPlayer.Create;

begin

inherited;

Gun1 := TGun.Create;


end;

destructor TPlayer.Destroy;

begin

FreeAndNil(Gun1);

FreeAndNil(Gun2);

inherited;

end;

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

35


которая называется "owner" (владение дочерним объектом). Объект у которогоесть owner (владелец) будет автоматически освобождён его owner-ом. Механизмочень гибкий и никогда не освобождает объекты, которые уже освобождены, т.е.всё будет работать правильно и для несозданных объектов, и для освобождённыхранее. Таким образом предыдущий пример можно переписать следующимобразом:

uses SysUtils, Classes;

type

TGun = class(TComponent)

end;

TPlayer = class(TComponent)

Gun1, Gun2: TGun;

constructor Create(AOwner: TComponent); override;

end;

constructor TPlayer.Create(AOwner: TComponent);

begin

inherited;

Gun1 := TGun.Create(Self);

Gun2 := TGun.Create(Self);

end;

Следует обратить внимание, что также необходимо override виртуальныйconstructor от TComponent . Это, в свою очередь, означает, что нельзя изменятьпараметры constructor-а. Впрочем, всё-таки это возможно — объявив новыйconstructor с ключевым словом reintroduce . Однако здесь стоит бытьосторожным, так как некоторый функционал, например, streaming, всё равнобудет использовать виртуальный constructor, по этому следует удостовериться,что во всех возможных случаях всё будет работать корректно.

Ещё один удобный механизм автоматического освобожденияпамяти — функционал OwnsObjects (который по умолчанию равен true )классов-списков, таких, как TFPGObjectList или TObjectList . Т.е. можносделать следующим образом:

uses SysUtils, Classes, FGL;

type

TGun = class

36


end;

TGunList = specialize TFPGObjectList<TGun>;

TPlayer = class

Guns: TGunList;

Gun1, Gun2: TGun;

constructor Create;


end;


begin

inherited;

// Вообще говоря, параметр OwnsObjects и так true по умолчанию

Guns := TGunList.Create(true);


Guns.Add(Gun1);


Guns.Add(Gun2);

end;


begin

{ Здесь достаточно освободить сам список.

Он сам автоматически освободит всё содержимое. }

FreeAndNil(Guns);

{ Таким образом нет нужды освобождать Gun1, Gun2 отдельно. Правда,

хорошей

практикой будет теперь установить значение "nil" соответствующим

значениям

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

В этом простом классе с простым destructor-ом, очевидно,

что к ним не произойдёт доступа, однако в случае сложных destructor-ов

это может оказаться полезно.

Альтернативно, можно избежать объявления Gun1 и Gun2 отдельно

и использовать напрямую Guns[0] и Guns[1] в коде.

Можно также создать метод Gun1, который возвращает ссылку на

Guns[0]. }

Gun1 := nil;

Gun2 := nil;

inherited;

end;

37


Заметим, что механизм owner-ов классов-списков простой (без дополнительныхпроверок) и, в случае освобождения содержащегося в списке экземпляра классасторонним кодом, впоследствии возникнет ошибка. Чтобы исключить что-либоиз списка без освобождения используется метод Extract , однако это такжеозначает, что в дальнейшем элемент придётся освободить вручную.

Например, в Castle Game Engine все наследники класса TX3DNode

автоматически управляют памятью при добавлении другой TX3DNode в списокchildren. Корневая X3DNode называется TX3DRootNode и, в свою очередь,обычно имеет своим owner-ом класс TCastleSceneCore . Другие объекты такжеимеют простой механизм owner-а — обычно это обозначено параметром илисвойством под названием вида OwnsXxx .

5.4. Free notification

Если на экземпляр класса создано несколько ссылок, это эквивалентно тому,что две ссылки указывают на одну и ту же область памяти. Если освободитьодну из них, вторая окажется "болтающимся" pointer-ом. Нельзя пытатьсяполучить доступ к области памяти, которая была освобождена. Это можетпривести к runtime ошибке, либо может быть получено неопределённое значение("мусор") — в случае, если эта область памяти уже была повторно выделена длядругих элементов внутри текущей программы.

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

var

Obj1, Obj2: TObject;

begin

Obj1 := TObject.Create;

Obj2 := Obj1;

FreeAndNil(Obj1);

// что произойдёт, если попытаться получить доступ к объекту Obj1 или

Obj2?

end;

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

38


использовать проверку if Obj1 <> nil then … чтобы случайно не вызватьметод уже освобождённого экземпляра класса, например:

if Obj1 <> nil then

Writeln(Obj1.ClassName);

Попытка доступа к ссылке nil на экземпляр класса приведёт кпредсказуемой и понятной ошибке. Таким образом, даже если код не будетпроверять Obj1 <> nil , и попытается вслепую получить доступ к Obj1 ,возникнет достаточно ясное сообщение об ошибке.

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

2. Ситуация с Obj2 — куда сложнее. Её значение не nil , однако оно ужеошибочно. Попытка доступа к не- nil ссылки на несуществующий экземпляркласса приводит к непредсказуемому результату — это может быть и ошибкаaccess violation, а может и просто какое-то случайное значение.

К решению такой проблемы есть несколько путей:

• Первое решение - внимательно читать документацию к объекту. Непредполагать ничего о длительности жизни ссылки, если она создана чужимкодом. Если в классе TCar есть поле wheel , указывающее на экземпляркласса типа TWheel , то есть правило что ссылка на wheel верна, покасуществует класс car , и сам car освободит все его wheel используясвой destructor. Но это правило не всегда возможно выполнить. В болеесложных случаях, в документации следует сделать упоминание о том, что икак происходит со ссылками.

• В примере выше, сразу после освобождения экземпляра класса Obj1 , можнопросто вручную установить Obj2 значение nil . В данном конкретномпримере тривиально.

• Однако, наиболее перспективным решением будет применение специальногомеханизма класса TComponent под названием "free notification" (извещениеоб освобождении). Таким образом один компонент может получить извещениев случае освобождения одной из компонент, и далее установить ссылку на неёв nil .

39


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

Для этого оба класса должны наследовать TComponent . Обычно это сводитсяк использованию FreeNotification , RemoveFreeNotification , иoverride Notification .

Следующий пример демонстрирует как использовать этот подход вместе сconstructor-ом / destructor-ом и setter-ом. Иногда можно всё сделать намногопроще, но здесь демонстрируется полномасштабная версия, которая будетверной в любом случае.

type

TControl = class(TComponent)

end;

TContainer = class(TComponent)

private

FSomeSpecialControl: TControl;

procedure SetSomeSpecialControl(const Value: TControl);

protected

procedure Notification(AComponent: TComponent; Operation:

TOperation); override;

public


property SomeSpecialControl: TControl

read FSomeSpecialControl write SetSomeSpecialControl;

end;

implementation

procedure TContainer.Notification(AComponent: TComponent; Operation:

TOperation);

begin

inherited;

if (Operation = opRemove) and (AComponent = FSomeSpecialControl) then

{ установить значение nil для SetSomeSpecialControl чтобы всё

аккуратно подчистить }

SomeSpecialControl := nil;

end;

procedure TContainer.SetSomeSpecialControl(const Value: TControl);

40


begin

if FSomeSpecialControl <> Value then

begin

if FSomeSpecialControl <> nil then

FSomeSpecialControl.RemoveFreeNotification(Self);

FSomeSpecialControl := Value;

if FSomeSpecialControl <> nil then

FSomeSpecialControl.FreeNotification(Self);

end;

end;

destructor TContainer.Destroy;

begin

{ Установить значение nil для SetSomeSpecialControl, чтобы запустить

notification про освобождение памяти }

SomeSpecialControl := nil;

inherited;

end;

6. Run-time library

6.1. Ввод/вывод с помощью потоков

Для ввода / выода в современных программах на Паскале используется классTStream . У него также есть множество полезных производных классов, такихкак TFileStream , TMemoryStream , TStringStream и т.п.



var

S: TStream;

InputInt, OutputInt: Integer;

begin

InputInt := 666;

S := TFileStream.Create('my_binary_file.data', fmCreate);

try

S.WriteBuffer(InputInt, SizeOf(InputInt));

finally FreeAndNil(S) end;

S := TFileStream.Create('my_binary_file.data', fmOpenRead);

try

S.ReadBuffer(OutputInt, SizeOf(OutputInt));

41


finally FreeAndNil(S) end;

Writeln('Из файла прочитано целое число: ', OutputInt);

end.

В Castle Game Engine следует использовать метод Download для созданияпотока, который оперирует ресурсами (это могут быть файлы, данные, скачанныес URL или Android assets). Более того, для однозначного кросс-платформенногоуказания на папку игровых данных (обычно это под-папка data ) следуетиспользовать функцию ApplicationData .

EnableNetwork := true;

S := Download('http://castle-engine.sourceforge.net');

S := Download('file:///home/michalis/my_binary_file.data');

S := Download(ApplicationData('gui/my_image.png'));

Чтобы прочитать обычный текстовый файл лучше использовать классTTextReader из CastleClassUtils . Он предоставляет построчный API,как надстройку над TStream . URL можно задать через конструктор классаTTextReader , либо можно передать ему готовый TStream вручную.

Text := TTextReader.Create(ApplicationData('my_data.txt'));

while not Text.Eof do

WritelnLog('NextLine', Text.ReadLine);

6.2. Списки

Для создания различных списков переменной длинны, лично я советуюиспользовать generic классы из unit-а FGL . Можно использовать TFPGListдля простых типов данных (включая record-ы или устаревшие object-ы), иTFPGObjectList для списка экземпляров классов. В Castle Game Engine:можно также использовать TGenericStructList из CastleGenericListsдля создания списков record-ов или устаревших object-ов. Это позволяет обойтипроблему невозможности override их операторов в старых версиях FPC.

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

42


сортировка, итерация и т.п. Вообще говоря, не стоит использовать динамическиемассивы ( array of X , SetLength(X, …) ) поскольку их API очень неудобный -можно применить лишь SetLength . Также не желательно использовать TListили TObjectList поскольку это потребует преобразование типа из общегоTObject в конкретный тип класса при каждом обращении.

6.3. Клонирование классов: TPersistent.Assign

Стандартным подходом для создания копии экземпляра класса являетсянаследование этим классом TPersistent с последующим override его методаAssign . Здесь нет ничего сложного, просто нужно в методе Assign прописатькопирование полей, которые Вам необходимы.

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



type

TMyClass = class(TPersistent)

public

MyInt: Integer;

procedure Assign(Source: TPersistent); override;

end;


public

MyString: string;


end;

procedure TMyClass.Assign(Source: TPersistent);

var

SourceMyClass: TMyClass;

begin

if Source is TMyClass then

begin

SourceMyClass := TMyClass(Source);

MyInt := SourceMyClass.MyInt;

// Xxx := SourceMyClass.Xxx; // добавить необходимые поля здесь

end else

43


{ Вызываем inherited ТОЛЬКО если не получается вручную обработать

Source }

inherited Assign(Source);

end;

procedure TMyClassDescendant.Assign(Source: TPersistent);

var

SourceMyClassDescendant: TMyClassDescendant;

begin

if Source is TMyClassDescendant then

begin

SourceMyClassDescendant := TMyClassDescendant(Source);

MyString := SourceMyClassDescendant.MyString;

// Xxx := SourceMyClassDescendant.Xxx; // добавить необходимые поля

здесь

end;

{ ВСЕГДА вызываем inherited, чтобы TMyClass.Assign сама обработала

все остающиеся поля. }

inherited Assign(Source);

end;

var

C1, C2: TMyClass;

CD1, CD2: TMyClassDescendant;

begin

// тестируем TMyClass.Assign

C1 := TMyClass.Create;


try

C1.MyInt := 666;

C2.Assign(C1);

Writeln('C2 состояние: ', C2.MyInt);

finally

FreeAndNil(C1);

FreeAndNil(C2);

end;

// тестируем TMyClassDescendant.Assign

CD1 := TMyClassDescendant.Create;

CD2 := TMyClassDescendant.Create;

try

CD1.MyInt := 44;

CD1.MyString := 'что-нибудь';

CD2.Assign(CD1);

Writeln('CD2 состояние: ', CD2.MyInt, ' ', CD2.MyString);

44


finally

FreeAndNil(CD1);

FreeAndNil(CD2);

end;

end.

Иногда более удобно написать альтернативный override метода AssignTo вкопируемом классе, а не делать override метода Assign в классе, в которыйвыполняется копирование.

Следует быть осторожным с inherited при написании Assign . Inherited изTPersistent.Assign должен вызываться исключительно в случаях, если Выне можете самостоятельно выполнить копирование в своём коде (это позволитиспользовать метод AssignTo и создавать сообщения об ошибках, в случае,если копирование не может быть выполнено). С другой стороны, если данныйкласс является производным от класса, в котором уже есть метод Assign , то вданном случае следует обязательно вызывать inherited из TMyClass.Assign .См. пример выше.

Примечание: Обратите внимание, что наследуя класс TPersistent поумолчанию видимость полей становится published , чтобы дать возможностьпереводить в поток (streaming) производные от TPersistent классы. Однако,не все типы полей и свойств разрешены в секции published . Если возникаютсвязанные с этим ошибки и нет необходимости передавать эти данные в поток,просто вручную измените уровень видимости на public . Детальнее см. разделSection 4.5, “Уровни видимости”.

7. Различные полезные возможности языка

7.1. Местные (вложенные) процедуры

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

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

45


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

Данные два примера абсолютно эквивалентны:

procedure SumOfSquares(const N: Integer): Integer;

function Square(const Value: Integer): Integer;

begin

Result := Value * Value;

end;

var

I: Integer;

begin

Result := 0;

for I := 0 to N do

Result := Result + Square(I);

end;

И второй вариант, в котором Square получает прямой доступ к переменной I :

procedure SumOfSquares(const N: Integer): Integer;

var

I: Integer;

function Square: Integer;

begin

Result := I * I;

end;

begin

Result := 0;

for I := 0 to N do

Result := Result + Square;

end;

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

46


7.2. Колбэки — они же события, они же указатели на

функции, они же процедурные переменные

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

Колбэки могут быть:

• Обычными, что означает, что они могут указывать на любую нормальнуюфункцию (т.е. не на метод или локальную функцию)


function Add(const A, B: Integer): Integer;

begin

Result := A + B;

end;

function Multiply(const A, B: Integer): Integer;

begin

Result := A * B;

end;

type

TMyFunction = function (const A, B: Integer): Integer;

function ProcessTheList(const F: TMyFunction): Integer;

var

I: Integer;

begin

Result := 1;

for I := 2 to 10 do

Result := F(Result, I);

end;

var

SomeFunction: TMyFunction;

begin

SomeFunction := @Add;

Writeln('1 + 2 + 3 ... + 10 = ', ProcessTheList(SomeFunction));

47


SomeFunction := @Multiply;

Writeln('1 * 2 * 3 ... * 10 = ', ProcessTheList(SomeFunction));

end.

• Указывающими на метод: для этого в конце добавляется of object .


uses SysUtils;

type

TMyMethod = procedure (const A: Integer) of object;

TMyClass = class

CurrentValue: Integer;

procedure Add(const A: Integer);

procedure Multiply(const A: Integer);

procedure ProcessTheList(const M: TMyMethod);

end;

procedure TMyClass.Add(const A: Integer);

begin

CurrentValue := CurrentValue + A;

end;

procedure TMyClass.Multiply(const A: Integer);

begin

CurrentValue := CurrentValue * A;

end;

procedure TMyClass.ProcessTheList(const M: TMyMethod);

var

I: Integer;

begin

CurrentValue := 1;

for I := 2 to 10 do

M(I);

end;

var

C: TMyClass;

begin


try

C.ProcessTheList(@C.Add);

Writeln('1 + 2 + 3 ... + 10 = ', C.CurrentValue);

48


C.ProcessTheList(@C.Multiply);

Writeln('1 * 2 * 3 ... * 10 = ', C.CurrentValue);


end.

Следует заметить, что невозможно передать обычные процедуры или функциикак методы. Они несовместимы. Если Вам необходимо использовать колбэкof object , но не хотите создавать экземпляр-пустышку для класса, естьвозможность передавать Section 8.2, “Class method” в качестве метода.

type

TMyMethod = function (const A, B: Integer): Integer of object;

TMyClass = class

class function Add(const A, B: Integer): Integer

class function Multiply(const A, B: Integer): Integer

end;

var

M: TMyMethod;

begin

M := @TMyClass(nil).Add;

M := @TMyClass(nil).Multiply;

end;

К сожалению, в данном случае приходится писать громоздкую конструкцию@TMyClass(nil).Add , а не просто @TMyClass.Add .

• Может указывать на локальную процедуру: для этого её нужно объявитьс is nested в конце, а также установить директиву {$modeswitch

nestedprocvars} для данного участка кода. Детальнее см. Section 7.1,“Местные (вложенные) процедуры”.

7.3. Generic-и

Generic-и - это очень мощная функция современных языков. Определение чего-либо (обычно - класса) может быть конкретизировано другим типом. Наиболееестественным примером является необходимость создать контейнер (список,словарь, дерево, граф…): можно определить список типа T, а потом specialize(конкретизировать) его чтобы сразу получить список из integer, список из string,список из TMyRecord и т.д.

49


Generic-и в Паскале реализованы весьма подобно generic-ам в C++. Это означает,что они "конкретизируются" когда происходит specialize, что немного похоже наповедение макросов (однако, когда тип "конкретизирован", используются толькоэти конкретные определения, и таким образом невозможно "добавить" какое-либонеожиданное поведение в generic после его "конкретизации"). Преимуществомих является высокая скорость выполнения (оптимизированная для каждогоконкретного типа) и поддержка типов любого размера. Можно использоватьпримитивные типы (integer, float) а также record, class и т.п. при specialize данногоgeneric-а.


uses SysUtils;

type

generic TMyCalculator<T> = class

Value: T;

procedure Add(const A: T);

end;

procedure TMyCalculator.Add(const A: T);

begin

Value := Value + A;

end;

type

TMyFloatCalculator = specialize TMyCalculator<Single>;

TMyStringCalculator = specialize TMyCalculator<string>;

var

FloatCalc: TMyFloatCalculator;

StringCalc: TMyStringCalculator;

begin

FloatCalc := TMyFloatCalculator.Create;

try

FloatCalc.Add(3.14);

FloatCalc.Add(1);

Writeln('Сложение величин типа Float: ', FloatCalc.Value:1:2);

finally FreeAndNil(FloatCalc) end;

StringCalc := TMyStringCalculator.Create;

try

StringCalc.Add('что-нибудь');

StringCalc.Add(' ещё');

Writeln('Сложвнеие величин типа String: ', StringCalc.Value);

50


finally FreeAndNil(StringCalc) end;

end.

Возможности generic-ов не ограничиваются классами, можно создать genericфункции и процедуры:


uses SysUtils;

{ Примечание: этот пример требует FPC 3.1.1 и не скомпилируется в FPC

3.0.0 или более ранних версиях. }

generic function Min<T>(const A, B: T): T;

begin

if A < B then

Result := A else

Result := B;

end;

begin

Writeln('Min (1, 0): ', specialize Min<Integer>(1, 0));

Writeln('Min (3.14, 5): ', specialize Min<Single>(3.14, 5):1:2);

Writeln('Min (''a'', ''b''): ', specialize Min<string>('a', 'b'));

end.

7.4. Overload

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

По умолчанию overload использует стиль FPC. Это означает, что абсолютновсе имена в пространстве имён (в классе или unit-е) равны, и скрывает всеостальные методы в пространстве имён с более низким приоритетом. Например,если создать класс с методом Foo(Integer) и Foo(string) , и при этомкласс наследует класс в котором уже есть Foo(Float) , то метод Foo(Float)невозможно будет вызвать напрямую, только с помощью приведения типаданного класса к родительскому классу. Чтобы избежать такого поведения,при объявлении процедур и функций следует использовать ключевое словоoverload .

51


7.5. Предобработка кода

Можно использовать простые директивы предобработки кода с целью:

• компиляции на основании различных условий (например, если код зависит отплатформы, или других заданных вручную параметров),

• чтобы включить один файл внутри другого,

• для вызова беспараметрических макросов.

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


unit PreprocessorStuff;

interface

{$ifdef FPC}

{ всё что идёт внутри данного условия ifdef определено только для FPC, а

не других компиляторов (например, Delphi). }

procedure Foo;

{$endif}

{ Определить константу NewLine. Это пример того, как "нормальный"

синтаксис Паскаля "поломан" директивами предобработки.

Если компилировать на Unix-системах (включая Linux, Android, Mac OS X),

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

const NewLine = #10;

Если компилировать на Windows, компилятор увидит так:

const NewLine = #13#10;

Однако, на других операционных системах, код не скомпилируется,

поскольку компилятор увидит следующее:

const NewLine = ;

Вообще, это *хорошо* что в данном случае возникает ошибка -- если

возникнет

52


необходимость портировать программу на другую операционную систему,

которая не является ни Unix, ни Windows, то компилятор "напомнит", что

необходимо выбрать правильное значение NewLine для такой системы. }

const

NewLine =

{$ifdef UNIX} #10 {$endif}

{$ifdef MSWINDOWS} #13#10 {$endif} ;

{$define MY_SYMBOL}

{$ifdef MY_SYMBOL}

procedure Bar;

{$endif}

{$define CallingConventionMacro := unknown}

{$ifdef UNIX}

{$define CallingConventionMacro := cdecl}

{$endif}

{$ifdef MSWINDOWS}

{$define CallingConventionMacro := stdcall}

{$endif}

procedure RealProcedureName;

CallingConventionMacro; external 'some_external_library';

implementation

{$include some_file.inc}

// $I это удобное сокращение от $include, они идентичны

{$I some_other_file.inc}

end.

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

• Включаемый файл может содержать лишь другие директивы компилятора,которые "конфигурируют" исходный код программы. Например, можно создатьфайл myconfig.inc со следующим содержанием:

{$mode objfpc}

{$H+}

{$J-}

{$modeswitch advancedrecords}

53


{$ifndef VER3}

{$error Этот код может быть скомпилирован только в версии FPC не ниже

3.x.}

{$endif}

Теперь можно включить этот файл {$I myconfig.inc} в каждом unit-еисходного кода.

• Второй важный пример использования - разделить unit на несколько файлов,и при этом всё же оставить его одним unit-ом (с учётом всех особенностейПаскаля). Не стоит злоупотреблять таким подходом. В первую очередь стоитдумать о том, как разделить программу на несколько unit-ов, а не разделятьеё на множество include файлов. Однако, в общем, это довольно полезная иудобная техника.

1. Такой подход позволяет избежать огромного количества unit-ов, и приэтом исходные файлы не окажутся слишком длинными. Например, кудаудобнее иметь один файл с "часто используемыми GUI элементами", чемсоздавать отдельные unit-ы для каждого GUI элемента", поскольку второйвариант сделает обычную "uses" неоправданно длинной (поскольку в GUI-приложении будут использоваться множество GUI элементов). Однако,размещение всех этих классов в одном файле myunit.pas приведёт кего большому размеру, что в свою очередь затруднит навигацию по файлу.Таким образом, разбить этот файл на несколько include файлов будетразумным.

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

{$ifdef UNIX} {$I my_unix_implementation.inc} {$endif}

{$ifdef MSWINDOWS} {$I my_windows_implementation.inc} {$endif}

Иногда это более удобно, чем писать длинный код со множеством{$ifdef UNIX} , {$ifdef MSWINDOWS} вперемешку с нормальнымкодом (определение переменных, описание процедур). Повышается ичитабельность кода. Эту технику можно применять более агрессивно,используя опцию командной строки -Fi при вызове FPC, чтобывключить целые папки только для конкретных платформ. Таким образомможно организовать множество версий include файлов типа {$I my

54


platform_specific_implementation.inc} . При этом компиляторавтоматически найдёт правильную версию.

7.6. Record

Record является своеобразным контейнером для других переменных. Онаявляется очень, очень упрощённым классом: в record-ах нет наследования, нетвиртуальных методов. Они несколько подобны structure в C-подобных языках.

Применяя директиву {$modeswitch advancedrecords} , появляетсявозможность добавить методы и уровни видимости в record и использоватьлюбые особенности языка, доступные классам, которые не нарушают простуюи предсказуемую раскладку памяти для record.



type

TMyRecord = record

public

I, Square: Integer;

procedure WritelnDescription;

end;

procedure TMyRecord.WritelnDescription;

begin

Writeln('Квадрат числа ', I, ' равен ', Square);

end;

var

A: array [0..9] of TMyRecord;

R: TMyRecord;

I: Integer;

begin

for I := 0 to 9 do

begin

A[I].I := I;

A[I].Square := I * I;

end;

for R in A do

R.WritelnDescription;

end.

55


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

• Record-ам не требуется constructor или destructor. Они определяются какпеременные. Их содержимое не определено в начале (так называемый "мусорв памяти"), кроме случаев автоматически управляемых типов, таких какstring, которые всегда инициализируются пустыми. Таким образом следуетбыть более аккуратным при их использовании, однако преимуществом такогоподхода будет увеличение скорости исполнения программы.

• Массивы, состоящие из record-ов однородно располагаются в памяти и такимобразом их удобно кешировать.

• Разметка памяти (размер и расстояние между каждым полем) для record-овчётко определена в некоторых ситуациях: когда запрашивается C layout илиесли используется packed record . Это может быть полезным в следующихслучаях:

◦ для связи между библиотеками, написанными в других языкахпрограммирования и предоставляющих API, который основывается наданных типа record,

◦ для чтения и записи бинарных файлов,

◦ для выполнения "грязных" низкоуровневых оптимизаций (как небезопасноеприведение одного типа в другой, на основании их однозначногопредставления в памяти).

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

7.7. Устаревшие object

Давным-давно, в Turbo Pascal был введён новый тип синтаксиса с функционалом,похожим на классы, который задавался ключевым словом object . По сути, это- нечто среднее между record и современным class .

56


• Такие object-ы можно создавать / освобождать, и в процессе этого можновызвать их constructor / destructor.

• Но их можно просто объявить и использовать как обычную record. Простыетипы record или object не являются указателями (pointer-ами) на что-либо, они, собственно, являются данными. Это делает их весьма удобными вслучаях небольших объёмов информации, когда многократное распределениеили освобождение памяти не всегда оправдано.

• Устаревшие object-ы имеют наследование и виртуальные методы, впрочем,в несколько отличном виде от современных классов. Следует бытьвнимательным: если попытаться использовать object, имеющий виртуальныеметоды, без вызова его constructor-а, могут возникнуть ошибки.

В большинстве случаев крайне не советуется использовать устаревшие objects-ы. Современные class-ы имеют гораздо более широкий функционал. А в случаеесли необходимо повысить скорость выполнения, можно использовать record-ы (включая advanced records). Такие подходы обычно лучше, чем устаревшиеobject-ы.

7.8. Pointer-ы

В Паскале возможно создать pointer (указатель) на любой тип данных. Указательна тип TMyRecord определяется с помощью синтаксиса ^TMyRecord , и чащевсего такие pointer-ы называют PMyRecord . В качестве классического примерарассмотрим связанный список целых чисел, организованный с помощью record:

type

PMyRecord = ^TMyRecord;

TMyRecord = record

Value: Integer;

Next: PMyRecord;

end;

Следует обратить внимание, что здесь было использовано рекурсивноеопределение (тип PMyRecord определяется с помощью TMyRecord , аTMyRecord использует в своём определении PMyRecord ). Можно определитьpointer на тип, который ещё не был объявлен, в том случае, если он будетопределён в том же самом блоке type .

Можно распределять и освобождать память для pointer-ов с помощью методовNew / Dispose , или (более низкоуровневых, но не типобезопасных) методов

57


GetMem / FreeMem . Для доступа к данным, на которые pointer указывает, посленего следует добавить оператор ^ (в виде PMyRecord^.Value ). Обратнаяоперация (получить pointer на существующую переменную) выполняется спомощью оператора-префикса @ (например, @myRecordVariable ).

Существует также самый общий тип Pointer , который не указывает наконкретный тип данных и подобен void* в C-подобных языках. Он совершенноне типобезопасен, и его можно привести его тип в любой другой тип pointer-а.

Следует помнить, что экземпляр класса также является pointer-ом, хоть дляработы с ним и не нужно использовать дополнительных операторов ^ и @ .Рекурсивные определения также возможны и для классов, и в данном случае всёбудет выглядеть ещё проще:

type

TMyClass = class

Value: Integer;

Next: TMyClass;

end;

7.9. Перегрузка операторов

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


uses StrUtils;

operator* (const S: string; const A: Integer): string;

begin

Result := DupeString(S, A);

end;

begin

Writeln('повтор' * 10);

end.

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

58



uses SysUtils;

type

TMyClass = class

MyInt: Integer;

end;

operator* (const C1, C2: TMyClass): TMyClass;

begin

Result := TMyClass.Create;

Result.MyInt := C1.MyInt * C2.MyInt;

end;

var

C1, C2: TMyClass;

begin


try

C1.MyInt := 12;

C2 := C1 * C1;

try

Writeln('12 * 12 = ', C2.MyInt);

finally FreeAndNil(C2) end;

finally FreeAndNil(C1) end;

end.

Можно перегружать и операции над record-ами. Обычно это проще, чем в случаеклассов, поскольку нет необходимости выполнять операции по распределениюили освобождению памяти.


uses SysUtils;

type

TMyRecord = record

MyInt: Integer;

end;

operator* (const C1, C2: TMyRecord): TMyRecord;

begin

Result.MyInt := C1.MyInt * C2.MyInt;

end;

59


var

R1, R2: TMyRecord;

begin

R1.MyInt := 12;

R2 := R1 * R1;

Writeln('12 * 12 = ', R2.MyInt);

end.

При работе с record-ами лучше использовать режим {$modeswitch

advancedrecords} и перегружать операторы в виде class operator

внутри объявления record-а. Такой подход позволяет использовать generic классыкоторые зависят от существования какого-либо оператора (например TFPGList ,который зависит от доступности оператора равенства). В противоположномслучае "глобальное" определение оператора (не внутри объявления даннойrecord) не будет найдено (поскольку оно не доступно коду, которыйиспользуется в TFPGList ), и не удастся specialize список в виде specializeTFPGList<TMyRecord> .



uses SysUtils, FGL;

type

TMyRecord = record

MyInt: Integer;

class operator+ (const C1, C2: TMyRecord): TMyRecord;

class operator= (const C1, C2: TMyRecord): boolean;

end;

class operator TMyRecord.+ (const C1, C2: TMyRecord): TMyRecord;

begin

Result.MyInt := C1.MyInt + C2.MyInt;

end;

class operator TMyRecord.= (const C1, C2: TMyRecord): boolean;

begin

Result := C1.MyInt = C2.MyInt;

end;

type

TMyRecordList = specialize TFPGList<TMyRecord>;

var

60


R, ListItem: TMyRecord;

L: TMyRecordList;

begin

L := TMyRecordList.Create;

try

R.MyInt := 1; L.Add(R);



R.MyInt := 0;

for ListItem in L do

R := ListItem + R;

Writeln('1 + 10 + 100 = ', R.MyInt);

finally

FreeAndNil(L);

end;

end.

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

8.1. Различие private и strict private

Спецификатор видимости private означает что поле или метод не доступныизвне данного класса. Однако из данного правила есть одно исключение: любойкод в данном unit-е может преодолеть это ограничение и иметь полный доступк private полям и методам. Программист на C++ сказал бы, что в Паскале всеклассы в одном unit-е являются "друзьями". Часто это весьма удобно.

Однако, при создании unit-ов большого размера со множеством не очень близкоинтегрированных классов, более безопасным является применение видимостиstrict private . Как можно легко догадаться, это означает что поле или методне доступны извне данного класса. Точка. Никаких исключений.

Таким же образом различаются спецификаторы видимости protected

(видимый наследникам данного класса или "друзьям" в том же unit-е) и strictprotected (видимы только и исключительно наследникам данного класса.Точка).

8.2. Class method

Существуют методы, которые можно вызвать из класса вообще ( TMyClass ), необязательно из его конкретного экземпляра.

61


type

TEnemy = class

procedure Kill;

class procedure KillAll;

end;

var

E: TEnemy;

begin

E := TEnemy.Create;

try

E.Kill;

finally FreeAndNil(E) end;

TEnemy.KillAll;

end;

Обратите внимание, что они также могут быть виртуальными — иногда это весьмаудобно, особенно, если применяется совместно с понятием Section 8.4, “Ссылкина класс”.

Следует отметить, что constructor всегда работает, как class method когдавызывается "обычным образом" ( MyInstance := TMyClass.Create(…

); ). Впрочем, можно вызвать конструктор в данном конкретном экземплярекласса как метод — и он тогда и сработает как обычный метод. Такимобразом можно сделать удобную "цепочку" constructor-ов, когда один constructor(например, перегруженный для принятия дополнительных параметров)выполняет определённый код, а затем вызывает другой constructor (например,беспараметрический).

8.3. Дополнительные возможности объявления классов и

локальные классы

Внутри определения класса можно создавать константы ( const ) илитипы ( type ). Таким образом можно даже создать класс внутри класса.Спецификаторы видимости будут работать как обычно, и такие локальные классымогут быть private (не видимые "внешнему миру"), что иногда удобно.

Следует обратить внимание, чтобы определить поле после константы или типабудет необходимо использовать блок var :

type

62


TMyClass = class

private

type

TInternalClass = class

Velocity: Single;

procedure DoSomething;

end;

var

FInternalClass: TInternalClass;

public

const

DefaultVelocity = 100.0;

constructor Create;


end;

constructor TMyClass.Create;

begin

inherited;

FInternalClass := TInternalClass.Create;

FInternalClass.Velocity := DefaultVelocity;

FInternalClass.DoSomething;

end;

destructor TMyClass.Destroy;

begin

FreeAndNil(FInternalClass);

inherited;

end;

{ Обратите внимание на префикс "TMyClass.TInternalClass." }

procedure TMyClass.TInternalClass.DoSomething;

begin

end;

8.4. Ссылки на класс

Ссылки на класс позволяют выбрать класс в процессе исполнения программы,например, для вызова class method-а или constructor-а не определив заранее,какой именно класс будет использоваться. Такой тип объявляется следующимобразом: class of TMyClass .

type

TMyClass = class(TComponent)

63


end;

TMyClass1 = class(TMyClass)

end;


end;

TMyClassRef = class of TMyClass;

var

C: TMyClass;

ClassRef: TMyClassRef;

begin

// Можно сделать так:

C := TMyClass.Create(nil); FreeAndNil(C);

C := TMyClass1.Create(nil); FreeAndNil(C);

C := TMyClass2.Create(nil); FreeAndNil(C);

// А с помощью ссылки на класс можно сделать следующим образом:

ClassRef := TMyClass;

C := ClassRef.Create(nil); FreeAndNil(C);

ClassRef := TMyClass1;




end;

Ссылки на класс можно комбинировать с виртуальными class method-ами.Работает это подобно классам с виртуальными методами — конкретный метод,который необходимо выполнить определяется уже в процессе выполненияпрограммы.

type


class procedure DoSomething; virtual; abstract;

end;


class procedure DoSomething; override;

64


end;


class procedure DoSomething; override;

end;


var

C: TMyClass;

ClassRef: TMyClassRef;

begin


ClassRef.DoSomething;



{ А следующая строка приведёт к ошибке выполнения,

поскольку DoSomething является abstract в TMyClass. }

ClassRef := TMyClass;


end;

Если есть экземпляр класса и необходимо создать ссылку на этот класс (нена какой-либо объявленный класс, а на конкретного наследника, который былиспользован при создании данного экземпляра класса), можно использоватьсвойство ClassType . Вообще говоря, объявленный тип ClassType являетсяTClass , который в свою очередь является class of TObject . Его тип можнопривести во что либо более конкретное, когда есть информация, чем именноявляется данный экземпляр.

ClassType также можно использовать для вызова виртуальных методов,включая виртуальные constructor-ы. Такой подход позволяет создать такиеметоды, как Clone которые создают экземпляр как точную копию данногокласса в конкретный момент исполнения программы. Можно совместить такойподход с Assign (см. Section 6.3, “Клонирование классов: TPersistent.Assign”)для того, чтобы метод возвращал новую, готовую к работе копию текущегоэкземпляра.

Следует обратить внимание, что подобный подход сработает только еслиconstructor данного класса виртуальный. Например, его можно использоватьс наследниками стандартного класса TComponent , поскольку все они

65


выполняют override виртуального constructor-а TComponent.Create(AOwner:TComponent) .

type



function Clone(AOwner: TComponent): TMyClass;

end;


function TMyClass.Clone(AOwner: TComponent): TMyClass;

begin

// Таким образом будет создан объект конкретного типа TMyClass:

//Result := TMyClass.Create(AOwner);

// А такой подход может создать объект как типа TMyClass, так и его

наследников:

Result := TMyClassRef(self.ClassType).Create(AOwner);

Result.Assign(Self);

end;

8.5. Class helper

Метод является лишь процедурой внутри конкретного класса. Извне классаон вызывается с помощью специального синтаксиса MyInstance.MyMethod(…) . И через некоторое время приходит привычка, что если нужно произвестидействие над классом X, следует писать X.Action(…) .

Однако, иногда возникает необходимость выполнить что-либо, что концептуальноявляется действием на класс TMyClass, однако при этом не изменяяисходный код TMyClass. Причин тому может быть несколько. Например, этоможет быть исходный код, написанный другим программистом, который неследует или невозможно изменять. Также иногда причиной тому могут бытьзависимости — добавление метода Render к классу TMy3DObject кажетсявполне логичным, однако, возможно, имплементация класса TMy3DObject

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

Наиболее простой путь сделать это - создать глобальную процедуру, котораябудет принимать ссылку на TMy3DObject как параметр.

66


procedure Render(const Obj1: TMy3DObject; const Color: TColor);

var

I: Integer;

begin

for I := 0 to Obj1.ShapesCount - 1 do

RenderMesh(Obj1.Shape[I].Mesh, Color);

end;

И это действительно сработает. Однако, недостаток такого подхода - он выглядитне очень красиво. Ведь обычно мы вызываем действия над объектом с помощьюX.Action(…) , а тут нам приходится использовать иной синтаксис: Render(X,…) . Было бы куда удобнее записать X.Render(…) , даже для случаев, когдаRender не описан в unit-е, в котором находится TMy3DObject .

Для этого и существуют class helper-ы, дающие возможность создать процедуры/функции, которые оперируют данным классом и вызываются таким же образом,как и остальные методы класса. Однако они не являются "обычными"методами — они "добавляются" извне определения класса TMy3DObject .

type

TMy3DObjectHelper = class helper for TMy3DObject

procedure Render(const Color: TColor);

end;

procedure TMy3DObjectHelper.Render(const Color: TColor);

var

I: Integer;

begin

{ Обратите внимание, мы получаем доступ к ShapesCount, Shape без

дополнительных указаний типа TMy3DObject.ShapesCount }

for I := 0 to ShapesCount - 1 do

RenderMesh(Shape[I].Mesh, Color);

end;

ПРИМЕЧАНИЕ: Более общая концепция является "type helper", используякоторую становится возможным добавлять методы даже к самым примитивнымтипам, например integer. Можно также создать "record helper" чтобы… ну,Вы поняли. Детальнее см. здесь: http://lists.freepascal.org/fpc-announce/2013-February/000587.html .

67

http://lists.freepascal.org/fpc-announce/2013-February/000587.html

http://lists.freepascal.org/fpc-announce/2013-February/000587.html


8.6. Виртуальные constructor-ы, destructor-ы

Имя destructor-а всегда должно быть Destroy , и он всегда является virtual(поскольку он вызывается без указания конкретного класса при компиляции) ибеспараметрический.

В качестве имени constructor-а принято использовать Create . Можноиспользовать и другое имя, однако здесь следует быть аккуратным — например,создав CreateMy , всегда создайте и Create , иначе constructor Create будетвсё равно доступен из родительского класса и может быть вызван в обходконкретного CreateMy конструктора.

В базовом классе TObject constructor не является виртуальным, и при созданиинаследников его можно изменить. Новый constructor просто спрячет constructorродительского класса (примечание: не используйте overload , в данном случаеэто не сработает).

В наследниках же класса TComponent , следует выполнять constructor

Create(AOwner: TComponent); override; . Для решения задач потоковойпередачи данных, а также для создания класса без указания конкретного типа принаписании программы, виртуальные constructor-ы являются очень удобными (см.раздел Section 8.4, “Ссылки на класс” выше).

8.7. Ошибки при исполнении constructor-а

Что произойдёт если в процессе выполнения constructor-а возникнет ошибка?Строка

X := TMyClass.Create;

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

В объектном Паскале существует следующее решение. Если возникла ошибкапри исполнении constructor-а, то сразу вызывается destructor. Именно по этойпричине этот destructor должен быть "дубовым", т.е. сработать в любом случае,даже на частично сконструированном классе. Обычно это не сложно, еслиосвобождать всё безопасным образом, например, с помощью FreeAndNil .

68


Также можно полагаться на факт, что перед вызовом constructor-а вся памятьгарантированно обнуляется. Таким образом, при создании все ссылки внутрикласса являются nil , а числа равны 0 и т.п.

Т.е. следующий код сработает без утечек памяти:


uses SysUtils;

type

TGun = class

end;

TPlayer = class

Gun1, Gun2: TGun;

constructor Create;


end;


begin

inherited;


raise Exception.Create('Вызваем exception из constructor-а!');


end;


begin

{ в данном случае в результате ошибки в constructor-е, у нас

может оказаться Gun1 <> nil и Gun2 = nil. Смиритесь.

В таком случае, FreeAndNil справится с задачей без каких-либо

дополнительных действий с нашей стороны, поскольку FreeAndNil

проверяет

является ли экземпляр класса nil перед вызовом соответствующего

destructor-а. }

FreeAndNil(Gun1);

FreeAndNil(Gun2);

inherited;

end;

begin

try

TPlayer.Create;

except

69


on E: Exception do

Writeln('Ошибка ' + E.ClassName + ': ' + E.Message);

end;

end.

9. Интерфейсы

9.1. Хорошие (CORBA) интерфейсы

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

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

Интерфейсы CORBA в Object Pascal работают в значительной степени так,как и интерфейсы в Java (https://docs.oracle.com/javase/tutorial/java/concepts/interface.html) или в C# (https://msdn.microsoft.com/en-us/library/ms173156.aspx).


{$interfaces corba}


type

IMyInterface = interface

['{79352612-668B-4E8C-910A-26975E103CAC}']

procedure Shoot;

end;

TMyClass1 = class(IMyInterface)

procedure Shoot;

end;

TMyClass2 = class(IMyInterface)

procedure Shoot;

end;

TMyClass3 = class

70

https://docs.oracle.com/javase/tutorial/java/concepts/interface.html

https://docs.oracle.com/javase/tutorial/java/concepts/interface.html

https://msdn.microsoft.com/en-us/library/ms173156.aspx


procedure Shoot;

end;

procedure TMyClass1.Shoot;

begin

Writeln('TMyClass1.Shoot');

end;


begin


end;


begin


end;

procedure UseThroughInterface(I: IMyInterface);

begin

Write('Стреляем... ');

I.Shoot;

end;

var

C1: TMyClass1;

C2: TMyClass2;

C3: TMyClass3;

begin

C1 := TMyClass1.Create;



try

if C1 is IMyInterface then

UseThroughInterface(C1 as IMyInterface);





finally

FreeAndNil(C1);

FreeAndNil(C2);

FreeAndNil(C3);

end;

end.

71


9.2. CORBA и COM интерфейсы

Почему интерфейсы названы "CORBA"?Название CORBA крайне неудачное. Куда лучший термин был бы обычныйинтерфейс. Такие интерфейсы являются "чистой особенностью языка".Их можно использовать, если возникает необходимость приведения типовразличных классов в виде одинакового интерфейса, поскольку у ниходинаковая API.

Не смотря на то, что эти интерфейсы могут использоваться совместнос технологией CORBA (Common Object Request Broker Architecture) (см.https://en.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture), онине имеют к ней никакого отношения.

Требуется ли задавать {$interfaces corba} ?Да, поскольку по умолчанию будут созданы COM интерфейсы. Последнееможно указать явно с помощью директивы {$interfaces com} , но необязательно, так как это случай по умолчанию.

Лично я не советую использовать COM интерфейсы. Особенно в случае, еслиВам знакомы интерфейсы из других языков программирования. ИнтерфейсыCORBA в Паскале — это именно то, что ожидается от интерфейсов, ониидентичны интерфейсам в C# и Java. При этом COM интерфейсы привносятдополнительные "особенности", которые, скорее всего, не понадобятся.

Обратите внимание, что {$interfaces xxx} определяеттолько интерфейсы, родительский интерфейс которых явно неуказан (лишь используется ключевое слово interface , а неinterface(ISomeAncestor) ). Если интерфейс имеет родительскийинтерфейс, он имеет такой же тип, как и родительский интерфейс и не зависитот директивы {$interfaces xxx} .

Что такое COM интерфейсы?Понятие COM интерфейс является синонимом понятия интерфейс,наследующий некоторый интерфейс IUnknown . Такое наследование отIUnknown :

• Требует, чтобы классы определяли методы _AddRef и _ReleaseRef .Правильная имплементация этих методов позволит управлять объектом спомощью подсчёта ссылок (reference-counting).

72

https://en.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture


• Добавляет метод QueryInterface .

• Позволяет взаимодействовать с технологией COM (Компонентная модельобъектов).

Почему я не советую использовать COM интерфейсы?Дополнительные возможности, привнесённые COM интерфейсами с моейточки зрения проблематичны. Не поймите превратно — идея reference-counting очень хороша. Однако переплетение такого функционала синтерфейсами (вместо того, чтобы делать их "поперечными" свойствами),на мой взгляд, является очень грязным. И явно не соответствует задачам,которые я встречал в своей практике.

• Иногда возникает необходимость передать обычные классы (не имеющиминичего общего) через обычный интерфейс.

• Иногда возникает желание управлять памятью с помощью технологииreference counting.

• Возможно когда-нибудь лично мне тоже пригодится COM технология.Но всё это - ничем не связанные задачи. Переплетать их в единойособенности языка, на мой личный взгляд, нехорошо. И это не просто вопросэстетики, такой подход причиняет реальные проблемы: механизм reference-counting интерфейса COM, даже если отключён с помощью специальныхимплементаций _AddRef и _ReleaseRef , всё равно может привести кошибкам. Придётся быть внимательным и следить, чтобы нигде не осталасьвременная ссылка на интерфейс после освобождения экземпляра класса.Чуть подробнее речь об этом пойдёт дальше.

Именно по этому, мой совет: всегда использовать интерфейс в стиле CORBAи соответствующую {$interfaces corba} директиву в современном коде,который работает с интерфейсами. На мой взгляд, COM интерфейсы этонекоторое "недоразумение" языка.

Однако, чтобы быть честными, чуть дальше будет детально идти речь и о COMинтерфейсах.

Можно ли использовать reference-counting совместно с интерфейсомCORBA?

Естественно. Необходимо лишь добавить методы _AddRef / _ReleaseRef .Нет необходимости наследовать интерфейс IUnknown . Впрочем, вбольшинстве случаев, если возникает необходимость использовать reference-counting в интерфейсах, можно просто использовать COM интерфейсы.

73


9.3. GUID-ы интерфейсов

GUID-ы это на первый взгляд случайная последовательность букв ицифр ['{ABCD1234-…}'] которую можно увидеть при каждом объявленииинтерфейса. В действительности, они и являются случайными. Но, к сожалению,в них есть необходимость. Никакого особого смысла в них не вкладывается(если не планируется интеграция с технологиями COM или CORBA). Однако, дляправильного исполнения программы они обязательны. И пусть не сбивает с толкукомпилятор, который, увы, позволяет создавать интерфейсы без GUID-ов.

Без присваивания (уникального) GUID-а, все интерфейсы будут идентичнымидля оператора is . Таким образом, он всегда будет возвращать true еслиданный класс поддерживает любой из используемых интерфейсов. "Волшебная"функция Supports(ObjectInstance, IMyInterface) работает нескольколучше в данном случае, поскольку выдаст ошибку компиляции для интерфейсовбез GUID. Это касается и CORBA, и COM интерфейсов, для версии FPC 3.0.0.

Таким образом, необходимо обязательно объявлять GUID для каждогоинтерфейса. Можно использовать встроенный генератор GUID-ов Lazarus GUIDgenerator (горячая клавиша Ctrl + Shift + G в режиме редактирования). Либовоспользоваться он-лайн сервисом, например https://www.guidgenerator.com/ .

А можно вообще написать свой инструмент, использующий CreateGUID иGUIDToString функции из RTL. Например, следующим образом:


uses SysUtils;

var

MyGuid: TGUID;

begin

Randomize;

CreateGUID(MyGuid);

Writeln('[''' + GUIDToString(MyGuid) + ''']');

end.

9.4. Некрасивые (COM) интерфейсы

Использование COM интерфейсов даёт две дополнительных возможности:

1. Интеграция с технологией COM (технология, которая используется в Windows,также доступна в Unix-системах через XPCOM, который применяется Mozilla),

74

https://www.guidgenerator.com/


2. Подсчёт ссылок - reference counting (что позволяет автоматическиосвобождать экземпляр класса, когда все ссылки на его интерфейс уходят изполя переменных).

На мой взгляд, неправильно переплетать интерфейсы с такими возможностями.Это усложняет использование интерфейсов для того, для чего онипредназначены: когда у многих классов один и тот же API, однако они не могутпроисходить от одного родительского класса. Используя же COM интерфейс,следует помнить о механизме автоматического уничтожения и его отношениик технологии COM.

На практике это означает следующее:

• В классе необходимо создать "волшебные" методы _AddRef , _Release иQueryInterface . Или наследовать класс, который уже имеет их. Конкретнаяимплеметация этих методов позволяет включить или отключить такуювозможность COM интерфейсов, как reference-counting. Впрочем, отключатьеё достаточно опасно — см. следующий подраздел.

◦ Стандартный класс TInterfacedObject имеет эти методывыполненными в таком виде, чтобы включить reference-counting.

◦ Стандартный класс TComponent имеет эти методы выполненнымив таком виде, чтобы выключить reference-counting. В CastleGame Engine предоставлены дополнительные классы, от которыхможно выполнять наследование: TNonRefCountedInterfacedObjectи TNonRefCountedInterfacedPersistent для этих целей,см. детальнее: https://github.com/castle-engine/castle-engine/blob/master/src/base/castleinterfaces.pas .

• Необходимо быть аккуратным при освобождении класса, когда на негомогут ссылаться некоторые переменные интерфейса. Поскольку интерфейсыосвобождаются с помощью виртуального метода (потому что он можетиспользовать reference-counting, даже если _AddRef написан такимобразом, чтобы отключить эту возможность), то нельзя освобождатьнизлежащий экземпляр класса из-за того, что какая-либо переменнаяинтерфейса может на него указывать. См. раздел "7.7 Reference counting" вруководстве FPC (http://freepascal.org/docs-html/ref/refse47.html).

Чтобы безопасно использовать COM интерфейсы необходимо

• осознавать факт, что в них используется reference-counting,

75

https://github.com/castle-engine/castle-engine/blob/master/src/base/castleinterfaces.pas

https://github.com/castle-engine/castle-engine/blob/master/src/base/castleinterfaces.pas

http://freepascal.org/docs-html/ref/refse47.html


• наследовать соответствующие классы от TInterfacedObject

• и избегать прямого обращения к экземпляру класса, вместо чего всегдаиспользовать экземпляр через интерфейс, оставляя алгоритму reference-counting управление освобождением памяти.

Ниже представлен пример использования такого интерфейса:


{$interfaces com}


type


['{3075FFCD-8EFB-4E98-B157-261448B8D92E}']

procedure Shoot;

end;

TMyClass1 = class(TInterfacedObject, IMyInterface)

procedure Shoot;

end;

TMyClass2 = class(TInterfacedObject, IMyInterface)

procedure Shoot;

end;

TMyClass3 = class(TInterfacedObject)

procedure Shoot;

end;


begin


end;


begin


end;


begin


end;

76



begin


I.Shoot;

end;

var

C1: IMyInterface; // COM управляет освобождением памяти

C2: IMyInterface; // COM управляет освобождением памяти

C3: TMyClass3; // Здесь управлять освобождением памяти придётся ВАМ

begin

C1 := TMyClass1.Create as IMyInterface;

C2 := TMyClass2.Create as IMyInterface;


try

UseThroughInterface(C1); // Нет необходимости в операторе "as"

UseThroughInterface(C2);


UseThroughInterface(C3 as IMyInterface); // Так не сработает

finally

{ Переменные C1 и C2 выходят из поля зрения

и будут автоматически уничтожены сейчас.

а переменная C3 является экземпляром класса

и не управляется интерфейсом,

и по этому её необходимо совободить вручную. }

FreeAndNil(C3);

end;

end.

9.5. Использование COM интерфейсов с отключённым

reference-counting

Как уже было упомянуто в прошлом разделе, в классах,наследующих TComponent (либо подобные классы, такие какTNonRefCountedInterfacedObject иTNonRefCountedInterfacedPersistent ) отключено reference-counting дляCOM интерфейсов. Это позволяет использовать COM интерфейсы и при этомдаёт возможность освобождать классы вручную.

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

77


что каждая операция приведения типа в виде Cx as IMyInterface такжесоздаёт временную переменную интерфейса, которая может существоватьвплоть до конца текущей процедуры. Этот пример иллюстрирует процедуруUseInterfaces , которая освобождает классы вне этой процедуры (когда мыможем быть уверены, что временная переменная интерфейса вышла из текущегополя переменных).

Чтобы избежать этих неудобств, лучше использовать интерфейсы CORBA, еслив данной программе нет необходимости параллельного использования reference-counting и интерфейсов.


{$interfaces com}


type


['{3075FFCD-8EFB-4E98-B157-261448B8D92E}']

procedure Shoot;

end;

TMyClass1 = class(TComponent, IMyInterface)

procedure Shoot;

end;

TMyClass2 = class(TComponent, IMyInterface)

procedure Shoot;

end;

TMyClass3 = class(TComponent)

procedure Shoot;

end;


begin


end;


begin


end;

78



begin


end;


begin


I.Shoot;

end;

var

C1: TMyClass1;

C2: TMyClass2;

C3: TMyClass3;

procedure UseInterfaces;

begin


//if Supports(C1, IMyInterface) then // эта строчка идентична проверке

"is" выше






end;

begin

C1 := TMyClass1.Create(nil);



try

UseInterfaces;

finally

FreeAndNil(C1);

FreeAndNil(C2);

FreeAndNil(C3);

end;

end.

9.6. Приведение типов интерфейсов без оператора "as"

Этот раздел касается как CORBA, так и COM интерфейсов.

79


Приведение типа интерфейса через оператор as выполняет проверку в режимеисполнения. Рассмотрим пример:

UseThroughInterface(Cx as IMyInterface);

Этот вариант скомпилируется для всех экземпляров C1 , C2 , C3 из примерав предыдущем подразделе. При выполнении программы возникнет ошибка дляC3 , у которого не описан IMyInterface (впрочем, мы можем избежать такойошибки, проверив Cx is IMyInterface перед выполнением приведения типа),как это сделано в примере.

Однако, возможно привести тип данного экземпляра самым непосредственнымобразом:

UseThroughInterface(Cx);

В таком случае проверка выполняется в момент компиляции. Такой кодскомпилируется для C1 и C2 (которые определены, как классы, использующиеIMyInterface ), но не скомпилируется для C3 .

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

Эквивалентно этому:

UseThroughInterface(IMyInterface(Cx));

Это тоже приведение типа, которое должно быть верным при компиляции.Обратите внимание, что данный синтаксис работает иначе, чем приведение типовобычных классов. Если написать что-либо вроде TMyClass(C) для классов, то врезультате получится небезопасное, непроверяемое приведение типов. В случаеже интерфейсов, писать IMyInterface(C) безопасно и быстро (проверяетсялишь при компиляции).

10. Про этот документ

Copyright Michalis Kamburelis.

80


Исходные файлы этого документа в формате AsciiDoc можно скачать поадресу: https://github.com/michaliskambi/modern-pascal-introduction . Автор будетрад любым пожеланиям, исправлениям, расширениям материала, доработками pull request-ам :). С автором можно связаться через профиль GitHub либопо e-mail: [email protected] . Домашняя страничка автора: https://michalis.ii.uni.wroc.pl/~michalis/ .

Этот документ можно свободно распространять и изменять налицензи идентичной лицензии Wikipedia, см. https://en.wikipedia.org/wiki/Wikipedia:Copyrights :

• Creative Commons Attribution-ShareAlike 3.0 Unported License (CC BY-SA)

• Либо GNU Free Documentation License (GFDL) (unversioned, with no invariantsections, front-cover texts, or back-cover texts) .

Благодарю за прочтение!

Перевод на русский выполнен: Александр Скворцов и Евгений Лоза 2016-2017

1 mailto:[email protected]

81

https://github.com/michaliskambi/modern-pascal-introduction

mailto:[email protected]

https://michalis.ii.uni.wroc.pl/~michalis/

https://michalis.ii.uni.wroc.pl/~michalis/

https://en.wikipedia.org/wiki/Wikipedia:Copyrights

https://en.wikipedia.org/wiki/Wikipedia:Copyrights

mailto:[email protected]

Object Pascal для программистов Michalis Kamburelismichalis/tmp/... · 1....

Documents

Transcript of Object Pascal для программистов Michalis Kamburelismichalis/tmp/... · 1....