[ Миронченко ] Императивное и объектно-ориентированное програмирование на Turbo Pascal и Delphi

211

•Голубь (die Taube) всегда придерживается мирной тактики

•Ястреб (der Habicht) всегда агрессивен.

•Отпорщик (отпор – die Abfuhr, отпорщик – der Abfuhrer), если враг не пытается нападать, то ведет себя мирно, а если враг агрессивен, то будет стоять до конца.

•Задира (der Streithammel) - сначала всегда нападает, а затем, если соперник дает отпор, то сразу отступает.

Примеры функций переходов для Ястреба и Отпорщика:

{Ястреб}

function HabichtStr(EigenZustand,GegnerZustand:integer):integer; begin

HabichtStr:=0;

end;

{Отпорщик}

function AbfuhrStr(EigenZustand,GegnerZustand:integer):integer; begin

if EigenZustand =0 then{Если уже разозлили, то - все} begin

AbfuhrStr:=0;

exit;

end;

if (GegnerZustand=0) then AbfuhrStr:=0

else AbfuhrStr:=1;

end;

Докинз в своей книге активно критикует многих биологов, поэтому я не могу не раскритиковать его самого: давайте рассмотрим бой двух Задир. Каждый из них сначала нападает, т.е. дает отпор с точки зрения соперника. Значит, во втором этапе схватки они должны оба убежать друг от друга. Что должны делать Задиры дальше, Докинз не говорит. Но если интерпретировать их действия в виде функции, то выходит, что, так как соперник прекратил давать отпор, то идет новое нападение на ресурс. Но ведь так думают оба Задиры, значит, - снова будет битва, затем – отступление, … и эта схватка не закончится никогда (до естественной смерти), т.е. мы попадем в бесконечный цикл. Поэтому, чтобы избежать таких проблем, я к стратегии Задиры добавлю от себя, что если Задира один раз уже отступил, то дальше он уже будет придерживаться в этой схватке стратегии Голубя, т.е. только строить боевую физиономию.

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

212

Понадобится также процедура, которая будет имитировать схватку между особями:

function WirdDieSchlacht(var S1,S2:Strategie):integer;

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

•0, если состоится кровавая стычка

•1, если будет мирная борьба

•2, если представитель стратегии S1 прогонит представителя стратегии S2

(в этом случае считается, что произошла мирная схватка, в которой победил представитель S1)

• 3, если представитель стратегии S2 прогонит представителя стратегии S1

Проектирование групп и популяции в целом

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

Anzahl:longint; {численность группы} end;

{Пусть Gruppen – некоторая структура данных, содержащая все группы} Population = record {Набор стратегий}

Gr:Gruppen;

PopAnzahl:longint;{Общая численность популяции} GrAnzahl:integer;{Количество задействованных стратегий}

end;

Какой будет структура Gruppen выбирать вам. Наверное, имеет смысл сделать ее списком (см. главу 13). В таком случае вы добьетесь большей общности.

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

Надеюсь, что мое описание хоть немного поможет вам в вашем проекте.

213

Глава 13: Динамическая память

13.1. Структура памяти, доступной программе

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

•Часть ОП, в которой находится программа (и глобальные данные), называется статической.

•Стек – часть ОП, в которой хранятся локальные переменные, объявляемые в подпрограммах.

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

Размещаются эти области в ОП следующим образом:

Стек

Динамическая

память

Статическая

память

Рис 13.1. Структура памяти, доступной программе

Статическая память находится в нижних адресах, за ней – куча (так часто называют ДП). Стек находится в верхних адресах. Он может расти вниз, а куча - вверх.

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

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

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

214

ДП. Программы на TP выполняются под управлением операционной системы MS-DOS, поэтому мы будем пользоваться адресацией, которая используется в этой ОС. Изучая Delphi, мы рассмотрим адресацию в Windows.

•Адрес переменной складывается из 2-х частей: номера сегмента (англ. segment) и смещения (англ. offset).

•Сегмент – область памяти размером 64 Кбайт, которая начинается с адреса, кратного 16.

•Смещение – кол-во байтов, которые надо отступить от начала сегмента, чтобы указывать точно на переменную.

Впамяти адрес можно трактовать как 2 числа типа word.

адрес = Номер сегмента смещение Сегмент, начинающийся с 0-го байта имеет 0-й номер, с 16-го байта – 1-й номер,

с 32-го байта – 2-й номер и т.д..

Значение адреса равно 16*(номер сегмента)+смещение.

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

•Указатель – переменная, которая в качестве значения содержит адрес определенной области памяти.

Указатели в ТР бывают 2-х типов:

•типизированные, т.е. указатели на переменную определенного типа.

•нетипизированные (бестиповые), которые могут указывать на любой байт памяти.

Объявление указателя: var

p:pointer; {бестиповый указатель}

pr:^Real; {указатель на переменную типа real}

Рассмотрим на примере основные операции с указателями:

Пример 1: Операции с указателями.

1 : type

2 : Preal=^Real;{^Real - указатель на real}

3 : PInt=^Integer; {PInt - указатель на integer }

4 : var

5 : p:pointer;{бестиповый указатель}

6 : pr:PReal;

7 : z:PInt;

8 : r:real;

9 : x:integer;

10:begin

11:r:=8.88;

12:pr:=@r;{Записываем в pr aдрес r }

13:writeln('Значение переменной, на кот. ссылается рr ',pr^);

215

14:p:=pr; {В переменную p можно записывать указатели любых типов}

15:writeln(Preal(p)^);

16:

17:x:=123;

18:z:=@x;{Записываем в pr aдрес r }

19:writeln('Значение переменной, на кот. ссылается z ',z^);

20:p:=z; {В переменную p можно записывать указатели любых типов}

21:writeln(PInt(p)^)

22:end.

•Операция @ - операция взятия адреса.

@x – возвращает адрес переменной х.

•Получить доступ к переменной, на которую ссылается указатель можно с помощью операции разыменования - шапки после называния переменной (см.

строки 13, 19).

Типизированные указатели разных типов присваивать друг другу нельзя, но тип pointer совместим с любым другим указательным типом (строки 14, 20). Операция разыменования не может быть применена к бестиповым указателям, т.к. тип переменной, на который они ссылаются неизвестен. Поэтому бестиповые указатели нужно приводить к указателю на какой-то конкретный тип данных (строки 15,21).

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

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

Выделить память под типизированный указатель можно процедурой

New(p:pointer).

Само словосочетание «выделить память под указатель» означает не то, что надо выделить память для хранения самого указателя – он и так уже существует в памяти (неважно, в статической, динамической или стеке), - оно означает, что администратор кучи должен выделить память под переменную, на которую будет ссылаться указатель, и затем вернуть адрес этой переменной в этот самый указатель.

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

Dispose(P:Pointer).

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

216

10:i:integer;

11:begin

12:New(PM); {Выделяем память под указатель}

13:for i:=1 to n do

14:PM^[i]:=random(100);

15:SchaffRandMass:=PM;

16:end;

17:

18:procedure SchrMass(p:Pmas); {Печатает массив целых чисел}

19:var

20:i:integer;

21:begin

22:for i:=1 to n do

23:write(P^[i], ' ');

24:end;

25:

26:var

27:Ms:PMas;

28:begin

29:randomize;

30:Ms:=SchaffRandMass;{Ms присваиваем указатель на массив}

31:SchrMass(Ms);

32:Dispose(Ms); {Удаляем массив из дин. памяти}

33:readln;

34:end.

Вфункции SchaffRandMass объявлена локальная переменная PM, которая является указателем на массив. Под нее в строке 12 выделяется память, в строках 13-14 массив, на который ссылается РМ, заполняется случайными числами, и указатель возвращается в качестве результата.

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

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

13.2. Использование бестиповых указателей

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

GetMem(p:pointer; Umf:Longint) выделяет под указатель p Umf байт (der Umfang -

объем) памяти (р при этом указывает на первый из этих байтов).

FreeMem(p:pointer; Umf:Longint) возвращает в кучу Umf байт памяти, связанных с указателем р.

Еще могут понадобиться такие подпрограммы:

function Seg(x):word – возвращает номер сегмента, где расположена переменная х. function Ofs(x):word – возвращает смещение переменной х от начала сегмента.

218

вы посмотрите на результаты работы программы, то вы увидите, что было потрачено 24 байта. Не удивляйтесь этому. Дело в том, что администратор кучи выделяет память лишь порциями, кратными 8 байтам, поэтому выделяется наименьшее число байт, большее либо равное количеству байт, которое надо выделить и при этом делящееся на 8. Разумеется, при выделении больших объемов памяти потеря лишних нескольких байт – не проблема.

В15-й строке печатается номер сегмента и смещение той области памяти, на которую ссылается указатель р. Заметьте, что надо брать именно seg(p^), а не seg(p), т.к. надо получить номер сегмента переменной, на которую ссылается р, а не номер сегмента, в котором находится сам р.

Ofs(p^) сразу после выделения памяти под р равен либо 0, либо 8. Он обязан быть кратным 8, потому что администратор кучи выделяет блоки, кратные 8 байтам, а больше 8 он тоже быть не может, т.к. если он равен 16, то администратор кучи просто увеличит номер сегмента на 1, а смещение сделает равным 0. Вы это можете проверить, посмотрев результаты работы программы, написанной в четвертом примере.

Встроках 16-17 примера №3 мы начинаем наделять те 2*n байт смыслом – до этого они были для нас просто доступной памятью. В этих 2-х строках мы трактуем эти 2*n байт как массив из n целых чисел, а р – как указатель на начало массива. Но если в примере №2 ПК знал, что переменная Pm – указатель на массив (см. строки 9, 15 примера №2), и мы могли обратиться к i-му элементу массива как к Pm^[i], то в текущем примере сам ПК знает лишь то, что p – бестиповый указатель, и даже просто разыменовать его не получится. Приходится идти другим путем.

Давайте расшифруем выражение PInt(longint(p)+(i-1)*U)^ в строке 17. Значение р – адрес первого элемента массива. Мы знаем, что р состоит на самом

деле из двух чисел типа word: старшие 2 байта – это номер сегмента, а младшие 2 байта

– это смещение относительно начала сегмента. Еще мы знаем, что Ofs(p^) – либо 0, либо 8. Это означает, что в младших двух байтах переменной р находится либо 0, либо

8.

longint(p) – это указатель р, интерпретированный как длинное целое число. Замечу, что longint(p)- это не адрес, а просто целое число, соответствующее переменной р. Но, если мы будем прибавлять к числу longint(p) число (i-1)*U (напомню, что U=2 – размер переменной типа integer), то фактически это число будет прибавляться лишь к 2-м младшим байтам числа longint(p), а значит, что само число longint(p)+(i-1)*U, если его проинтерпретировать как указатель на целое число, будет ссылаться как раз на i-й элемент массива (т.к. на первый ссылается сам р). PInt(longint(p)+(i-1)*U)- указатель на i-й элемент массива. Его можно разыменовать, т.к. Pint – типизированный указатель. Итого, PInt(longint(p)+(i-1)*U)^:=I означает: i-му элементу массива присваивается число i.

Строки 19-20 печатают массив. Можно было бы обращаться к элементам массива так же, как это мы делали в строке 17, но я решил показать вам еще один способ.

Расшифруем выражение PInt(ptr(seg(p^),ofs(p^)+(i-1)*U))^ ptr(seg(p^),ofs(p^)+(i-1)*U) вернет указатель (бестиповый) на i-й элемент массива. Почему это так, должно быть ясно из приведенных выше соображений. Т.к. указатель бестиповый, то его надо привести к типу (в нашем случае – к указателю типа Pint), а затем его уже можно будет разыменовывать.

220

13.4.Обобщенная сортировка массива

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

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

Пример 5: Обобщенная сортировка массива.

1 : uses

2 : Crt;

3 : type

4 : PInt=^integer;

5 : PStr=^string;

6 : Vergleich=function(p1,p2:pointer):boolean;

7 : var

8 : p:pointer;

9 : n,i:longint;

10: Umf:integer; {Umfang - объем} 11:

12:{Печатает массив целых чисел}

13:procedure SchrMass(p:pointer;Q:longint);

14:var

15:i:integer;

16:begin

17:for i:=0 to Q-1 do

18:write((pint(longint(p)+2*i))^,' ');

19:writeln;

20:end;

21:

22:{Побайтово копирует Umf байтов начиная с адреса p2

23:в Umf байтов, начиная с p1}

24:procedure Kopiere(p1,p2:pointer;Umf:longint);

25:type

26:Pbyte=^byte;

27:var

28:i:integer;

29:begin

30:for i:=1 to Umf do

31:Pbyte(longint(p1)+(i-1))^:=Pbyte(longint(p2)+(i-1))^;

32:end;

33:

34: {Обобщенная сортировка пузырьком - сортирует данные размера Umf