1. Объявление указателей

Как правило, в Турбо-Паскале указатель связывается с некоторым типом данных (типизированныеуказатели).

Type    PerPnt = ^PerRec;{указатель на переменную типа PerRec}    PerRec = Record      Name: String;      Job: String;      Next: PerPnt;    End;  Var    P1: ^Integer;    P2: ^Real;

Внимание! При объявлении типа PerPnt мы сослались на PerRec, который ещё не был объявлен, это связано с тем, что существует исключение из правил для указателей, которые содержат ссылку на ещё неописанный тип данных. Это исключение сделано не случайно, так как динамическая память позволяет использовать организацию данных в виде списков (каждый элемент имеет в своём составе ссылку на соседний элемент - обратите внимание на поле Next).

В Турбо-Паскале можно объявлять указатель и не связывать его с конкретным типом данных:  Var   PP: Pointer;

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

В Турбо-Паскале можно передавать значения только между указателями, связанными с одним и тем же типом данных.  Var   P1,P2: ^Integer;   P3: ^Real;   PP:Pointer; Begin   P1:= P2; {- верно}   P1:= P3; {- неверно}

но можно сделать так:    PP:= P3;    P1:= PP;  так как ограничение не распространяются на нетипизированные указатели. Но подобные операции часто путают программиста и чреваты смысловыми ошибками.

2. Выделение и освобождение динамической памяти

Вся динамическая память – пространство ячеек, называемое кучей. Физически куча располагается в старших адресах, сразу за программой. Указатель на начало кучи храниться в предопределенной переменной HeapOrg, конец - FreePtr, текущую границу незанятой динамической памяти указывает указатель HeapPtr. Для выделения памяти под любую переменную используется процедура New. Единственным параметром является типизированный указатель:  Var   I,J: ^Integer;   R: ^Real;  Begin   New(I); {под I выделяется область памяти,}   {адрес первого байта этой области помещается в I} End.

После выполнения этого фрагмента указатель I приобретёт значение, которое перед этим имел указатель кучи HeapPtr, а HeapPtr увеличится на два (т.к. он типа Integer); New(R) - вызовет смещение указателя на 6 байт. После того как указатель приобрёл некоторое значение, то есть стал указывать на конкретный байт памяти, по этому адресу можно разместить значения соответствующего типа:

  I^:= 2;    R^:= 2*Pi;  Допустима запись: R^:= Sqr (R^) + I^ - 17;  Но недопустима запись: R:= Sqr (R^) + I^ - 17; так как указателю R нельзя присвоить значение вещественного выражения.

Возврат динамической памяти обратно в кучу осуществляется оператором Dispose:    Dispose(R);    Dispose(I); - вернут в кучу, ранее забранные 8 байт.    Dispose(Ptr) не изменяет значения указателя Ptr, а лишь возвращает в кучу память, связанную с этим указателем. Однако повторное применение процедуры к “свободному” указателю приведет к возникновению ошибки времени исполнения. Чтобы указать, что указатель свободен, нужно использовать зарезервированное слово Nil.

К указателям можно применять операции отношения, в том числе и сравнения с Nil:  Const  P:^Real = Nil; . . . . . . . . Begin  If P = Nil then    New (P);  . . . . . . . .  Dispose(P);  P:= Nil; End.

Использование указателей, которым не присвоено значение процедурой New или каким-либо другим способом, никак не контролируется системой и может привести к непредсказуемым результатам. Многократное чередование New и Dispose приводит к “ячеистой” структуре кучи. Дело в том, что все операции с кучей выполняется под управлением особой программы, которая ведёт учёт всех свободных фрагментов в куче. При выполнении оператора New( ) эта программа отыскивает минимальный свободный фрагмент, в котором может разместиться требуемая переменная. Адрес начала найденного фрагмента возвращается в указателе, а сам фрагмент или его часть нужной длины, помечаются как занятая часть кучи.

Можно освободить целый фрагмент кучи следующим образом:  1. Перед началом выделения динамической памяти значения указателя HeapPtr запоминается в переменной-указателе с помощью процедуры Mark.  2. Выполнение программы.  3. Освобождение фрагмента кучи от заполненного адреса до конца динамической памяти с использованием процедуры Release.

Var  P, P1, P2, P3, P4, P5: ^Integer; Begin  New(P1);  New(P2);  New(P3);  New(P4);  New(P5);  Mark(P); . . . . . . . .   Release (P); End.

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

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

Для работы с нетипизированными указателями используются также процедуры GetMem(P, Size) иFreeMem(P, Size) - резервирование и освобождение памяти.  P - нетипизированный указатель, Size - размер.

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

Использование нетипизированных указателей даёт широкие возможности неявного преобразования типов:  Var    i,j: ^Integer;    r: ^Real;  Begin    New (i); { I:= HeapOrg; HeapPtr:= HeapOrg+2 }    j:= i; { J:= HeapOrg }    j^:=2;    Dispose (i); { HeapPtr:= HeapOrg }    New (r); { R:= HeapOrg; HeapPtr:= HeapOrg+6 }    r^:= Pi;    WriteLn (j^);  End.  {Будет выведено: "8578"}  {здесь преобразование не имеет никакого смысла}

Примеры использования указателей. Динамическая память - 200..300 Кбайт. Нужно разместить массив 100 * 200 типа Extended. Требуется 100 * 200 * 10 = 200000 байт. Пробуем:  Var   i,j: Integer;   PtrArr: Array[1..100, 1..200] of ^Extended.  Begin . . . . . .   For i:= 1 to 100 do     For j:= 1 to 200 do      New (PtrArr [i,j]); . . . . . . End.

Теперь к любому элементу можно обратиться: PtrArr[i,j]^:=...; Но длина внутреннего представления указателей 4 байта, поэтому потребуется ещё 100*200*4 = 80000 байт, что превышает размер сегмента (65536 байт), доступный для статического размещения данных.

Можно было бы работать с адресной арифметикой (арифметикой над указателями), то есть не создавать массив указателей, а вычислять адрес элемента непосредственно перед обращением к нему. Однако в Турбо-Паскале над указателями не определены никакие операции, кроме присваивания и отношения. Но задачу решить можно:  Seg(x) - возвращает сегментную часть адреса.  Ofs(x) - возвращает смещение.  x - любая переменная, в том числе и та, на которую указывает указатель.

Далее с помощью Ptr(Seg, Ofs: Word): Pointer можно создать значение указателя, совместимое с указателем любого типа.

Таким образом, сначала с помощью GetMem забираем из кучи несколько фрагментов подходящей длины (не более 65521). Удобно по строкам 200 * 100 = 20000 байт. Начало каждого фрагмента запоминается в массиве PtrStr из 100 указателей. Теперь для доступа к любому элементу строки нужно вычислить смещение этого элемента от начала строки и сформировать указатель.  Var    i,j: Integer;    PtrStr: Array [1..100] of Pointer;    Pr: ^Extended;  Const    SizeOfExt = 10;  Begin    For i:= 1 to 100 do      GetMem (PtrStr[i], SizeOfExt*200);  . . . . . . . . . . . . . . . .      Pr:= Ptr(Seg(PtrStr[i]^), Ofs(PtrStr[i]^) + (j - 1) * SizeOfExt);      {Обращение к элементу матрицы [i,j]}  End;

далее работаем с Pr^:=. . . и т.д.  Полезно ввести две вспомогательных функции GetExt и PutExt. Каждая из них будет обращаться к функции вычисления адреса AddrE.  Program Demo;  Const    SizeOfExt = 10;    N = 100;    M = 200;  Type    ExtPoint = ^Extended;  Var    i,j: Integer;    PtrStr: Array[1..N] of Pointer;    S: Extended;

  Function AddrE(i,j: Word): ExtPoint;    Begin      AddrE:= Ptr(Seg(PtrStr[i]^), Ofs(PtrStr[i]^) + (j - 1) * SizeOfExt);    End;

  Function GetExt(i,j: Integer): Extended;    Begin     GetExt:= AddrE(i,j)^;    End;

  Procedure PutExt(i,j: Integer; X: Extended);    Begin     AddrE(i,j)^:= X;    End;

  Begin {main}     Randomize;     For i:=1 to N do     Begin      GetMem (PtrStr[i], M*SizeOfExt);      For i:= 1 to m do        PutExt(i, j, Random(255));     End;     S:= 0;    For i:= 1 to N do     For j:= 1 to M do      S:= S + GetExt(i,j);     WriteLn(S/(N*M));  End.

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