ХКОИС
ХРРЦ
Регистрация
Забыли пароль?
Логин:
Пароль:
Поиск
Справочные сведения о системе образования Хабаровского края
Новости образования Хабаровского края
Информация и документы из министерства образования и науки Хабаровского края
Хабаровская краевая заочная физико-математическая школа
РЕГИОНАЛЬНАЯ ОЛИМПИАДА ШКОЛЬНИКОВ
Подготовка к олимпиадам по информатике
Подготовка к олимпиадам по информатикеДополнительные и справочные материалы > Краткий справочник по языку программирования Паскаль (Turbo Pascal)
Краткий справочник по языку программирования Паскаль (Turbo Pascal)
Краткий справочник по языку программирования Турбо – Паскаль
 
 
Общий вид программы
 
            Структура программы на Паскале имеет следующий вид:
 
            Program <имя программы>;
            [ Раздел описаний]
            Begin
            [Список команд]
            End.
             
Примечание.
 
Принято использовать угловые скобки — < > — для указания на то, что параметр является обязательным и квадратные скобки — [ ] — для указания на то, что параметр может быть опущен.
 
            Раздел описаний содержит определение всех элементов, используемых в программе: меток, констант, типов данных, переменных, функций, процедур. Для элементов программы приняты следующее правило: Элемент может быть использован при описании других элементов, только после того, как был описан сам.
            Список команд состоит из последовательности операторов языка программирования и вызовов процедур отделенных друг от друга знаком точка с запятой – «;».
            При записи программ на языке Паскаль используются зарезервированные слова, идентификаторы предопределенных и описанных программистом элементов и знаки препинания и специальные символы, применяемые для описания элементов ( чаще всего связанные со структурными типами данных ) и обращения к ним и их компонентам.
 
Идентификаторы
 
            Идентификаторы или имена элементов, являются определяемыми программистом последовательностями латинских букв и цифр. Для идентификаторов принято следующее соглашение – на первом месте всегда стоит латинская буква, следующие символы могут быть либо латинскими буквами, либо цифрами в любой комбинации, пробелы и другие знаки являются недопустимыми символами.
 
Пример:         D, A1, gamma, delta, v3f.
 
В Турбо – Паскале большие и малые буквы воспринимаются транслятором одинаково, например Dd, DD и dd являются одинаково воспринимаемыми идентификаторами.
            Примечание.
            Первым идентификатором в тексте программы является имя программы.
 
Стандартные простые типы данных в Турбо – Паскале
 
             В Турбо – Паскале определены следующие стандартные простые типы данных, с которыми связаны соответствующие зарезервированные слова.
 
            Числовые
                        Целый                       — integer
            Вещественный                     — real
                        Байтовый                 — byte
 
            Символьные
                        Литерный                 — char
                        Строчный                 — string
 
            Логический                           — boolean
                       
            Для каждого из перечисленных выше типов данных могут определяться константы, составляться соответствующего типа выражения, определяться переменные.
            Диапазоны значений для различных типов данных имеют ограничения. Integer имеет диапазон значений от –MaxInt до MaxInt, где MaxInt – предопределенная системой константа. Byte – 0..255. Char имеет значением один символ из таблицы символов компьютера. String – цепочка символов длинной от 0 до 255 (строго говоря – этот тип является не простым, а структурным (сложным)). Boolean имеет два значения — True (истина) и False (ложь).
            Для перечисленных выше типов данных имеются предопределенные процедуры для операций ввода (кроме boolean) и вывода в текстовом виде.
            Типы данных логический, целый, байтовый, литерный относятся к так называемым перечисляемым типам, то есть таким для каждого значения которых однозначно определены предыдущий и следующий элементы.
 
Раздел описаний
 
            В Турбо – Паскале элементы, в отличие от стандартного Паскаля, могут описываться в произвольном порядке.
            Описанию элемента предшествует зарезервированное слово, указывающее его вид. Затем следует описание элемента.
            Метки                         Label
            Константы                 Const
            Типы                           Type
            Переменные            Var
            Функции                      Function
            Процедуры               Procedure
            Форматы описания элементов:
            Метки
                        <целое число1>[, <целое число2> и так далее];
            Константы
                        <идентификатор1>=<значение1>;
                        [<идентификатор2>=<значение2>;]
                        … … … …
            Типы
                        <идентификатор1>=<описание типа1>;
                        [<идентификатор2>=<описание типа2>;]
                        … … … …
            Переменные
                        <идентификатор11>[,<идентификатор12>, …]:<тип1>;
                        [<идентификатор12>[,<идентификатор22>, …]:<тип2>;]
                        … … … …
 
            Приведем пример содержащий описания элементов некоторых типов
 
            Program prim01;
            Label
                        1,5;
            Const
                        H=4.3;
            Type
                        F=array [1..8] of real;
            Var
                        A,b,c:integer;
                        X:f;
            ……………
           
Основные операторы и предопределенные процедуры Турбо – Паскаля
 
Оператор присваивания
 
            Оператор присваивания предназначен для задания переменной вычисляемого значения соответствующего выражения. Выражения составляются с использованием констант (предопределенных, определенных программистом, непосредственно вписанных в выражение), переменных, функций с использованием знаков допустимых для данных типов данных выражений и круглых скобок.
 
            Формат оператора присваивания:
 
<идентификатор переменной>:=<выражение>;
 
            Тип выражения должен совпадать с типом переменной или быть совместим с ним.
 
            Пример
 
            Program prim02;
            Var
                        A,b,c:integer;
            Begin
                        A:=4;
                        b:=a+3;
                        c:=a+b
            End.
Таблица символов операций
 
 
Integer, byte
Real
String
Boolean
+
*
*
*
 
-
*
*
 
 
*
*
*
 
 
/
 
*
 
 
Div
*
 
 
 
mod
*
 
 
 
Or
*
 
 
*
And
*
 
 
*
Not
*
 
 
*
Xor
*
 
 
*
Not
*
 
 
*
 
Таблица символов отношений
 
Больше
Меньше
Больше или равно
>=
Меньше или равно
<=
Неравно
<> 
Равно
=
 
            Для строковых типов данных имеют смысл только отношения «равно» и «неравно».
Обратите внимание, что операция возведения в степень в Паскале не определена.
 
Процедуры ввода и вывода
 
Процедуры ввода являются предопределенными.
Формат процедур:
 
Ввод данных
 
Read[(<список ввода>)];
ReadLn[(<список ввода>];
 
Суффикс Ln означает, что после ввода значений курсор переходит на начало следующей строки экрана.
Список ввода состоит из идентификаторов переменных, отделенных друг от друга запятой.
 
Вывод данных
 
Write[(<список вывода>)];
WriteLn[(<список вывода>];
 
Суффикс Ln означает, что после вывода значений курсор переходит на начало следующей строки экрана.
Список вывода состоит из идентификаторов переменных и выражений, отделенных друг от друга запятой.
В списке вывода могут присутствовать параметры задающие формат вывода результатов. После идентификатора следует двоеточие и число определяющее число знакомест для вывода, после второго двоеточия указывается количество знаков после запятой.
 
Пример
 
            Program prim03;
            Var
                        b,c:integer;
                        v:real;
            Begin
                        Write('b=');
                        Readln(b);
                       Write('c=');
                        Readln(c);
                        v:=(b+c)/3.56;
                        Writeln('v=',v:6:2)                  
            End.
 
Для переменной v определено для вывода поле шириной 6 позиций, в том числе две позиции для знаков после десятичной точки, которая так же займет одну позицию из 6.
 
Условный оператор
 
            Условный оператор имеет две формы: полную и неполную.
 
Формат оператора
1.      полная форма
 
            If <логическое выражение>           then <инструкция1> else <инструкция2>;
 
            Если логическое выражение имеет значение «истина», то выполняется инструкция1, иначе инструкция2.
 
2.      неполная форма
 
            If <логическое выражение>           then <инструкция>;
 
            Если логическое выражение имеет значение «истина», то выполняется инструкция, иначе управление передается следующей после условного оператора команде. Обратите внимание на то, что логическое выражение может представлять собой логическую переменную или логическую функцию, сравнение их со значениями True или False не требуется.
Инструкция представляет собой либо одну команду, либо список команд, отделенных друг от друга символом точка с запятой и заключенный в так называемые инструктивные скобки begin — end. В Паскале имеются алгоритмические конструкции, которые сами выполняют роль инструктивных скобок, в этом случае внешние скобки begin – end могут быть опущены.
 
Пример
 
            Program prim04;
            Var
                        b,c:integer;
                        v:real;
                        g:boolean;
            Begin
                        Write('b=');
                        Readln(b);
                       Write('c=');
                        Readln(c);
                        g:=c<b;
                        if g       then
begin
v:=(b+c)/3.5;
v:=v/(v+1)
end
                                    else
                                                v:=b-c/5;
                        Writeln('v=',v:6:2)                  
            End.
 
            Program prim05;
            Var
                        b,c:integer;
                        v:real;
            Begin
                        Write('b=');
                        Readln(b);
                       Write('c=');
                        Readln(c);
                        if c<b   then
begin
v:=(b+c)/3.5;
v:=v/(v+1)
end;
                        if c>=b then
                                                v:=b-c/5;
                        Writeln('v=',v:6:2)                  
            End.
 
 
            Приведенные выше примеры программ показывают варианты решения одной и той же задачи с использованием логической переменной  и без нее, а так же применяя полную и неполную форму условного оператора.
 
Повторения
 
            Повторения (циклы) реализуются в Турбо – Паскале тремя видами операторов цикла.
 
1.      Оператор цикла с предусловием (цикл пока)
 
Формат оператора
 
While <логическое выражение> do
            [<инструкция>];
 
 
Выполнение инструкция повторяется пока логическое выражение имеет значение «истина». Проверка условия производится перед выполнением инструкции.
 
2. Оператор цикла с постусловием (цикл до тех пор)
 
Формат оператора
 
Repeat
<список команд>
until <логическое выражение>;
 
Инструкция выполняется, после этого происходит проверка значения логического выражения. Повторение выполнения инструкции прекращается когда логическое выражение получает значение «истина».
3.      Цикл с параметром (цикл со счетчиком).
 
Форматы оператора
 
For <идентификатор переменной>:=<выражение1> to <выражение2> do
[<инструкция>];
 
            Для значений переменной от  выражение1 до выражение2 выполняется инструкция, происходит переход к следующему значению переменной.
 
For <идентификатор переменной>:=<выражение1> downto <выражение2> do
[<инструкция>];
 
            Для значений переменной от  выражение1 до выражение2 выполняется инструкция, происходит переход к предыдущему значению переменной.
            Переменная должна быть перечисляемого типа (смотрите выше).
Операция имеет смысл, если для выражение1 и выражение2 выполняются соответственно отношения меньше или равно для первого варианта и больше или равно для второго.
           
Пример
 
            Program prim06;
            Var
                        b,c:integer;
                        v:real;
            Begin
                        Write('b=');
                        Readln(b);
                        c:=1;
                        while c<=20 do
                        begin
                        v:=(b+c)/3.56;
                        Writeln('v=',v:6:2);
                        c:=c+1
                        end     
            End.
 
            Program prim07;
            Var
                        b,c:integer;
                        v:real;
            Begin
                        Write('b=');
                        Readln(b);
                        c:=1;
                        repeat
                        v:=(b+c)/3.56;
                        Writeln('v=',v:6:2);
                        c:=c+1
                        until c>20
            End.
 
             Program prim08;
            Var
                        b,c:integer;
                        v:real;
            Begin
                        Write('b=');
                        Readln(b);
                        For c:=1 to 20 do
                        begin
                        v:=(b+c)/3.56;
                        Writeln('v=',v:6:2);
                        end     
            End.
 
            Program prim09;
            Var
                        b,c:integer;
                        v:real;
            Begin
                        Write('b=');
                        Readln(b);
                        For c:=20 downto 1 do
                        begin
                        v:=(b+c)/3.56;
                        Writeln('v=',v:6:2);
                        end     
            End.
 
            В приведенных выше примерах показаны различные способы вычисления с выводом на печать значений выражения.
 
Функции и процедуры в Паскале
 
            Процедурой в Паскале является специально выделенная часть задачи представляющая собой специально оформленный самостоятельный фрагмент программы.
Введение процедур связано не столько с необходимостью избежания повторения одного и того же фрагмента программного кода, который встречается в различных частях программы, а с подходом к разработке программ называемым структурным программированием. Подход состоит в том, что задача разбивается на отдельные подзадачи, которые отдельно решаются, отлаживаются и тестируются, возможно разными программистами, затем строится главная программа.
            Описание процедуры производится в разделе описаний и имеет следующий общий вид:
 
            Procedure <идентификатор>[(описание формальных параметров)];
            <раздел описаний>
            begin
            <список команд>
            end;
 
            Вызов процедуры в программе или другой функции или процедуре производится указанием ее идентификатора и перечислением в круглых скобках фактических параметров, если они есть:
 
<идентификатор>[(<список фактических параметров>)].
 
Функцией в Паскале называется процедура, результатом выполнения которой является вычисление и передача в программу некоторого значения.
 
            Описание функций производится в разделе описаний и имеет следующий общий вид:
 
Function <идентификатор>[(описание формальных параметров)]:<тип результата>;
            <раздел описаний>
            begin
            <список команд>
            end;
 
            Для передачи результата в программу выполняется операция присваивания вида <идентификатор>:=<выражение>;
 
            Вызов функции в программе или другой функции или процедуре производится указанием ее идентификатора и перечислением в круглых скобках фактических параметров, если они есть:
 
<идентификатор>[(<список фактических параметров>)].
 
            Раздел описаний для функций и процедур имеет тот же смысл и структуру, что и для главной программы.
Если в разделе описаний процедуры или функции описаны некоторые элементы, то они являются определенным только для этой процедуры или функции и вложенных в них элементов.
Выполняется правило изменения описания элементов с одинаковыми идентификаторами во вложенных элементах. Действительным является самое последнее из предшествующих описаний.
Формальные параметры описываются в заголовке процедуры или функции и являются локальными. Они используются для программирования кода. При вызове процедуры или функции формальные параметры заменяются фактическими. При этом типы параметров должны совпадать. Типы совпадают, только если при описании формальных и фактических переменных использовались одни и те же имена типов (предопределенных или определенных программистом).
Параметры могут передаваться одним из двух способов по значению или по ссылке (как переменные). При передаче параметров по значению в памяти компьютера отводится место для их размещения и туда копируются значения параметров. При передаче параметров по ссылке для описанных формальных параметров устанавливается связь с соответствующими фактическими параметрами. При этом модификация параметра в процедуре или функции влечет за собой изменение значений указанных в списке фактических параметров переменных, чего не происходит при передаче параметров по значению.
Описанию формальных параметров – переменных (передаваемых по ссылке) перед ними должно стоять зарезервированное слово var.
 
Пример
 
Procedure pr1(x,y:real;var z:integer);
 
Описаны формальные параметры – значения x и y и параметр  — переменная z.
 
Function fn1(a,b:integer):real;
 
Описаны формальные параметры – значения a и b.
 
Пример
 
Program prim10;
            Var
                        d,e:integer;
            procedure pr2(b,c:integer);
            var
                        v:real;
            Begin
                        v:=(b+c)/3.56;
                        Writeln('v=',v:6:2);
            End;
            Begin
                        Write('d=');
                        Readln(d);
                        For e:=1 to 20 do
                                    Pr2(d,e)
            End.
  
Процедура производит вычисление и печать значений переменной v, определенной как локальная в процедуре.
  
Program prim11;
            Var
                        d,e:integer;
            function fn2(b,c:integer):real;
            Begin
                        Fn2:=(b+c)/3.56;
            End;
            Begin
                        Write('d=');
                        Readln(d);
                        For e:=1 to 20 do
                        Writeln('v=',fn2(d,e):6:2);
            End.
 
Функция используется для вычисления значения выражения, которое распечатывается в основой программе.
 
Рекурсия
 
            В Паскале возможно применения рекурсии в процедурах и функциях. Под рекурсией понимается такой вычислительный процесс, когда процедура или функция явно или неявно вызывает саму себя.
            Рассмотрим два способа вычисления числа N! – N — факториал. Имеют место два эквивалентных определения N!.
 N!=1*2*3*4*…*(N-1)*N – последовательное произведение N натуральных чисел и
 
Второе определение N! является рекурсивным, в нем следующее значение определяется через предыдущее. В приведенных ниже программах реализованы функции nff1 и nff2 соответственно для первого и второго определений факториала. В первой функции производится вычисление значения с помощью цикла с параметром. Во второй функции явно цикл отсутствует, однако фактически происходит циклический процесс через рекурсивное обращение к функции nff2 с параметром на 1 меньше, чем переданный при вызове функции. Каждый новый вызов функции nff2 приводит к выделению в памяти компьютера места для размещения значений передаваемого параметра и результата. При достижении значения параметра 0, значение результата определяется равным 1 и происходит процесс вычисления всех следующих значений функции.
 
Program NF1;
Var
            N:integer;
Function nff1(k:integer):real;
Var
            I:integer;
            X:real;
Begin
            X:=1;
            For I:=1 to k do
                        X:=X*I;
            nff1:=X
end;
Begin
            Write('N=');
            Readln(N);
            Writeln(nff1(N))
End.
 
Program NF2;
Var
            N:integer;
Function nff2(k:integer):real;
Begin
If k=0 then nff2:=1
            else  nff2:=nff2(k-1)*k
end;
Begin
            Write('N=');
            Readln(N);
            Writeln(nff2(N))
End.
 
 
Типы данных, определяемые пользователем
 
            Язык Паскаль имеет мощные возможности для конструирования пользователем собственных типов данных. Описание типов данных позволяет создавать такие структуры данных, которые позволяют решать задачи более оптимальными способами, делать решение более наглядным, установить соответствие между принятыми в теоретических исследованиях и реализуемых в программировании структурах данных.
            В Паскале имеют место простые типы данных и сложные или структурные. Сложные типы данных представляют собой набор компонентов связанных общим именем и расположенных в смежной области памяти. Доступ к компонентам производится с использованием так называемых косвенной и индексной адресации, тогда как к простым типам данных применяется прямая адресация.
            Основными типами структурных данных относятся массивы (array) и записи (record).
 
Массивы
 
            Массив является сложной переменной, представляющей собой связанный общим именем набор элементов одного базового типа, доступ к компонентам которой производится с использованием индексов.
            Описание типа массив производится в разделе описаний и имеет следующий формат.
            Type
                        <имя типа>=array <диапазон индексов> of <имя базового типа>;
            Диапазон индексов определяет количество измерений и набор значений каждого из них.
            Диапазон индексов задается перечисляемым типом и является чаще всего отрезком такого типа. Применение в качестве индексов отрезков типа Char или определенного пользователем перечисляемого типа повышает наглядность и, в некоторых случаях, упрощает программирование. Однако все реальные потребности могут быть покрыты применением отрезков целого типа.
 
Пример
 
            Type    Ar1=array [1..20] of real;     
                        Ar2=array ['a'..'z'] of integer;
                        Ar3=array [1..10,1..5] of integer;
                        Ar4=array [1..10] of ar1;
 
Приведенный пример описывает типы одномерных массивов Ar1, Ar2, двумерный массив Ar3 и массив Ar4, компонентами которого являются одномерные массивы типа Ar1.
            Описание переменных имеющих тип массив может выглядеть следующим образом:
 
            Var      A:ar1;
                        B:ar4;
                        C:ar3;
 
Доступ к компонентам массивов производится указанием в квадратных скобках выражений, определяющих значение индекса.
            Для приведенного выше примера описания переменных возможны следующими способами.
 
1.            A[1]:=3.5;
2.            B[6]:=A;
3.            B[5][4]:=A[3];
4.            C[2,4]:=10;
 
Для массива массивов возможны присваивания приведенные во втором примере. Для массива имеющего в качестве базового типа сложный (B типа Ar4) обращение к компонентам вложенного типа производится через приписывание справа дополнительных скобок с указанием индекса.
 
Пример
 
Program NF3;
Type    Ar=array[1..20] of real;
Var      N,m:integer;
            A:Ar;
Function nff1(k:integer):real;
Var
            I:integer;
            X:real;
Begin
            X:=1;
            For I:=1 to k do
                        X:=X*I;
            nff1:=X
end;
Begin
            Write('N=');
            Readln(N);
For m:=1 to N do
            Begin
            A[m]:=nff1(m);
            Writeln(A[m])
            end
End.
 
            Приведенный выше пример программы формируем и распечатывает массив значений факториала.
 
Записи
 
            Запись является сложной переменной, представляющей собой связанный общим именем набор элементов различных базовых типов — полей, доступ к компонентам которой производится с использованием имени поля. Описание типа запись производится в разделе описаний и имеет следующий формат.
 
            Type
                        <имя типа>=record
<имя поля1>:<имя базового типа1>;
<имя поля2>:<имя базового типа2>;
<имя поля3>:<имя базового типа3>;
……………
                        end;
 
Правила выбора имени поля такие же, что для всех остальных идентификаторов. Приведем пример описания типа запись и переменных такого типа, а так же доступа к их компонентам.
 
            Type
                        Anket=record
                                    Name:string;
                                    Rost:integer;
                                    Date:integer
                        End;
                        Mass=array [1..20] of anket;
            Var
                        A:anket;
                        D:mass;
            Begin
                        a.name:='Сидоров';
                        d[8].rost:=123;
                        d[3]:=a;
                        a.date:=12;
 
В приведенном примере описана запись содержащая 3 поля и массив состоящий из таких же записей. Показаны правила обращения к компонентам массива записей и записи.
 
Множества
 
В Турбо – Паскале имеется специальный тип данных реализующий конечные множества. Модель множества представляется в виде двоичного числа. Если элемент принадлежит множеству, то соответствующий ему разряд двоичного числа имеет значение 1, если не принадлежит, то 0. Описание типа множества производится в разделе описаний типов и имеет следующий формат.
 
Type
            <имя типа>=set of <базовый тип>;
 
Базовый тип является отрезком перечисляемого типа и имеет длину не более 256 элементов.
 
Пример описания
Type
            Mn1=set of byte;
            Mn2=set of 1..10;
            Mn3=set of 'a'..'z';
 
            В первом случае определен тип множества состоящего из 256 элементов типа Byte, во втором из 10 элементов целого типа, в третьем из отрезка типа Char включающего все малые латинские литеры.  Для определенных выше типов можно определить переменные.
 
            Var
                        C:Mn1;
                        D:Mn2;
                        E,F:Mn3;
 
Для работы с множествами введены специальные операции и отношение принадлежности.
 
Операции над множествами в Паскале:
 
Объединение множеств (+): E:=E+F, в E включены все элементы которые были в множествах E и F.
Преобразование элементов базового типа в множество ( [ ] ): E:=[], пустое множество. F:=['a'..'z'], включены все элементы базового множества. C:=[2,6], входят только элементы 2 и 6. D:=[i], где i – целое число, множество состоящее из элемента со значением равным значению переменной i.
 
            Пересечение множеств (*): E:=E*F, входят только те элементы, которые были как в первом, так и во втором множествах.
 
            Разность множеств (-): E:=E-F, в E остаются только те элементы, которых нет в множестве F.
 
Отношение принадлежности имеет значение «истина» если элемент базового типа принадлежит множеству и «ложь» в противном случае.
 
Формат
 
<выражение базового типа> in <множество>
 
Например: i in D, где i – переменная целого типа.
 
Пример
 
Program mnog;
Type
            Mn=Set of 1..20;
Var
            I:integer;
            D:Mn;
Begin
            D:=[1..20];
For i:=1 to 10 do
            D:=D-[2*i];
For i:=1 to 20 do
            If i in D then
                                    Writeln(i)
End.
 
В данном примере создается множество из 20 элементов, затем из него исключаются все четные элементы и распечатываются значения тех элементов, которые остались в множестве.
 
Динамические переменные и указатели
 
            Выше были описана работа с переменными, которые размещаются в памяти компьютер при запуске программы, обращении к процедуре или функции. Они занимают память все время выполнения вычислительного процесса и не могут быть созданы или уничтожены непосредственно в ходе вычислительного процесса. Такие переменные называются статическим.
            Кроме статических переменных в Паскале определены так же и динамические, то есть такие, которые могут создаваться и уничтожаться непосредственно в ходе вычислительного процесса.
            Типы значений динамических переменных задаются таким же образом, как и для статических. Управление динамическими переменными и доступ к их компонентам осуществляется посредством специального типа переменных – указатели.
            Переменная типа указатель содержит информации о размещение в памяти динамической переменной, на которую она указывает. Кроме того, устанавливается соответствие между указателем и типом переменной, на которую он указывает.
            Динамическая переменная создается специальной процедурой (new) параметром которой является переменная типа указатель.
 
            Описание переменной – указателя:
            Type
                        <имя типа — указателя>=^<имя типа — переменной>;
 
Пример
            Type
                        Uk=^integer;
            Описан указатель на динамическую переменную целого типа.
            Var
                        Dp:uk; — описана переменная – указатель.
Begin
New(Dp);       {в памяти создана переменная целого типа и связана с переменной – указателем}
Dp^:=30;        {динамической переменной присвоено значение}
Dp:=nil;   {переменная — указатель получила значение пустой указатель, показывающее, что она не связана ни с какой переменной}
           End.
 
            Переменные – указатели используются как компоненты сложных типов – записей и массивов для создания различных структур данных: одно и многосвязных списков, стеков, очередей, деревьев.
 
Файлы
 
            Под файлом будем понимать специально организованную специфицированную структуру данных на внешнем устройстве.
            Ниже справочно приводятся основные понятия, процедуры и функции для управления файлами.
            Для управления файлами определяются специальные переменные файлового типа.
 
Текстовые файлы                          <имя файловой переменной>:text;
Типизированные файлы               <имя файловой переменной>:file of <имя базового типа>;
Не типизированные файлы          <имя файловой переменной>:file;
 
Отождествление файловой переменной с физическим файлом производится процедурой
 
assign(<имя файловой переменной>,<спецификация файла>).
 
Открытие файла производится процедурами
 
reset(<имя файловой переменной>) для чтения
rewrite(<имя файловой переменной>) для записи.
 
Чтение данных из файла производится процедурами
 
read(<имя файловой переменной>,<список ввода>) 
readln(<имя файловой переменной>,<список ввода>) – только для чтения из текстового файла.
 
Запись данных в файл производится процедурами
 
write(<имя файловой переменной>,<список вывода>)
writeln(<имя файловой переменной>,<список вывода>) – только для записи в текстовый файл.
 
Функция eof(<имя файловой переменной>) имеет значение «истина» если достигнут конец файла и «ложь» в противном случае.
 
Закрытие файла производиться процедурой close(<имя файловой переменной>).
Copyright © 2005–2017 ХабЦНИТ ТОГУ Отправить письмо
Создание сайтов в Хабаровске
В этом магазине лепнины продаются полиуретановый молдинг с большой скидкой! cвой бизнес