Реферат: Описание указателей
Введение
Адресация динамических переменных происходит через указатели. В Паскале можно определить переменные, которые имеют тип указатель, их значения определяют адрес объекта. Для работы с динамическими переменными в программе должны быть предусмотрены:
выделение памяти под динамическую переменную;
присвоение указателю на динамическую переменную адреса выделенной памяти (инициализация указателя);
освобождение памяти после использования динамической переменной.
1. Указатели. Описание указателей
Указатели - это особый тип данных. В переменных этого типа хранятся адреса других переменных содержащих полезную для программы информацию. На первый взгляд может показаться, что использование указателей приводит к лишним затратам памяти и к усложнению программы, а также существе усложняет и сам процесс программирования. В данной главе мы, приведем такие примеры использования указателей, из которых станет ясно, что все дополнительные затраты на их хранение и обработку окупаются в полной мере. Работа с указателями предусмотрена не только в Pascal, но и в некоторых других языках программирования. Например, в языке С указатели используются практически в любой программе.
В Pascal роль указателей несколько скромнее, и, тем не менее, начинающим программистам следует усвоить базовые принципы работы с указателями, чтобы глубже понять внутренний механизм обработки и выполнения любой компьютерной программы.
2. Указатели и адреса
Известно, что адресом переменной является адрес первого байта ячейки памяти, которая под нее отводится. Для данных структурных типов (массивов и записей) их адресом считается адрес первого байта первого элемента.
В Turbo Pascal существует возможность прямого доступа к любому байту оперативной памяти по его адресу при помощи определенных в модуле system массивов Mem, MemW и MemL, которые позволяют записать информацию или прочитать ее непосредственно из ячеек памяти (один, два или четыре байта). Это очень опасные действия, поэтому они исключены в 32- разрядных системах программирования. Все же дадим краткие пояснения для тех, кто работает в среде Borland (Turbo) Pascal.
В качестве индекса в этих массивах используется адрес, записанный в виде, принятом в DOS: сегмент: Смещение относительно начала сегмента. Такой странный способ записи адреса связан с тем, что в операционной системе DOS вся память разбита на сегменты, размеры которых не превышают 64 Кбайт. Для получения абсолютного адреса из пары сегмент Смещение система прибавляет к сегменту справа шестнадцатеричный ноль (это четыре нуля в двоичной системе), а затем складывает его со смещением. Таким способом можно адресовать 1 Мбайт памяти.
Например, начальный адрес видеобуфера запишется в виде $B800:$000, а обратиться к самому первому его байту можно так:
Mem[$В800:$0000],
к первым двум байтам — MemW[$B800:$0000],
к первым четырем байтам — MemL [$B800:$0000]
Абсолютный адрес, соответствующий данной паре, — $B8000.
Еще один пример для любознательных — оператор mem[0:$41C]:=mem[0:$41А]; можно применить для принудительной очистки буфера клавиатуры. Здесь адрес маркера конца буфера клавиатуры приравнивается к адресу его начала. Конечно, в данном случае лучше воспользоваться средствами модуля crt.
Имеется еще один способ обращения к оперативной памяти — использование служебного слова absolute при описании переменной. В этом случае переменная будет располагаться именно по тому адресу в оперативной памяти, который указан после absolute. Разумеется, использование служебного слова absolute — столь же опасный способ, как и обращение к памяти через предопределенные массивы.
Однако absolute может использоваться и более безопасным способом, позволяя совмещать в памяти две переменные с разными именами. В языке Pascal есть специальная операция получения указателя на переменную (или процедуру) — она обозначается как @. Имеется также эквивалентная ей функция addr.
Например, @x или addr(х) — адрес переменной х.
Имеется и обратная операция получения значения переменной по ее адресу, которая обозначается знаком ^. Например, р^ переменная с адресом р.
В повседневной практике средства работы с адресами используются довольно редко. Основное назначение указателей состоит в том, чтобы обеспечить механизм использования в программе динамических переменных. Этот механизм мы и будем обсуждать подробно в следующих разделах.
3. Описание указателей
В Pascal имеются два различных вида указателей: типизированные и нетипизированные. Типизированный указатель — это указатель на переменную определенного типа, например, целого, строкового или типа массива Нетипизарованный указатель — это адрес первого байта области памяти, в которой может размещаться любая информация вне зависимости от ее типа.
Описание двух видов указателей выполняется по-разному:
var p1: ^integer; {указатель на переменную целого типа}
p2: ^string; {указатель на стоку}
p3 pointer; {нетипизированный указатель}
Заметим что тип pointer совместим со всеми типами указателей. В дальнейшем изложении для удобства имена всех указателей будем начинать с буквы p (pointer).
Каждый указатель размещается в сегменте данных или в стеке (если он объявлен в подпрограмме) и занимает там 4 байта. Это дополнительные “накладные расходы’ памяти. Поэтому обычные переменные очень редко создают и уничтожают динамически, оставляя эту возможность для больших совокупностей данных.
Чем больше размер динамической переменной, тем меньше доля накладных расходов. Например, при хранении в динамической памяти массивов больших размеров лишние 4 байта, затраченные на указатель, несущественны.
указатель динамический память адресация
4. Объявление указателей
Как правило, в Турбо Паскале указатель связывается с некоторым типом данных. Такие указатели будем называть типизированными. Для объявления типизированного указателя используется значок А, который помещается перед соответствующим типом, например:
var
p1: ^integer;
р2: ^real;
type
PerconPointer = ^PerconRecord;
PerconRecord = record
Name: string;
Job: string;
Next: PerconPointer
end;
Обратите внимание: при объявлении типа PerconPointer мы сослались на PerconRecord, который предварительно в программе объявлен не был. Как уже отмечалось, в Турбо Паскале последовательно проводится в жизнь принцип, в соответствии с которым перед использованием какого-либо идентификатора он должен быть описан. Исключение сделано только для указателей, которые могут ссылаться на еще не объявленный тип данных. Это исключение сделано не случайно. Динамическая память дает возможность реализовать широко используемую в некоторых программах организацию данных в виде списков. Каждый элемент списка имеет в своем составе указатель на соседний элемент, что обеспечивает можность просмотра и коррекции списка. Если бы в Турбо Паскале не было этого исключения, реализация списков была бы значительно затруднена.
В Турбо Паскале можно объявлять указатель и не связывать его при этом с каким-либо конкретным типом данных. Для этого служит стандартный тип POINTER, например:
var
р: pointer;
Указатели такого рода будем называть нетипизированными. Поскольку нетипизированные указатели не связаны с конкретным типом, с их помощью удобно динамически размещать данные, структура и тип которых меняются в ходе работы программы.
Как уже говорилось, значениями указателей являются адреса переменных в памяти, поэтому следовало бы ожидать, что значение одного укаателя можно передавать другому. На самом деле это не совсем так. В Турбо Паскале можно передавать значения только между указателями, связанными с одним и тем же типом данных. Если, например,
var
p1, p2: ^integer;
р3: ^real;
рр: pointer;
то присваивание
р1:= р2;
вполне допустимо, в то время как
р1:= р3;
запрещено, поскольку Р1 и Р3 указывают на разные типы данных. Это ограничение, однако, не распространяется на нетипизированные указатели, поэтому мы могли бы записать
pp:= р3;
р1:= рр;
и тем самым достичь нужного результата.
Читатель вправе задать вопрос, стоило ли вводить ограничения и тут же давать средства для их обхода. Все дело в том, что любое ограничение, с одной стороны, вводится для повышения надежности программ, а с другой - уменьшает мощность языка, делает его менее пригодным для каких-то применений. В Турбо Паскале немногочисленные исключения в отношении типов данных придают языку необходимую гибкость, но их использование требует от программиста дополнительных усилий и таким образом свидетельствует о вполне осознанном действии.
Использование указателей
Подведем некоторые итоги. Итак, динамическая память составляет 200...300 Кбайт или больше, ее начало хранится в переменной HEAPORG, a конец соответствует адресу переменной HEAPEND. Текущий адрес свободного участка динамической памяти хранится в указателе HEAPPTR.
Посмотрим, как можно использовать динамическую память для размещения крупных массивов данных. Пусть, например, требуется обеспечить доступ к элементам прямоугольной матрицы 100х200 типа 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) - возвращает смещение.
Аргументом Х при обращении к этим функциям может служить любая переменная, в том числе и та, на которую указывает указатель. Например, если имеем
var
р: ^real;
begin
new(p);
p^ := 3.14;
end
то функция SEG(P) вернет сегментную часть адреса, по которому располагается 4-байтный указатель Р, в то время как SEG(P^) - сегмент 6-байтного участка кучи, в котором хранится число 3.14.
С другой стороны, с помощью встроенной функции PTR(SEG,OFS: WORD): POINTER можно создать значение указателя, совместимое с указателями любого типа. Таким образом, возможна такая последовательность действий. Вначале процедурой GETMEM из кучи забираются несколько фрагментов подходящей длины (напомню, что за одно обращение к процедуре можно зарезервировать не более 65521 байт динамической памяти). Для рас сматриваемого примера удобно резервировать фрагменты такой длины чтобы в них могли, например, разместиться строки прямоугольной матрицы, т.е.
200 * 10 = 2000 байт.
Начало каждого фрагмента, т.е. фактически начало размещения в памяти каждой строки, запоминается в массиве PTRSTR, состоящем из 100 указателей. Теперь для доступа к любому элементу строки нужно вычислить смещение этого элемента от начала строки и сформировать соответствующий указатель:
var
i, j: integer;
PtrStr: array [1..100] of pointer;
pr: ^real;
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 pr^ > 1 then
end
Поскольку оператор вычисления адреса PR := PTR... будет, судя по всему, использоваться в программе неоднократно, полезно ввести вспомогательную функцию GETR, возвращающую значение элемента матрицы, и процедуру PUTR, устанавливающую новое значение элемента. Каждая из них, в свою очередь, обращается к функции ADDRR для вычисления адреса. Ниже приводится программа, создающая в памяти матрицу из NxM случайных чисел и вычисляющая их среднее значение.
program Primer1;
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 * M): 12:10)
end. {Main}
В рассмотренном примере предполагается, что каждая строка размещается в куче, начиная с границы параграфа, и смещение для каждого указателя PTRSTR равно нулю. В действительности при последовательных обращениях к процедуре GETMEM начало очередного фрагмента следует сразу за концом предыдущего и может не попасть на границу сегмента. В результате, при размещении фрагментов максимальной длины (65521 байт) может возникнуть переполнение при вычислении смещения последнего байта.