Использование указателей
Подведем некоторые итоги. Итак, динамическая память составляет 200...300 Кбайт или больше, ее начало хранится в переменной HEAPORG, а конец соответствует адресу переменной HEAPEND. Текущий адрес свободного участка динамической памяти хранится в указателе HEAPPTR.
Посмотрим, как можно использовать динамическую память для размещения крупных массивов данных. Пусть, например, требуется обеспечить доступ к элементам прямоугольной матрицы 100x200 типа EXTENDED. Для размещения такого массива требуется память 200000 байт (100*200*10).
Казалось бы, эту проблему можно решить следующим образом:
var
i,j : Integer;
PtrArr : array [1..100, 1...200] of Real;
begin
for i := 1 to 100 do
for j := 1 to 200 do
new(PtrArr[i,j]);
.......
end.
Теперь к любому элементу вновь созданного динамического массива можно обратиться по адресу, например:
PtrArr[1,1] := 0;
if PtrArr[i,j*2] > 1 then ......
Вспомним, однако, что длина внутреннего представления указателя составляет 4 байта, поэтому для размещения массива PTRARR потребуется 100*200*4 = 80000 байт, что превышает размер сегмента данных (65536 байт), доступный, как уже отмечалось, программе для статического размещения данных.
Выходом из положения могла бы послужить адресная арифметика, т.е. арифметика над указателями, потому что в этом случае можно было бы отказаться от создания массива указателей PTRARR. и вычислять адрес любого элемента прямоугольной матрицы непосредственно перед обращением к нему. Однако в Турбо Паскале над указателями не определены никакие операции, кроме операций присвоения и отношения.
Тем не менее, решить указанную задачу все-таки можно. Как мы уже знаем, любой указатель состоит из двух слов типа WORD, в которых хранятся сегмент и смещение. В Турбо Паскале определены две встроенные функции типа WORD, позволяющие получить содержимое этих слов:
SEG(X) - возвращает сегментную часть адреса;
OFS(X) - возвращает смещение.
Аргументом X при обращении к этим функциям может служить любая переменная, з том числе и та, на которую указывает указатель. Например, если имеем
var
р : Real;
begin
......
new(p);
р := 3.14;
.......
end.
то функция SEG(P) вернет сегментную часть адреса, по которому располагается 4-байтный указатель Р, в то время как SEG(P^) - сегмент 6-байтного участка кучи, в котором хранится число 3.14 .
С другой стороны, с помощью встроенной функции
PTR(SEG,OFS: WORD): POINTER
можно создать значение указателя, совместимое с указателями любого типа. Таким образом возможна такая последовательность действий. Вначале процедурой GETMEM из кучи забираются несколько фрагментов подходящей длины (напомню, что за одно обращение к процедуре можно зарезервировать не более 65521 байт динамической памяти). Для рассматриваемого примера удобно резервировать фрагменты такой длины, чтобы в них могли, например, разместиться строки прямоугольной матрицы, т.е. 100 * 10 = 2000 байт. Начало каждого фрагмента, т.е. фактически начало размещения в памяти каждой строки, запоминается в массиве PTRSTR, состоящем из 100 указателей, теперь для доступа к любому элементу строки нужно вычислить смещение этого элемента от начала строки и сформировать соответствующий указатель:
var
i,j:Integer;
PtrStr : array [1..100] of pointer;
const
SizeOfReal = 6;
begin
for i := 1 to 100 do
GetMem (PtrStr [i] , SizeOfReal*200) ;
.......
{Обращение к элементу матрицы [i,j]}
pr := ptr(seg(PtrStr[i]),
ofs(PtrStr[i])+(j-1)*SizeOfReal);
if рr > 1 then
.......
end.
Поскольку оператор вычисления адреса PR := PTR... будет, судя по всему, использоваться в программе неоднократно, полезно ввести вспомогательную функцию GETR, возвращающую значение элемента матрицы, и процедуру PUTR, устанавливающую новое значение элемента (правила объявления процедур и функций изложены в гл. 8). Каждая из них, в свою очередь, обращается к функции ADDRR для вычисления адреса. В примере 6.1 приводится программа, создающая в памяти матрицу из NxM случайных чисел и вычисляющая их среднее значение.
Пример 6.1
const
SizeOfReal = 6; {Длина переменной типа REAL}
N = 100; {Количество столбцов}
М = 200; {Количество строк}
var
i,j : Integer;
PtrStr: array [1..N] of pointer;.
s : Real ;
type
RealPoint =^Real;
{-------------------}
Function AddrR(i,j: word): RealPoint;
{По сегменту i и смещению j выдает адрес вещественной переменной}
begin
AddrR := ptr(seg (PtrStr [i]),
ofs{ PtrStr [i]) + (j -1) * SizeOfReal)
end {AddrR} ;
{-------------------}
Function GetR(i,j: Integer): Real;
{ Выдает значение вещественной переменной по сегменту i и смещению j ее адреса}
begin
GetR := AddrR(i,j)
end {GetR};
{-------------------}
Procepure PutR(i,j : Integer; x: Real);
{Помещает в переменную, адрес которой имеет сегмент i
и смещение j, вещественное значение x}
begin
AddrR ( i , j ) : = x
end {PutR};
{-------------------}
begin {Main}
for i :=1 to N do
begin
GetMem (PtrStr [i] , M*SizeOfReal) ;
for j := 1 to M do PutR(i, j, Random)
end;
S := 0;
for i := 1 to N do
for j := 1 to M do
s := s +GetR(i,j);
WriteLn(s/(N * М) :12:10)
end {Main} .
В рассмотренном примере предполагается, что каждая строка размещается в куче, начиная с границы параграфа, и смещение для каждого указателя PTRSTR равно нулю. В действительности при последовательных обращениях к процедуре GETMEM начало очередного фрагмента следует сразу за концом предыдущего и может не попасть на границу сегмента. В результате, при размещении фрагментов максимальной длины (65521 байт) может возникнуть переполнение при вычислении смещения последнего байта.
