Олег Деревенец - Песни о Паскале

p1 := nil; { p1 – пустой указатель на целое }

p3 := nil; { p3 – пустой указатель на символ }

Указатели похожи на письма, а переменные – на дома, куда эти письма адресованы (рис. 117).

Судя по рис. 117, жителям первого дома повезло, – им адресованы два письма. Третий конверт – без адреса, он пуст и подобен указателю, содержащему NIL.

Поскольку указатели – это не обычные числа, их нельзя вычитать, складывать и сравнивать на «больше» или «меньше». Зато можно сравнивать на равенство и неравенство. В таком сравнении есть смысл: ведь если непустые указатели равны, то ссылаются на одну и ту же переменную. Вот примеры правильных сравнений.

if p1=p2 then …

if p1<>p2 then …

if p3=nil then …

Сравнением с NIL выясняется, свободен ли указатель или ссылается на что-то. Но значение NIL в указатель должен занести программист, само оно там не появится!

Проверить незанятость указателя можно как сравнением с NIL, так и функцией Assigned. Она принимает указатель любого типа, а возвращает булев результат. Вот примеры её применения.

p1 := @X; p3 := nil;

Writeln (Assigned(p1)); { true }

Writeln (Assigned(p3)); { false }

Функция Assigned возвращает FALSE, если указатель содержит NIL.

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

p1 := @X; { назначение адреса указателю P1 }

X := 25;

Writeln (p1^); { 25 }

X := 100;

Writeln (p1^); { 100 }

Здесь показано, что с изменением переменной X меняется и значение P1^. Иначе говоря, если P1=@X, то P1^=X (а верно ли обратное?).

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

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

var P1, P2 : pointer; N : integer; S : string;

begin

P1:= @N; P2:= @S;

if P1=P2 then Writeln('Указатели совпадают');

if P1<>nil then Writeln('Указатель не пустой');

end.

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

type PInt = ^integer; { тип указателя на целое }

var P : pointer; N : integer;

…

P:= @N;

Writeln( PInt(P)^ ); { печатается значение N }

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

{ P_51_1 – Указатели }

var A, B, C : integer; { целые числа }

p1, p2, p3 :^integer; { указатели на целые числа }

begin

{ Присвоение значений переменным }

A:= 10; B:= 20; C:= 30;

{ Последовательное переключение одного указателя на разные переменные }

p1:= @A; Writeln(p1^);

p1:= @B; Writeln(p1^);

p1:= @C; Writeln(p1^);

{ Настройка трех указателей на одну переменную }

p1:=@B; p2:=p1; p3:=p1;

Writeln(p1^:6, p2^:6, p3^:6);

{ Арифметические действия через указатели }

C:= 2 * p1^;

Writeln(C); { C= 2 * B = 40 }

Readln;

end.

Результат работы этой программы таков.

10

20

30

20 20 20

40

Здесь опять убеждаемся, что разыменованный указатель равнозначен переменной, на которую он ссылается. С ним выполняют те же действия, что и с переменной: ввод, вывод, арифметические операции и так далее.

В программе «P_51_2» мы ещё раз увидим это, а вдобавок исследуем размеры указателей на переменные разных типов, – отличаются ли они?

{ P_51_2 – Указатели разных типов, размеры указателей }

type PBool= ^boolean; { Тип указателя на булевскую переменную }

PInt = ^integer; { Тип указателя на целое число }

PStr = ^string; { Тип указателя на строку }

var B : boolean;

I : integer;

S : string;

pB : PBool; { Указатель на булевскую переменную }

pI : PInt; { Указатель на целое число }

pS : PStr; { Указатель на строку }

begin

{ Настройка указателей на переменные }

pB := @B; pI := @I; pS := @S;

{ Присвоение значений переменным через указатели }

pB^ := true;

pI^ := 10;

pS^ := 'Hello!';

{ Распечатка значений переменных }

Writeln(B:6, I:6, S:10);

{ Исследование размеров типов и указателей на них }

Writeln('Boolean = ',SizeOf(Boolean):6, SizeOf(PBool):6);

Writeln('Integer = ',SizeOf(integer):6, SizeOf(PInt ):6);

Writeln('String = ',SizeOf(String ):6, SizeOf(PStr ):6);

Readln;

end.

Вот «продукция» этой программы.

true 10 Hello!

Boolean = 1 4

Integer = 2 4

String = 256 4

Любопытны три последних строки. Они показывают, что размеры указателей на переменные всех типов одинаковы и для 32-разрядных систем составляют 4 байта (подобно тому, как размер конверта не зависит от размера дома, куда он адресован).

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

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

• Объекты программы – переменные, процедуры и функции – занимают ячейки памяти, адреса которых можно определить операцией взятия адреса @ или функцией Addr.

• Для хранения адресов применяют переменные особого типа – указатели. Каждому типу переменных соответствует свой тип указателя.

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

• С указателями допустимы лишь три операции: копирование, сравнение и разыменование.

• Разыменованный указатель – это переменная, на которую он ссылается в данный момент; с ним можно поступать как с этой переменной.