Fruitsekta.ru

Мир ПК
3 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Динамические данные паскаль

Программирование и базы данных

Ещё один сайт сети «Информационная база»

Pascal Динамические структуры данных

Линейные
списки, изучение основных операций

Списком называется структура данных, каждый элемент
которой посредством указателя связывается со следующим элементом. Из
определения следует, что каждый элемент списка содержит как минимуму
одно поле данных (назовем его data
и для простоты считаем его типа Integer ),
оно может иметь сложную структуру, и поле ссылки на следующий элемент
(назовем его next ). Поле ссылки
последнего элемента списка имеет значение Nil .
Указатель на начало списка (первый элемент) является значением отдельной
переменной. Пример списка, содержащего в поле данных целые числа 3. 5,
1, 9, приведен на рисунке.

Описание элемента списка, используемого в течение данного понятия, имеет
вид:

Основн ые операции с элементами списка:

просмотр элементов списка;

вставка элементов в список;

удаление элемента из списка;

Просмотр элементов списка, если он создан,
очевидная процедура.

Ее рекурсивная реализация:

Измените ее так, чтобы элементы списка выводились, начиная с последнего.

Вставка элемента в список возможна логически в его начало, конец и
середину. Разберем эти случаи. Вставка в начало имеет вид:

Procedure Ins_begin(Var first:pt;
el:Integer);

« Кра сными »
отрезками на рисунке выделены действия, выполняемые в процедуре. С
помощью цифр на рисунке и в тексте процедуры показаны действия
соответствующих операторов.

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

Procedure
Ins_end(Var last:pt; el:Integer);

Вставку в средину списка проиллюстрируем очередным рисунком.

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

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

Procedure
Ins_med(Var first:pt; el:Integer);

И наконец, общая логика вставки элемента в упорядоченный список.
Создаваемый список отличается от декларированного в начале тем, что он
описывается двумя указателями: на первый и последний элементы списка.

Procedure
Ins(Var first,last:pt; el:Integer);

If eKfirst».data Then
Ins_begin(first,el) Else

If el>last».data Then
Ins_end(last,el) Else Ins_med (first,el);

Ввод исходных данных при создании упорядоченного списка осуществляется с
клавиатуры. Напомним, что признак конца файла (Eof = True) в этом случае
вырабатывается при нажатии клавиш Ctrl+Z. Все действия по организации
ввода представлены в процедуре Solve.

Procedure
Solve(Var first,last:pt);

лабы по информатике, егэ

лабораторные работы и задачи по программированию и информатике, егэ по информатике

Занятие №15. Часть 1: Динамические структуры данных: указатели и списки

Динамические структуры данных

  • размер динамических данных заранее неизвестен;
  • память под них выделяется во время исполнения программы;
  • динамические данные, как правило, не имеют идентификаторов (имени в стандартном понимании статических данных), но имеют адрес в памяти;
  • обращение к динамическим данным осуществляется по их адресу в памяти.
  • Если говорить об оперативной памяти в программировании, то вводится понятие статической и динамической памяти. Оперативная память неодинакова, она имеет различные области: для статической памяти, для динамической памяти.
  • Обращение к участку динамической памяти происходит с помощью специальной ссылочной переменной, которая называется указателем или ссылкой.

Указатели

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

Универсальные нетипизированные указатели могут хранить адрес переменной любого типа:


Таким образом, указатель может находиться в одном из трех состояний:

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

var n, k: integer; pI: ^integer; begin n := 4; pI := @n; writeln(‘Адрес n =’ , pI); writeln(‘n = ‘, pI^); k := 4*(7 — pI^); // k = 4*(7 — 4) = 12 pI^ := 4*(k — n); // n = 4*(12 – 4) = 32 end.

Другой вариант присваивания значений — использование служебного слова NEW:

var pI: ^integer; begin new(pI); pI^ := 4; writeln(‘Адрес =’ , pI); writeln(‘Значение = ‘, pI^); end.

Type rec = Record Name : string[30]; Surname: string[30]; end; var P: ^rec; begin new(P); P^.Name:=’Иван’; write(P^.Name); // Иван end.

Списки

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

Каждый элемент списка организован следующим образом:

  • содержит поля с полезной информацией;
  • содержит специальное поле (или несколько полей), которое хранит адрес другого элемента списка.
  • type ukazatel = ^elem_spiska; elem_spiska = record znach:integer; next: ukazatel; end; .

    Рассмотрим потребность использования динамических структур — списков на примере:

    Читать еще:  Сортировка массива паскаль

    Так как количество слов заранее неизвестно, и определяется оно только в конце программы, то использование статических и динамических массивов невозможно. Необходимо использовать список.

    Алгоритм выполнения программы:

    1. создать список;
    2. если слова в файле закончились, то остановка;
    3. считать слово и искать его в списке;
    4. если слово найдено, то увеличить счетчик повторов слов, иначе добавить слово в список;
    5. перейти к шагу 2.
    • Список состоит из начального узла — головы — и связанного с ним списка.
    • Каждый элемент списка содержит информационную и ссылочную части. Т.е. каждый элемент имеет информационное поле (поля) — полезная информация — и ссылку (ссылки), то есть адрес на другой элемент списка.
    • Односвязный (линейный) список: структура, каждый элемент которой «знает» адрес только следующего за ним элемента.

    Для доступа к списку достаточно необходимо знать адрес его головного элемента:

    var Head: PNode; . Head := nil;

    Для решения нашей задачи запрограммируем функцию для создания узла. На вход функции подается новое слово, возвращает функция адрес нового узла, созданного в памяти.

    function CreateNode(NewWord: string): PNode; var NewNode: PNode; begin New(NewNode); NewNode^.word := NewWord; NewNode^.count := 1; NewNode^.next := nil; Result := NewNode; end;

    Добавить узел можно:

    • в начало списка;
    • в конец списка;
    • после заданного узла;
    • до заданного узла.

    Чтобы добавить узел в начало списка:

      Установить ссылку нового узла на голову списка:

    Обозначить новый узел как голову списка:

    Выполним добавление узла списка на Паскале в виде процедуры:

    procedure AddFirst ( var Head: PNode; NewNode: PNode ); begin NewNode^.next := Head; Head := NewNode; end;

    Чтобы добавить узел после заданного:

      Установить ссылку нового узла на узел, следующий за конкретным (p):

    Установить ссылку узла p на новый узел:

    Для добавления узла в конец списка или перед заданным узлом необходимо уметь перемещаться по списку.

    • устанавливаем дополнительный указатель pp на голову списка;
    • в случае когда дошли до конца списка, т.е.если указатель pp равен значению nil, то делаем остановку;
    • производим необходимые действия над узлом с адресом pp;
    • делаем переход к следующему узлу — pp^.next.

    var pp: PNode; . pp := Head; // начинаем с головы while pp <> nil do begin // цикл пока не достигнут конец . // выполняем действия с pp pp := pp^.next; // переходим к следующему узлу end;

    Чтобы добавить узел в конец списка:

    • определить последний узел pp, для которого pp^.next равен nil;
    • использовать процедуру AddAfter для добавления узла после узла с адресом pp.

    Если список пуст, то алгоритм выполнения изменяется:

    procedure AddLast ( var Head: PNode; NewNode: PNode ); var pp: PNode; begin if Head = nil then AddFirst ( Head, NewNode ) // добавляем в пустой список else begin pp := Head; while pp^.next <> nil do // поиск последнего узла pp := pp^.next; AddAfter ( pp, NewNode ); // после узла pp добавляем узел end; end;

    Чтобы добавить узел перед заданным:

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

    procedure AddBefore(var Head: PNode; p, NewNode: PNode); var pp: PNode; begin pp := Head; if p = Head then AddFirst ( Head, NewNode ) // добавление в начало списка else begin while (pp <> nil) and (pp^.next <> p) do // поиск узла, за которым следует узел p pp := pp^.next; if pp <> nil then AddAfter ( pp, NewNode ); // добавляем после узла pp end; end;

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

    function Find(Head: PNode; NewWord: string): PNode; var pp: PNode; begin pp := Head; // пока не конец списка и слово в просматриваемом узле не равно искомому while (pp <> nil) and (NewWord <> pp^.word) do pp := pp^.next; Result := pp; end;

    Вставка слова в определенное место списка по алфавиту

    Алгоритм выполнения:
    Создадим функция для поиска «подходящего» места MakePlace.
    На вход функции подается вставляемое слово, возвращает же функция адрес узла, перед которым необходимо добавить слово; возвращается nil, если слово должно быть вставлено в конец списка.

    function FindPlace(Head: PNode; NewWord: string): PNode; var pp: PNode; begin pp := Head; while (pp <> nil) and (NewWord > pp^.word) do pp := pp^.next; Result := pp; // слово NewWord в алфавитном порядке находится перед pp^.word end;

    Для удаления конкретного узла списка необходимо знать адрес предыдущего узла pp:

    Для этого создадим функцию TakeWord().
    Будем игнорировать все ненужные символы, код которых ‘ ‘) do begin Result := Result + c; read(F, c); end; end;

    1. Открываем файл в режиме на чтение ( var F: Text; )
    2. Считывание очередного слова из файла.
    3. Если слов больше не осталось (достигнут конец файла), то переходим к шагу номер 7.
    4. Слово нашлось — значит, увеличиваем счетчик слов.
    5. Если в списке искомого слова не существует, то выполняем:
      • создание нового узла с заполнением необходимых полей: функция CreateNode();
      • поиск узла, перед которым добавляем слово: функция MakePlace();
      • добавление узла: функция AddBefore().
    6. Возвращаемся к шагу номер 2.
    7. Закрываем рабочий файл.
    8. Печатаем на экран список слов: для этого используем алгоритм перемещения по списку.
    Читать еще:  Транспонирование матрицы паскаль

    Двусвязные списки (двунаправленные)

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

    «Обнуляем» адреса головы и хвоста:

    var Head, Tail: PNode; . Head := nil; Tail := nil;

    Указатели в Паскале. Динамическая память на языке Паскаль

    В ТР имена объектов (переменных и др.) д. б. определены до момента использования их в программе. Как отмечалось ранее, ОП персонального компьютера имеет сегментную структуру. Адрес – совокупность двух 16-ти разрядных слов — сегмента и смещения. (Например: $0060:$01А0). Сегмент — участок памяти, имеющий максимальную длину 64К (65536 байт). Начальный адрес каждого сегмента кратен 16 (т.е. 0, 16, 32, и т.д.), следовательно, два сегмента отстоят друг от друга, по крайней мере, на 16 байт. Сегменты адресуют память с точностью до параграфа. Параграф – фрагмент памяти равный 16 байт. Смещение – линейная адресация в сегменте. Она также имеет 16-ти разрядные адреса и адресует память с точностью до байта. При этом глобальные переменные и типизированные константы размещаются в сегменте данных. Такие переменные называются статическими, а память, выделяемая компилятором для их хранения называется статической памятью.

    Локальные переменные размещаются в памяти динамически при активизации подпрограммы. После выполнения подпрограммы память освобождается.

    Память, которая выделяется под локальные переменные, называется сегментом стека. Она задается директивой <$M >. Минимальный размер памяти 1К, максимальный 64К, по умолчанию 16к.

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

    Для динамических переменных отводится динамическая память, которая имеет стековую структуру и называется «кучей» (хипом – Heap-куча). Размер хипа задается директивой <$M >.

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

    Ссылочные типы. Указатели в Паскале

    Указатель – это переменная, которая содержит адрес другой переменной (байта памяти).
    В ТР имеется два вида указателей: указатель на объект некоторого типа (типизированный) и указатель, не связанный с типом.
    Описание указателей.

    Для объявления типизированных указателей используется значок ^, который помещается перед соответствующим типом:

    Type T = ^T1;
    Var A :T;
    где: T – имя типа;
    T 1 — базовый тип (любой в т.ч. указатель);
    ^ — указатель.
    Примеры:
    Var
    a :byte; <выделение памяти для переменной где хранится ее значение>
    a ;^byte;

    Var
    p1 :^integer;
    p2, p3 :^real;

    Для объявления переменных не связывая их, с каким либо типом данных можно использовать указатель без типа (pointer).
    Var
    p :pointer;
    где: pointer — не типизированный указатель, который занимает в памяти 4 байт (2-байта сегмент, 2байта смещение.).

    Операции с указателями

    Для указателей допустимы операции сравнения и присваивания.

    Присваивание. Указателю можно присвоить содержимое другого указателя того же самого типа или константу NIL – пустой, или адрес объекта с помощью функции ADDR или оператора @.

    Пример:
    P1 := PP;
    P2 := NIL;
    P3 := Addr(X);
    P4 := @X;

    Процедуры и функции для работы с указателями и адресами в Паскале

    ADDR(X) – результат POINTER, в котором содержится адрес аргумента. (X –имя любой переменной, процедуры или функции).
    OFS(X):WORD – возвращает значение смещения адреса объекта X.
    SEG(X):WORD – возвращает значение сегмента адреса объекта X.
    CSEG(X):WORD – возвращает текущее значение регистра Cs.
    DSEG(X):WORD – возвращает текущее значение регистра Ds.
    SSEG(X):WORD – возвращает текущее значение регистра Ss.
    SPRT(X):WORD — возвращает текущее значение регистра Sp.
    PRT(SEG,OFS) – преобразует отдельно заданные значение сегмента и смещения к типу указателя.
    MAXAVAIL:LONGINT — возвращает размер наибольшего непрерывного участка кучи.
    MEMXAVAIL:LONGINT — возвращает размер общего свободного пространства кучи.

    Процедуры:
    DISPOSE(TP:POINTER) – уничтожает динамическую переменную и возвращает в кучу фрагмент динамической памяти, который был зарезервирован
    указателем.
    NEW(TP:POINTER) – резервирует фрагмент кучи для размещения переменной.
    GETMEM(P:POINTER; ZIZE:WORD) –выделяет из кучи блок заданного размера и адрес его начала присваивает указателю.
    FREEMEM(P:POINTER; ZIZE:WORD) – освобождает блок заданного размера..
    MARK(P:POINTER) – запоминает текущую вершину кучи (адрес начала свободного участка).
    RELEASE(P:POINTER) – освобождает участок кучи от адреса с P до конца.

    Пример 19.1. Сгенерировать случайным образом массив случайных чисел. Разместить массив в динамической памяти, найти сумму элементов и удалить его с памяти.

    Текст программы

    Program Dinmas;
    Uses CRT;
    Const k1=100; k2=2*k1+1;
    Type
    Item = Real;
    DinArr = array[1..$FFF0 div SizeOf(Item)] of Item;
    DinPrt = ^DinArr;
    Var
    Arr : DinPrt;
    I,N : Word;
    S :Real;
    f :real;
    <$R->
    Begin
    ClrScr;
    Randomize;
    Writeln(‘Введите количество элементов массива N:’);
    Readln(N);

    GetMem(Arr,N*SizeOf(Item));
    Writeln(‘Введите массив X(N):’);
    For i:=1 to N do
    begin
    f:=random(k2);
    Arr^[i]:=k1-f; Write(Arr^[i]:4:2,’ ‘:2)
    < Read(Arr^[i]);>;
    End;
    Writeln;
    S:=0;
    For i:=1 to N do S:=S+Arr^[i];
    Writeln(^G’Результат:’,^J^M,^G’Сумма=’,S);
    FreeMem(Arr,N*SizeOf(Item));
    Repeat Until KeyPressed
    End.

    Результаты работы программы:

    Введите количество элементов массива N:
    200
    Введите массив X(N):
    -35.00 -82.00 45.00 95.00 -26.00 -72.00 1.00 -77.00 10.00 89.00 -38.00
    -48.00 8.00 26.00 13.00 33.00 6.00 82.00 -63.00 -83.00 -23.00 39.00
    6.00 11.00 48.00 72.00 -100.00 -2.00 93.00 68.00 73.00 66.00 -91.00
    6.00 0.00 -19.00 94.00 32.00 -63.00 59.00 87.00 29.00 -93.00 -51.00 3
    4.00 10.00 58.00 0.00 27.00 41.00 6.00 34.00 55.00 -84.00 7.00 -37.00
    -49.00 -6.00 71.00 11.00 -47.00 -85.00 -53.00 51.00 63.00 -80.00 32.
    00 -71.00 -73.00 -27.00 -15.00 -7.00 -68.00 -89.00 32.00 -22.00 -86.00
    -52.00 27.00 -16.00 92.00 19.00 -35.00 -8.00 -78.00 16.00 -94.00 -47
    .00 -8.00 -98.00 -96.00 -5.00 -68.00 37.00 10.00 82.00 -32.00 15.00 2
    2.00 -21.00 11.00 55.00 -15.00 -54.00 -20.00 -79.00 -15.00 -79.00 -13.
    00 -62.00 -59.00 -93.00 -57.00 -42.00 57.00 41.00 -64.00 -43.00 -71.00
    -66.00 49.00 25.00 66.00 89.00 38.00 98.00 -84.00 64.00 71.00 -75.00
    77.00 83.00 27.00 -88.00 49.00 -100.00 59.00 29.00 -57.00 70.00 33.0
    0 -87.00 -8.00 -45.00 23.00 88.00 -51.00 -66.00 5.00 95.00 -28.00 15.
    00 -1.00 -26.00 -63.00 37.00 -76.00 -1.00 96.00 -43.00 -94.00 -29.00
    -78.00 -99.00 4.00 -80.00 -43.00 -5.00 -6.00 -13.00 -1.00 -75.00 80.00
    43.00 -58.00 -31.00 69.00 -81.00 -71.00 -62.00 -21.00 -84.00 4.00 67
    .00 -82.00 -55.00 25.00 -4.00 94.00 75.00 -55.00 -15.00 -86.00 -43.00
    -92.00 5.00 -81.00 -18.00 -33.00 -71.00
    Результат:
    Сумма=-1.8610000000E+03

    Читать еще:  Техника безопасности при укладке волос

    Пример 19.2. Сгенерировать случайным образом матрицу случайных чисел. Разместить матрицу в динамической памяти, найти сумму элементов и удалить ее с памяти.

    Program Dinmas;
    Uses CRT;
    Type
    Item = Real;
    DinArr=array[1..$Ff div sizeof(item),1..$ff div sizeof(item)] of Item;
    DinPrt = ^DinArr;
    Var
    Arr : DinPrt;
    k,j,l,I,N : Word;
    S :Real;
    <$R->
    Begin
    ClrScr;
    randomize;
    Writeln(‘Введите количество строк массива N:’); Readln(i);
    Writeln(‘Введите количество столбцов массива N:’); readln (j);
    n:=i*j;

    GetMem(Arr,N*SizeOf(Item));
    < Writeln('Введите массив X(N):');>
    For k:=1 to i do
    for l:=1 to j do Arr^[k,l]:=random (2000);
    S:=0;
    For k:=1 to i do
    for l:=1 to j do S:=S+Arr^[k,l];
    Writeln(^G’Результат:’,^J^M,^G’Сумма=’,S);
    FreeMem(Arr,N*SizeOf(Item));
    Repeat Until KeyPressed
    End.

    Результаты работы программы:

    Введите количество строк массива N:
    1000
    Введите количество столбцов массива N:
    1000
    Результат:
    Сумма= 5.7820716634E+32

    Пример 19.3. Разместить запись в динамической памяти, затем удалить ее с памяти.

    Текст программы:

    Program pointer1;
    <Работа с динамической папятью>
    Uses crt;
    Type
    FriendRec = Record
    Name : string[30];
    Age : Byte;
    End;
    FrPtr = ^FriendRec;
    Var
    p : FrPtr;
    Begin
    ClrScr;
    GetMem(p, SizeOf(FriendRec)); <Выделение памяти в куче>
    Write(‘Введите имя : ‘); Readln(p^.Name);
    Write(‘Введите возраст : ‘); Readln(p^.Age);
    Writeln;
    Writeln(‘Память для записи о имени и возрасте распределена в куче.’);
    Writeln;
    Writeln(‘Имя : ‘,p^.Name);
    Writeln(‘Возраст : ‘,p^.Age);
    Writeln;
    FreeMem(p, SizeOf(FriendRec)); <Освобождение памяти>
    Writeln(‘Память, занимаемая записью о имени и возрасте освобождена.’);
    Repeat until KeyPressed;
    End.

    Результаты работы программы:

    Введите имя: Иванов Александр Григорьевич
    Введите возраст: 33

    Память для записи о имени и возрасте распределена в куче.

    Имя: Иванов Александр Григорьевич
    Возраст: 33

    Память, занимаемая записью о имени и возрасте освобождена.

    Вернуться в оглавление:Алгоритмические языки

    Программирование на языке паскаль

    Реклама на сайте

    Опрос

    Рубрики

    Подписка

    Динамическая память

    Динамические структуры – это структуры данных с изменяющимися в процессе работы программы размерами. Такие структуры можно по ходу программы создавать и удалять. Эти данные запоминаются в динамической памяти (ДП). В ДП операционной системой выделяется область (куча). Для динамических структур используются переменные типа-указатель (или указатель). Указатель содержит адрес первого байта переменной в ДП. Длина переменной определяется ее типом. Тип-указатель должен быть объявлен. Если тип объекта, на который ссылается указатель не стандартный, то его нужно объявить до применения указателя. Затем необходимо объявить указатели.

    Свойства указателей

    Указатель – носитель физического адреса в памяти величины базового типа. Указатель имеет размер в 2 слова (4 байта). Создается компилятором в статической памяти.

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

    Можно использовать операцию @:

    Средства работы с динамической памятью

    В модуле System определены средства:

    ВызовСодержание
    New(P)
    New – создать заново,
    P – имя указателя.
    Выделить область памяти для величины базового типа, на которую указывает Р. Ее адрес присвоить указателю Р.
    Dispose(P)
    Dispose – удалить.

    P – имя указателя.

    Освободить область памяти, на которую указывает Р. После выполнения процедуры Р = nil (неопределенно).
    GetMem(P, Size)
    Get Memory –

    получить память,
    P – указатель,
    Size – размер.

    Выделить область памяти размером Size. Ее адрес присвоить указателю Р. Используется для резервирования больших фрагментов ДП.
    FreeMem(P, Size)
    Free Memory –

    освободить память,
    P – указатель,
    Size – размер.

    Освободить область памяти размером Size, на которую указывает указатель Р. После выполнения процедуры Р = nil (неопределенно).
    SizeOf(X)Возвращает длину в байтах Х.
    Addr(X)Возвращает адрес Х.

    Работа с динамическими структурами

    Пример 1 . Создание динамических структур.

    uses SysUtils; // Ссылка на модули

    RecCircle = record // Запись для окружности:

    x:integer; // Координата X центра

    y:integer; // Координата Y центра

    PointerRecord=^RecCircle; // Тип-указатель на запись (нестандартный)

    Pointer1:^Real; // Указатель на вещественное число

    Pointer2:PointerRecord; // Указатель на запись

    Пример 2 . Работа с динамическими структурами.

    uses SysUtils; // Ссылка на модули

    p1:^Byte=nil; // Указатели с инициализацией

    Ссылка на основную публикацию
    Adblock
    detector