(5 оценок, среднее: 4,80 из 5)
Загрузка...
Учебная работа. Реферат: Структура Паскаль-программы
Программка на языке Паскаль состоит из последующих частей:
Заголовок
Подключение модулей
Раздел описаний
Begin
Раздел операторов
End.
Заголовок
– необязателен. Начинается с главного слова program.
Program <имя>;
Подключение модулей
– ключевое слово uses.
Uses <имя1>, <имя2>, …, <имя n>;
Раздел описаний
– состоит из нескольких подразделов.
Подраздел Label – описание меток.
Label <имя>, <число>;
Const– описание констант.
Type – описание типов.
Var– описание переменных.
Function– описание функций.
Procedure – описание процедур.
Раздел операторов
– содержит деяния, предписанные методом.
Раздел описаний вместе с разделом операторов именуется блоком.
Program My_First_program;
Var n1, n2: integer;
x: real;
Begin
Write(‘n1=’); readln(n1);
Write(‘n2=’); readln(n2);
x := n1 / n2;
Writeln(‘n1/n2= ‘, x);
End.
Процедура – некая последовательность операторов языка Паскаль, к которой можно обратиться по имени.
Системы типов языка. Обычные типы.
В языке Паскаль неважно какая константа, переменная, системы типов языка Паскаль.
См. рис.1.
Логический (булевский) тип.
Boolean – идентификатор логического типа. Может принимать два значения: False(0) либо True (1). Занимает 1 б.
ByteBool – 1 б.
WordBool – 2 б.
LongBool – 4 б.
Операции дела: >, <, >=, <=, =, <>. Результаты этих операций имеют логический тип.
В Паскале есть четыре логические операции: and (логическое И), or(логическое ИЛИ), xor (исключающее ИЛИ, сложение по модулю 2, отрицание равнозначностей), not (отрицание).
(x > 1) and (x < 2) – пример логических операций.
Целые типы.
Эта группа типов обозначает огромное количество целых чисел в разных спектрах.
Integer – длина 2 б. От -32768 до 32767.
Byte– длина 1 б. От 0 до 255.
Word– длина 2 б. От 0 до 65535.
Shortint – длина 1 б. От -128 до 127.
Longint– длина 4 б. От -2^31 до 2^31-1.
Операции:
+, -, *, /, div, mod.
Все операции, не считая деления, для целых данных дают итог целого типа. Деление постоянно даёт итог вещественного типа.
Обычные процедуры и функции, применимые к данным целого типа.
Odd(
x):
boolean
– функция возвращает True, если число нечётное, и False– в неприятном случае.
Порядковыми именуются типы, значения которых можно перечислить по порядку. Boolean тоже относится к порядковому типу.
Pred(
x)
– предшествующее
Succ(
x)
– последующее
Inc(
x)
– функция роста на единицу.
Inc(
x,
n)
– процедура наращивает
Dec(
x)
– функция уменьшения на единицу.
Dec(
x,
n)
– процедура уменьшает 1-ый параметр на n.
Вещественный тип.
Эта группа типов обозначает огромное количество вещественных значений в разных спектрах.
Real – идентификатор вещественного типа. Длина памяти – 6 б. Спектр: от 2,9*10^-39 до 1,7*10^38. В памяти машинки величины типа Realпредставляются так: символ порядка, порядок, мантисса.
Single– длина 4 б. От 1,1*10^-45 до 3,4*10^38. Представляется так: символ порядка, мантисса, порядок.
Double – длина 8 б. От 5,0*10^-324 до 1,7*10^308.
Extended– длина 10 б. От 3,4*10^-4932 до 1,1*10^4932.
Comp – длина 8 б. От -2^63 до 2^63-1.
Операции:
Арифметические: +, -, *, /. Итог – вещественного типа.
Операции дела.
Обычные процедуры и функции, применимые к данным вещественного типа.
имя
Тип аргумента
Тип результата
Вычисление
Абс(x)
целый либо вещ.
тип аргумента
Модуль x
Arctan(x)
целый либо вещ.
вещественный
Арктангенс x
Cos(x)
целый либо вещ.
вещественный
Косинус x
Exp(x)
целый либо вещ.
вещественный
E в степени x
Ln(x)
целый либо вещ.
вещественный
Натуральный лог. x
Sin(x)
целый либо вещ.
вещественный
Синус x
Sqr(x)
целый либо вещ.
тип аргумента
Квадрат x
Sqrt(x)
целый либо вещ.
вещественный
Корень из x
Frac(x)
вещественный
вещественный
Дробная часть аргум.
Int(x)
вещественный
вещественный
Целая часть аргумента
Pi
—
вещественный
Число Пи
Round(x)
вещественный
целый
Округление до целого
Trunc(x)
вещественный
целый
Целая часть аргумента
Символьный тип.
Char – идентификатор символьного типа. Знаки с кодом от 0 до 127 соответствуют ASCII. Знаки с кодом от 128 до 255 не ограничены эталонами. Длина типа Char– 1 б. значения – коды знаков от 0 до 255. Знаки в тексте программки записываются в одиночных апострофах.
Операции:
операции дела.
Символьные типы относятся к порядковому типу.
Обычные процедуры и функции, применимые к данным символьного типа.
имя
Тип аргумента
Тип результата
Итог
Ord(x)
символьный
целый
Код знака
Chr(x)
byte
символьный
По коду — знак
Pred(x)
символьный
символьный
Предшествующий знак
Succ(x)
символьный
символьный
Последующий знак
Upcase(x)
символьный
символьный
Перевод в верхний регистр
Тип именуется скалярным, если он не раскладывается на составные части.
Раздел определения констант.
Константы
– это данные, которые в процессе выполнения программки недозволено поменять.
Все константы делятся на литеральные и именованные.
Литеральные константы
– это все числа, знаки и строчки знаков в тексте программки.
Именованные константы
– фиксированное
С
onst
– идентификатор раздела констант.
const<имя> = <значение>;
Тип константы определяется её изображением (методом её записи). Константы бывают целые, вещественные, символьные и строковые.
Целые константы
– задаются десятеричным либо шестнадцатеричным числом (шестнадцатеричные – со знаком $ сначала).
Вещественные константы
могут создаваться форматом с фиксированной точкой либо с плавающей точкой.
Символьные константы
– одиночный знак с апострофами либо строчка с апострофами.
Раздел описания меток.
Метка в Паскале – это десятичное число либо верный идентификатор. Предназначение метки – помечать оператор.
Label
– идентификатор раздела меток.
Раздел описания переменных.
Var
–идентификатор раздела переменных.
var <имя>: <тип>;
x: real;
x, y, z, a: integer;
В Паскале введено понятие типизированных констант
. На самом деле, это – переменная с данным исходным значением. Типизированные константы описываются в разделе constследующим образом: <имя>: <тип> = значение;
x: integer= 10;
При описании переменных в одном блоке не быть может схожих имён. Для переменных, обрисованных в блоке, выделяется объём памяти размером 64 кБ.
Определение типов.
Type
– идентификатор раздела типов.
type <имя> = <описание типа>;
letters = ‘A’..’Z’;
Тип, который создаётся ограничением спектра вероятных значений какого-нибудь порядкового типа, именуется ограниченным типом. Тип, на который накладываются ограничения, именуется базисным типом.
interval = 0..100;
Базисные типы: все целые типы и тип Char.
Перечислимые типы
– задаются перечислением тех значений, которые он может получать. Каждое
Пример: Color = (Red, Yellow, Green);
За каждым именованием из этого перечня закреплено определённое недозволено.
var z: letters;
index: interval;
my_letter: ‘a’..’z’;
Выражения.
Главными объектами, из которых состоит исполняемая часть программки, являются константы, переменные и воззвания к функциям. Любой из этих объектов характеризуется своим значением и принадлежит к какому-либо типу данных.
Выражение
– это формальное правило для вычисления новейшего значения. Выражением быть может одиночный объект (константа, переменная, воззвание к функции) либо несколько операндов, разделённых знаками операций.
Операции
– определяют действие по вычислению новейших значений, исходя из значения операндов.
Все операции Паскаля можно поделить на 4 группы по ценностям: 1) унарные операции (логическое not, операция взятия адреса); 2) мультипликативные операции (умножение, деление, деление нацело, взятие остатка от целочисленного деления, логическое and, операции сдвига – shlи shr); 3) аддитивные операции (сложение, вычитание, логическое or, логическое xor); 4) операции дела (проверка на равенство либо неравенство, операции сопоставления, операция проверки принадлежности к огромному количеству – in).
Для логических выражений типично то, что их
Options – Compiler – BooleanEvaluation– выбор типа вычисления логических выражений.
Операторы.
Это синтаксические конструкции, предназначенные как для записи действий по преобразованию данных, так и для задания порядка выполнения остальных действий. язык Паскаль содержит всего 11 операторов: 1) оператор присваивания; 2) оператор процедуры; 3) оператор перехода; 4) составной оператор; 5) условный оператор; 6) оператор варианта; 7, 8, 9) операторы цикла; 10) оператор над записями; 11) пустой оператор. Не считая того, есть операторы машинного кода и ассемблера.
Оператор присваивания.
<идентификатор> := <выражение>;
Выражение обязано давать итог такового же типа, как и переменная. Присваивание допустимо для всех типов, не считая файловых.
Оператор процедуры.
Другое заглавие – вызов процедуры
.
<имя процедуры>(<характеристики>);
Оператор процедуры вызывает выполнение операторов, которые находятся в теле процедуры.
Оператор перехода.
Этот оператор вызывает передачу управления оператору, которому предшествует метка.
goto <метка>;
Все метки, применяемые в блоке, должны быть описаны, причём не наиболее 1-го раза.
Метка, обозначенная в операторе перехода, обязана помечать оператор, находящийся в том же блоке.
Переход вовнутрь структурного оператора может вызвать непредсказуемые эффекты, хотя компилятор не выдаст сообщение о ошибке.
Составной оператор.
Это последовательность операторов программки, заключённая в операторные скобки begin-end.
Условный оператор.
При помощи условного оператора реализуется структура «развилка». В Паскале два вида условного оператора: с ветвью elseи без ветки else.
if <выражение> then <оператор1> else <оператор2>;
if <выражение> then <оператор>;
if <выражение1> thenif <выражение2> then <оператор1> else <оператор2>;
elseвсегда относится к наиблежайшему if.
var a, b, c, d: integer;
begin
a := 1; b := 2; c := 3; d := 4;
if a > b then if c < d then if c < 0 then c := 0 else a := b;
If a > b then if c < d then if c < 0 then c := 0 else else else a := b;
Разглядим пример программки, которая вводит случайное десятичное число от 0 до 15 и выводит его в шестнадцатеричном формате.
program Hex1;
var ch: char;
n: integer;
begin
write(‘n = ‘); readln(n);
if (n >= 0) and (n <= 15) then
begin
if n < 10 then ch := chr(ord(‘0’) + n)
else ch := chr(ord(‘A’) + n — 10);
writeln(‘n = ‘, ch);
end
else writeln(‘Ошибка.’);
end.
Оператор варианта.
Реализует структуру «выбор», другими словами возможность выбирать из нескольких альтернатив. Оператор работает последующим образом: поначалу рассчитывается выражение. Это выражение время от времени именуется селектором либо ключом выбора. Выражение обязано давать итог хоть какого порядкового типа. Опосля этого вычисленное
case <выражение> of
<константа выбора1>: <оператор1>
<константа выбора2>: <оператор2>
…
<константа выбора n>: <оператор n>
[else <оператор>]
end;
Пример.
var color: (Green, Yellow, Red);
begin
color :=
case color of
Red: x := y + 2;
Yellow: x := y – 2;
Green: x := y;
end;
Не считая одиночных констант в кандидатурах могут быть заданы несколько констант для каждой кандидатуры (в этом случае они делятся запятыми) либо спектры значений. Пример:
case switch of
1..3: Proc1;
4, 10..20: Proc2;
5, 6: Proc3;
else Proc4;
end;
var ch: char;
begin
readln(ch);
case ch of
‘n’, ‘N’: writeln(‘Нет’);
‘y’, ‘Y’: writeln(‘Да’);
end
end.
При использовании оператора варианта должны производиться последующие правила: 1) один оператор в каждой кандидатуре. Если нужно выполнить несколько операторов, следует создавать составной оператор.
Операторы цикла.
В Паскале существует три вида циклов: цикл с предусловием, цикл с постусловием и цикл с параметром.
Оператор цикла с предусловием.
while <выражение> do <оператор>
В качестве примера использования whileрассмотрим программку, выводящую малое, не равное нулю вещественное число эпсилон, которое опосля прибавления его к единице ещё даёт итог, хороший от единице.
var epsilon: real;
begin
epsilon := 1;
while epsilon / 2 + 1 > 1 do epsilon := epsilon / 2;
writeln(‘Машинный epsilon = ‘, epsilon);
end.
Оператор цикла с постусловием.
repeat
<операторы>
until <выражение>
Пример: программка вводит знак и печатает его код, пока не будет нажата кнопка Enter.
begin
repeat
readln(ch);
writeln(ch, ‘=’, ord(ch));
until ord(ch) = cr;
end.
Оператор цикла с параметром.
Употребляется тогда, когда заблаговременно понятно число повторений цикла. Этот оператор предугадывает повторное выполнение тела цикла с одновременным конфигурацией по правилу арифметической прогрессии параметра цикла.
for <имя> := <выражение1> to <выражение2> do <оператор>
for <имя> := <выражение1> downto <выражение2> do <оператор>
Выполнение оператора цикла с параметром:
1) Рассчитывается выражение 1, определяющее изначальное
2) Параметру цикла присваивается это
3) Параметр цикла сравнивается с конечным значением. Если он больше конечного значения, то цикл завершается.
4) Производится тело цикла.
5) Значение параметра меняется на 1. Переход к шагу 3).
Пример: программка, находящая сумму целых чисел от 1 до n.
var i, n, s: integer;
begin
write(‘N = ‘); readln(n);
s := 0;
for i := 1 to n do s := s + i;
writeln(‘Сумма = ‘, s);
end.
На параметр цикла накладываются последующие ограничения:
1) В качестве параметра цикла обязана употребляться обычная переменная, описанная в текущем блоке, и эта переменная обязана принадлежать к порядковым типам.
2) Типы выражений для вычисления исходного и конечного значений параметра цикла должны быть совместимыми с типом параметра цикла.
3) В теле цикла запрещается очевидное изменение значений параметра цикла.
Пустой оператор.
Никак не обозначается и никак не смотрится. Может употребляться, к примеру, перед операторной скобкой end.
Пример:
repeatuntilKeypressed;
Составные типы.
В Паскале есть последующие составные, либо структурные, типы: постоянные типы (массивы), комбинированные типы (записи), строчки, огромного количества, файлы, объекты.
Массивы.
Массив
– это конечная именованная совокупа частей 1-го типа.
Массив является структурой с прямым доступом, к любому элементу можно обратиться по его номеру. Этот номер именуется индексом.
type <имя> = array[<тип индекса>] of <тип элемента>;
В качестве типа индекса можно задавать хоть какой порядковый тип, не считая Longint. Элементами массива быть может хоть какой тип, не считая файлового.
mas = array[1..10] ofreal;
color = array[byte] of mas;
m2 = array[char] of Boolean;
Размерность массива – количество индексов, данных при описании. В Паскале оно неограниченно. количество частей в массиве фиксировано, другими словами обязано быть определено до трансляции программки.
Многомерные массивы размещаются в памяти так, что резвее всего изменяется самый правый индекс. Наибольший объём памяти под все переменные – 64 кБ.
Строковые типы.
Строчки употребляются для хранения последовательностей знаков. В Паскале существует три типа строк:
1) Обычные. Определяются главным словом string.
2) Определяемые программером на базе string.
3) Строчки в динамической памяти.
var st: string;
st1: array[0..255] of char;
str: string[4];
const st7: string[15] = ‘Пример строчки’;
Таковая строчка может содержать от 0 до 255 знаков. Любой знак в таковой строке занимает 1 б.
Под строчку stотводится 256 б памяти. При всем этом в нулевом элементе строчки хранится длина строчки в символьном виде.
begin
st := ‘Это строчка’;
Для строк применима операция конкатенации, либо склеивания. Обозначается эта операция эмблемой «+».
var line: string;
begin
line := line + ‘стала длиннее’;
Для того, чтоб выяснить длину строчки: ord(line[0]) либо length(<имя строчки>).
Не считая операции склеивания над значениями строковых типов определены операции дела. При выполнении этих операций действуют последующие правила:
1) Наиболее маленькая строчка постоянно меньше наиболее длинноватой.
2) Если длины сравниваемых строк схожи, то строчки сравниваются посимвольно с учётом внутренней шифровки знаков.
Разглядим пример программки, которая обязана сформировать строчку из 26 больших знаков от Aдо Z.
var st: string[26];
i: integer;
begin
st := ‘A’;
for i := 1 to 26 do
st := st + chr(ord(‘A’) + i – 1);
writeln(st);
end.
Функции для работы со строчками:
Concat(
s1,
s2, …,
sn)
– склеивание перечисленных строк.
Copy(
s:
string,
index:
integer;
count:
integer):
string
– функция копирует из строчки scountсимволов, начиная с знака с номером index.
Str(x: real; st: string)
– конвертирует число x в строчку st.
Val(
st,
x,
code)
– процедура конвертирует строчку знаков stво внутреннее структура данных, состоящая из фиксированного числа разнотипных частей, именуемых полями записи. Каждое поле записей имеет своё имя.
type <имя> = record
<перечень полей>
end;
Перечень полей – это перечень имён, разделяемых запятыми, с указанием типа.
Пример:
goods = record
name: string[10];
price: real;
number: integer;
end;
var tov: goods;
tov.price := 2.7;
Доступ к полям записи делается при помощи конструкции, именуемой селектором записей. В общем виде он имеет вид: Q.Z, где Q– переменная комбинированного типа, а Z – имя поля. В качестве типа данных для полей записи может употребляться хоть какой тип, не считая самой записи.
type birthday = record
day: 1..31;
month: 1..12;
year: Word;
end;
person = record
name: string[20];
data: birthday;
end;
var sasha: person;
Воззвание: sasha.data.day := 17;
При работе с комбинированными типами чтоб упростить доступ к полям записи, употребляют оператор присоединения.
with <имя переменной> do <оператор>;
with sasha.data do begin
day := 17;
month := 7;
year := 1997;
end;
Множественные типы.
Огромное количество – это совокупа объектов.
type Digit = set of 1..5;
var s: Digit;
количество разных частей – от 0 до всех вероятных значений. Тип, которому должны принадлежать все элементы огромного количества, именуется базисным типом. Если базисный тип, на котором строится подмножество, имеет kэлементов, то количество подмножеств, входящих в этот множественный тип, равно 2^k.
x: 1..3;
z: setof 1..3;
zможет быть пустым обилием либо иметь значения: 1; 2; 3; 1 и 2; 1 и 3; 2 и 3; 1, 2 и 3.
В качестве базисного типа огромного количества может употребляться хоть какой порядковый тип, не считая типов Word, Integerи Longint. Огромное количество не может содержать больше, чем 256 частей. Переменная множественного типа занимает 32 б. Огромное количество – это бесповторная, неупорядоченная совокупа объектов.
type ElemColor = (red, yellow, green);
Color = set of ElemColor;
var mycolor: Color;
В Паскале для изображения огромного количества употребляется конструктор огромного количества – перечень частей огромного количества, заключённый в квадратные скобки.
mycolor := [] либо mycolor := [red, green]
Два огромного количества числятся эквивалентными и тогда лишь тогда, когда все их элементы схожи, причём порядок следования частей безразличен. Если все элементы 1-го огромного количества входят также и в другое, молвят о включении первого огромного количества во 2-ое.
Операции над огромными количествами:
1) Пересечение
. Итог операции – огромное количество, содержащее элементы, общие для обоих множеств.
A = [0..3, 6]
B = [3..9]
C := A * B; C = [3, 6]
2) Объединение (+). Итог – огромное количество, состоящее из частей, принадлежащих и A, и B.
A + B = [0..9]
3) Вычитание (-). Итог – огромное количество, состоящее из тех частей первого огромного количества, которые не входят во 2-ое.
A – B = [0..2]
4) Операция проверки принадлежности элемента огромному количеству.
<выражение> in <огромное количество>
var st: string;
a: set of 0..9;
k, i: integer;
begin
readln(st);
k := length(st);
a := [0..9];
for i := 1 to k do
if st[i] in a then write(st[i]);
writeln;
for i := 1 to k do
if not (st[i] in a) then write(st[i]);
end.
Не считая рассмотренных операций, к огромным количествам применимы операции дела: =, <>, <=, >=.
В Паскале отсутствует механизм изъятия элемента из огромного количества.
var s: set of char;
for i := 0 to 255 do
if chr(i) in s then inc(c);
Эквивалентность и сопоставимость типов.
В языке Паскаль принят принцип именной эквивалентности. Два типа T1 и T2 являются эквивалентными, если производится одно из 2-ух критерий: 1) T1 и T2 представляют собой один и этот же идентификатор; 2) Тип T2 описан с внедрением типа T1 при помощи конкретного неравенства вида T2 = T1, или средством цепочки неравенств: T2 = T1, T3 = T2 и т.д.
type A1 = array[1..10] of integer;
A2 = array[1..10] of integer;
Но типы A1 и A2 неэквивалентны.
V1, V2 = array[1..10] of integer;
V1 и V2 – эквивалентные типы.
Эквивалентность типов требуется при выполнении оператора присваивания над массивами, также в случае передачи характеристик при вызове процедур либо функций (другими словами типы фактических и формальных характеристик должны быть эквивалентны).
Выполнение операций выражений и сопоставления просит, чтоб операнды имели совместимые типы.
Два типа числятся совместимыми, если производится одно из последующих критерий: 1) два типа эквивалентны; 2) оба типа являются целыми, или оба – вещественными; 3) один тип является ограниченным типом, причём его базисным типом является иной тип; 4) оба типа являются ограниченными, причём их базисным типом является один и этот же тип; 5) оба типа являются множественными типами, причём их базисные типы совместимы; 6) оба типа строковые, или один тип строковый, а иной – символьный; 7) оба типа ссылочные.
Оператор присваивания считается корректным, если тип переменной в левой части совместим с типом выражения в правой части. Типы совместимы по присваиванию при выполнении хотя бы 1-го из последующих критерий: 1) оба типа эквивалентны, и ни один из их не является файловым либо структурным типом, содержащим поле с файловым типом; 2) оба типа являются совместимыми дискретными типами, и части; 3) оба типа вещественные, и значения из правой части попадают в спектр вероятных значений из левой части; 4) слева – переменная вещественного типа, справа – выражение целого типа; 5) слева – строковый тип, справа – символьный, или строковый; 6) оба типа – совместимые множественные типы; 7) оба типа являются совместимыми ссылочными типами.
Преобразование типов.
В Паскале данные 1-го типа могут преобразовываться в данные другого типа. Такое преобразование быть может очевидным и неявным.
Неявное преобразование – может быть в присваивании. к примеру, когда вещественной переменной присваиваются целые значения. Не считая того, неявное присваивание встречается в выражениях с переменными смешанных типов.
При очевидном преобразовании типов употребляются вызовы особых функций преобразования, аргументы которых принадлежат одному типу, а значения – другому. К примеру, функция Odd(i), функция Chr(j), функции Round(x), Trunc(x). Не считая того, в Паскале есть особая система очевидного преобразования типа. Именуется она «приведение типа переменной». Тип (имя_перем).
si: 0..255;
char(si) := ‘z’;
Система приведения типа переменной может находиться всюду, где допускается вхождение переменной. Близкой по синтаксису является система приведения типа значения, которая дозволяет конвертировать тип случайного выражения, записанного в круглых скобках, к типу перед скобками. Тип (выражение). Система может встречаться всюду, где допустимо выражение, к примеру, справа от знака присваивания.
Li: Longint;
i: integer;
Li := 1234567;
i := integer(Li + 1);
Но такое преобразование может привести к усечению типа значения. Тип выражения в скобках и идентификатор выражения перед скобками должны являться оба дискретными типами. Если один дискретный тип преобразуется к другому, то такое преобразование может привести к усечению либо повышению размера памяти по сопоставлению с начальным. Если
Файловые типы в Паскале и ввод-вывод.
Под файлом понимается именованная область наружной памяти ЭВМ (Электронная вычислительная машина — комплекс технических средств, предназначенных для автоматической обработки информации в процессе решения вычислительных и информационных задач) либо логическое устройство. В файл данные можно записать, или извлечь. Эти деяния имеют общее заглавие «ввод-вывод». Для воплощения операции ввода-вывода с файлами, в программке нужно найти переменные файловых типов, которые числятся представителями файлов в программке. файл при всем этом рассматривается как нескончаемый перечень значений. В Паскале существует три типа файловых переменных: типизированные файлы, текстовые и нетипизированные файлы.
var fp: file of <тип>;
fp: file of real; — типизированные файлы
fp1: text; — текстовые файлы
fp2: file; — нетипизированные файлы
С каждой переменной файлового типа соединено понятие текущего указателя файла. Все элементы файла числятся пронумерованными, и исходный элемент имеет нулевой номер.
Операции над файлами.
Input– файл для считывания данных с клавиатуры.
Output– файл для вывода данных на экран.
Для того чтоб работать с файлом на наружном носителе, в программке нужно: 1) обрисовать файловую переменную; 2) связать файловую переменную с файлом на диске. Это осуществляется при помощи процедуры: Assign(fp, ‘<cтрока, задающая имя файла>’);
Assign(fp, ‘D:MyDirdata.dat’);
3) открыть файл. В Паскале файл можно открыть лишь для чтения, лишь для записи. Типизированные файлы можно открыть и для чтения, и для записи сразу. Для открытия файлов служат две процедуры: Reset(fp) – на чтение; Rewrite(fp) – на запись.
Под открытием файла понимается поиск файла на наружном носителе, образование особых буферных областей в памяти для работы с ним и установка текущего указателя на начало файла. Процедура Resetпредполагает, что дисковый файл существует. Процедура Rewriteдопускает, что обозначенный файл может не существовать. В этом случае процедура создаёт на диске файл с тем именованием, которое указали в процедуре Assign. Для закрытия файлов существует процедура Close(fp); Она закрывает файл, но связь с файловой переменной не разрывается.
Операции ввода-вывода.
Для воплощения ввода-вывода из файла есть две процедуры: Readи Write.
Read([<ф.пер.>], перечень ввода);
Write([<ф.пер.>], перечень вывода);
Перечень ввода – это последовательность из 1-го либо наиболее имён переменных типа char, string, также хоть какого целого либо вещественного типа. В эти переменные будут помещаться значения из файла.
Перечень вывода – это перечень выражений. Выражения также делятся запятыми.
И чтение из файла, и запись в файл делается в позицию, в какой находится текущий указатель файла. Опосля ввода-вывода текущий указатель {перемещается}.
Некие процедуры и функции для работы с файлами.
Rename(<ф.пер.>, ‘<новое имя файла>’)
– переименовать файл. Перед выполнением процедуры файл нужно закрыть, если он был открыт.
Erase(<ф.пер>)
– удаляет файл.
EOF(<ф.пер.>):
Boolean
– функция инспектирует, достигнут ли указателем конец файла.
IOResult:
Word
– возвращает условный признак крайней операции ввода-вывода. Если операция открытия файла прошла удачно, функция возвращает 0, и не 0 в неприятном случае. Для использования функции нужно отключить контроль ошибок ввода-вывода. Директива {$I-} перед открытием файла отключает контроль ошибок. Опосля проверки лучше опять включить контроль ошибок директивой {$I+}.
var f: file of char;
…
begin
assign(f, ‘Myfile.dat’);
{$I-}
Reset(f);
{$I+}
if IOResult <> 0 then writeln(‘Файл не существует’)
else …
Текстовые файлы.
Предусмотрены для хранения текстовой инфы. По собственной структуре эти файлы представляют собой последовательность символьных строк переменной длины. Любая строчка текстового файла завершается признаком конца строчки (коды CR (13), LF (10)). Завершается текстовый файл признаком конца файла (код EOF (26)). К каждой строке текстового файла вероятен лишь поочередный доступ, начиная с первой. Другими словами, текстовые файлы – это файлы с поочередным доступом.
varft: text;
begin
assign(ft, ‘ ‘);
reset(ft) / rewrite(ft) / append(ft);
Append(<ф.пер.>)
– служит для открытия текстового файла для записи в конец.
Для чтения из текстового файла употребляются процедуры: Read(ft, <перечень ввода>), Readln(ft, <перечень ввода>). Перечень ввода – последовательность из 1-го либо наиболее имён переменных типа Char, String, также хоть какого целого либо вещественного типов. В эти переменные будут помещаться значения из файла. Опосля хоть какой операции чтения указатель {перемещается} на последующую позицию.
При обработке переменных типа Charвыполняется чтение 1-го знака из файла и присваивание считанного значения переменной.
Read(ft, ch);
Если перед выполнением чтения указатель файла достигнул конца строчки, то результатом чтения будет знак CR с кодом 13. Если указатель стоит на конце файла, то результатом чтения будет знак с кодом 26.
При вводе переменных типа String количество считанных процедурой и помещённых в строчку знаков равно наибольшей длине строчки, если лишь ранее не повстречается признак конца строчки либо конец файла. признак конца строчки в переменную не записывается.
st: string[20];
read(ft, st);
Если строчка файла больше, чем длина строковой переменной, обозначенной в процедуре Read, то излишние знаки до конца строчки файла отбрасываются, а новое воззвание к Readвернёт пустую строчку. При помощи процедуры Readнельзя прочесть последовательность строк. Для ввода последовательности строк необходимо применять функцию Readln. Её также можно задавать без перечня ввода.
При вводе числовых переменных процедура Readвыделяет подстроку во входном потоке по последующему правилу: все пробелы, знаки табуляции и маркеры конца строк пропускаются. Опосля выделения первого означающего знака и всех следующих знаки пробела, табуляции служат признаком конца подстроки.
x: integer;
Read(ft, x);
Выделенная подстрока рассматривается как символьное файл: Write(ft, <перечень вывода>), Writeln(ft, <перечень вывода>).
Перечень вывода – перечень выражений
типа Char, String, Boolean, также хоть какого целого либо вещественного типа. Для хоть какого выводимого параметра можно указывать минимальную ширину поля, в которое будет выведено символьное количество символов опосля десятичной точки. При использовании процедуры Writelnвыводимая строчка знаков заканчивается знаками конца строчки. Writelnможно задавать и без перечня вывода, для файлов это значит пропуск строчки.
Три функции, которые можно использовать лишь к текстовым файлам:
Eoln(
ft:
text):
Boolean
– инспектирует, где стоит файловый указатель. Если он стоит в конце текущей строчки, то функция возвращает True. В неприятном случае – False.
SeekEoln(
ft:
text):
Boolean
– перемещает файловый указатель до первого означающего знака либо до маркера конца строчки, пропускает все пробелы и знаки табуляции. Возвращает True, если указатель стоит на маркере конца строчки, и False– если на означающем знаке.
SeekEof(
ft:
text):
Boolean
– работает так же, как SeekEoln, лишь относительно конца файла, а не строчки.
Типизированные файлы.
Используются для хранения однотипных частей в их внутреннем представлении. По собственной структуре типизированный файл представляет собой двоичный файл со строго неизменной длиной всякого элемента. Для того чтоб работать с типизированным файлом, в программке обязана быть описана переменная последующим образом:
var fp: file of <тип>;
Составляющие типизированного файла могут быть хоть какого типа, не считая файлового. Типизированные файлы являются файлами с прямым доступом. Любой элемент файла нумеруется, самый 1-ый элемент имеет номер 0. Типизированный файл можно открыть при помощи процедуры Reset как на чтение, так и на запись. При всем этом типизированный файл должен существовать. Процедура Rewriteоткрывает файл лишь на запись, при всем этом файл может не существовать. При открытии файла и той, и иной процедурой указатель файла ставится на нулевой элемент.
Для чтения из файла употребляется лишь процедура Read. Перечень ввода – перечень имён переменных такого же типа, что и тип частей файла. Для записи употребляется лишь процедура Write. Перечень вывода – перечень выражений такого же типа, что и тип частей файла.
Seek(
fp:
file
of
real,
N:
longint)
– перемещает указатель на номер Nэлемента файла.
Seek(fp, 0L) – перемещает указатель в начало файла.
FileSize(
fp):
longint
– возвращает количество частей в файле.
FilePos(
fp):
longint
– возвращает номер элемента файла, на котором стоит указатель.
www.fepo.ru
230101.65
Пример работы с типизированным файлом.
type mas = array[1..100] of real;
var a, b: mas;
f: file of mas;
begin
assign(f, ‘file.dat’);
rewrite(f);
………… {запись частей в массивы}
write(f, a, b);
close(f);
end.
Элементом файла является массив полностью. В таковой файл недозволено записать отдельный элемент массива либо ординарную переменную вещественного типа.
Из текстового файла прочесть пару вещественных чисел. Считая 1-ое реальной, а 2-ое – надуманной составляющей всеохватывающего числа, записать их в файл всеохватывающих чисел.
program tip-file;
type complex = record
re, im: real
end;
var x: complex;
f1: text;
f2: file of complex;
begin
assign(f1, ‘tipfile.dat’);
reset(f1);
assign(f2, ‘tipfile.res’);
rewrite(f2);
while not eof(f1) do begin
read(f1, x.re, x.im);
write(f2, x);
end;
close(f1);
close(f2);
end.
Нетипизированные файлы.
vardata: file;
Нетипизированные файлы употребляются для организации доступа к хоть каким дисковым файлам, независимо от их структуры. При всем этом файл представляется, как последовательность частей случайного типа. Единственное, что оговаривается, это размер элемента.
Нетипизированный файл можно открыть или на чтение (Reset), или на запись (Rewrite).
reset(data, [N]);
rewrite(data, [N]);
N – размер 1-го элемента, указывать необязательно. По дефлоту, размер 1-го элемента – 128 б. Размер файла быть может не кратен размеру записи, крайняя запись будет неполной.
Для нетипизированных файлов есть особые процедуры.
BlockWrite(var f: file; var x; count: Word; [var num: word])
– запись в файл.
BlockRead(var f: file; var x; count: Word; [var num: word])
– чтение из файла.
f
– файловая переменная.
x
– буферная переменная, которая будет участвовать в обмене с файлом. При чтении в неё будут записываться элементы, а при записи – считываться из неё и записываться в файл.
count
– количество записей, которые должны быть прочитаны (либо записаны) за одно воззвание к файлу.
num
– при выходе из процедуры содержит количество практически обработанных записей.
Если N – длина одной записи, то за одно воззвание к файлу недозволено прочесть больше, чем count*Nбайт. И эта величина также не может превосходить 64 кБ. Длина внутреннего представления переменной xдолжна быть достаточной для размещения count*N байтов при чтении из файла. Если при записи в файл процедурой BlockWriteна диске не окажется вольного места либо при чтении из файла процедурой BlockReadразмер буфера (x) окажется меньше обозначенного произведения, то произойдёт последующее: если параметр numв вызовах процедур не указан, то произойдёт ошибка ввода-вывода; если указан, то ошибка не фиксируется, а опосля выполнения процедуры его
Пример:
программка делает ввод вещественных чисел из текстового файла и запись их в безтиповой файл блоками по 4 числа.
program createfile;
var buf: array[1..4] of real;
f_in: text;
f_out: file;
i, k: integer;
name_in, name_out: string;
begin
{$I-}
writeln(‘Введите имя входного файла: ‘);
readln(name_in);
assign(f_in, name_in);
reset(f_in);
if IOResult <> 0 then begin
writeln(‘Файл’, name_in, ‘ не найден’);
exit;
end;
writeln(‘Введите имя выходного файла: ‘);
readln(name_out);
assign(f_out, name_out);
rewrite(f_out, sizeof(real)*4);
{$I+}
i := 0;
while not eof(f_in) do begin
inc(i);
read(f_in, buf[i]);
if i = 4 then begin blockwrite(f_out, buf, 1); i := 0; end;
end;
if i <> 0 then begin
for k := i + 1 to 4 do buf[k] := 0;
blockwrite(f_out, buf, 1);
end;
close(f_in);
close(f_out);
end.
Truncate(
var
f)
– процедура устанавливает в текущей позиции признак конца файла и удаляет все следующие элементы.
Пример 2:
программка, выводящая на экран заданную по номеру запись из файла.
program get_bfile;
var buf: array[1..4] of real;
f: file;
i, k: integer;
filename: string;
begin
writeln(‘Введите имя файла: ‘);
readln(filename);
{$I-}
assign(f, filename);
reset(f, sizeof(real)*4);
if IOResult <> 0 then begin
writeln(‘Файл’, filename, ‘ не найден’);
exit;
end;
{$I+}
while true do begin
writeln(‘Введите номер записи либо -1 для окончания’);
readln(k);
if (k > filesize(f)) or (k < 0) then begin
writeln(‘Таковой записи нет’);
exit;
end;
seek(f, k);
blockread(f, buf, 1);
for i := 1 to 4 do write(buf[i]:6:1);
end;
close(f);
end.
Процедуры и функции.
Структурный подход к программированию подразумевает часть программки, оформленная в виде отдельной синтаксической конструкции и снабжённая именованием. Выполнение действий, данных в подпрограмме в виде операторов, быть может произведено в хоть какой точке программки средством указания имени данной подпрограммы. В языке Паскаль реализовано два вида подпрограмм: процедуры и функции. Имея схожую структуру, они различаются предназначением и методом использования. Процедура создана для выполнения некой последовательности действий, а смысл функции заключается в выполнении метода вычисления некого новейшего значения обычного либо ссылочного типов.
Общая структура подпрограммы.
Структура подпрограммы практически стопроцентно повторяет структуру главный Паскаль-программы. При описании подпрограммы нужно задать три неотклонимых компонента:
1) интерфейс подпрограммы.
2) Описание локальных объектов.
3) Операторы.
Интерфейсом подпрограммы является её заголовок. В описании локальных объектов могут определяться константы, переменные, остальные подпрограммы и т.п.
procedure <имя> [(список формальных параметров)];
function <имя> [(список формальных параметров)]: <тип>;
Перечень формальных характеристик – перечень тех характеристик, которые передаются подпрограмме в точке её вызова.
procedure Swap (var x, y: real);
function Max (a, b: byte): byte;
procedureStop;
области деяния имён.
Посреди описаний в подпрограмме может содержаться описание остальных подпрограмм (так именуемые, вложенные подпрограммы). (См. рис. в тетради).
При работе с блоками нужно соблюдать последующие правила:
1) Имена объектов, обрисованных в блоке, числятся известными в границах данного блока, включая и все вложенные блоки.
2) Имена объектов, обрисованных в блоке, должны быть неповторимы в границах данного блока и могут совпадать с именами объектов из остальных блоков.
3) Если во внутреннем блоке описан объект, имя которого совпадает с именованием из наружного блока, то имя из наружного блока не будет доступно во внутреннем блоке.
совокупа объектов, обрисованных в самом наружном блоке, именуется глобальными переменными.
var i: integer;
procedure P;
var i: integer;
begin
writeln(i);
end;
begin
i := 1;
P;
end.
характеристики.
В заголовке подпрограммы быть может задан перечень формальных характеристик. Этот перечень заключается в круглые скобки, и для всякого параметра указывается его имя и тип. Отделяются характеристики друг от друга точкой с запятой. Любой параметр, данный в заголовке, считается локальным в данной подпрограмме. Если перечень формальных характеристик существует, то при вызове подпрограммы ей необходимо передать фактические характеристики.
Swap(a, b);
Характеристики, указываемые при вызове подпрограммы, именуются фактическими параметрами. При задании типа формальных характеристик в заголовке тип должен указываться идентификатором.
procedure Incorrect (a: array[1..15] of real); — запись некорректная.
type Vector = array[1..15] of real;
procedure Correct (a: Vector); — запись верная.
Примеры заголовков подпрограмм:
function MaxElem (a: Vector; n: byte): real;
procedure Sum (a, b: matrix; var c: matrix);
procedure Move (var Source, Dest; n: Word);
Формальные характеристики в заголовках процедуры могут быть заданы 3-мя методами:
1) без служебного слова varс указанием типа.
2) со служебным словом varи с указанием типа.
3) со служебным словом varбез указания типа.
Эти три метода задания формальных характеристик выражают три разных метода передачи характеристик подпрограммам.
1-ый метод именуется «передача характеристик по значению».
2-ой метод именуется «передача характеристик по ссылке».
3-ий метод именуется «передача нетипизированных характеристик по ссылке».
Передача характеристик по значению.
Это самый обычной и более распространённый метод. При передаче характеристик по значению программка работает с копией фактического параметра.
var a, b: real;
procedure SumSquare (x, y: real);
begin
x := x * x;
y := y * y;
writeln(x + y);
end;
begin
a := 1,7;
b := 8,09;
SumSquare(a, b);
writeln(a, b);
end.
При вызове подпрограммы изначальное значения характеристик, переданных по значению, могут изменяться, но это никак не отражается на значении переменных вне подпрограммы.
Типовые характеристики.
При вызове подпрограммы мы можем представлять переменную типа, но не выражения.
Потому что тип формального параметра не задан, то, строго говоря, он не совместим ни с какой переменной и не может заходить не в какие конструкции. Чтоб его можно было применять, его нужно привести к какому-либо типу. Создать это можно 2-мя методами:
1. Применить систему приведения типа.
2. Обрисовать в подпрограмме локальную переменную определённого типа, с совмещением её в памяти с нетипизированным параметром.
В качестве примера использования первого метода разглядим функцию Fqual, которая может употребляться для сопоставления значений 2-ух переменных всех типов и, соответственно, всех размеров.
Fqual(var Source,Dest);
Type
Bytes=array[0..maxint] of byte;
Var
N:integer;
Begin
N:=0;
While (n<size) and (bytes(dest)[n]=bytes(source)[n]) do n:=n+1;
Fqual:=(n=size)
End.
Type
Vector=array[1..10] of integer;
Point=record
X,y:integer
End;
Var
Vec1,vec2:Vector;
N:integer;
P:point;
Fqual(vec1,vec2;size of integer);
Fqual(vec1[1], {сравниваются 5 первых частей vec1 с 5 крайними элементами vec2} vec2[6]; sizeofinteger);
Fqual(vec1[1],P,4);
2-ой метод:
В TurboPascal для того чтоб расположить 2 параметра в одном том же поле, употребляется слово absolute.
Var A:real;
B:integer absolute a;
В случае такового описания новенькая память под хранение переменной bне отводится. Переменная aи b могут иметь различные типы. Никаких проверок не делается.
Вычисление значения функции.
Смысл функции заключается в вычислении некого значения и организации передачи этого значения в точку вызова. Возврат вычисленного значения осуществляется последующим образом.
В теле функции должен находиться оператор присваивания, в левой части которого обязано быть обозначено имя функции, а в правой части – выражение, вычисляющее возвращаемое теле функции ни 1-го такового оператора нет, итог функции считается неопределённым.
Exit– при помощи данной процедуры можно немедля возвратятся в точку вызова подпрограммы.
Существует механизм подготовительного описания подпрограмм. Предварительное описание подпрограммы содержит заголовок подпрограммы, а заместо тела подпрограммы записывается служебное слово forward.
Это слово показывает на то, что тексты подпрограмм размещаются дальше.
Под наружным описанием понимается ситуация, когда подпрограмма либо группа подпрограмм разработаны вне системы Турбо Паскаль и на другом языке программирования, и нужно эти подпрограммы подключить к паскаль-программе. В этом случае объектный код подключаемых подпрограмм содержится в файле с расширением .obj, а само подключение осуществляется последующим образом: в паскаль-программе нужно указать заголовок подключаемой подпрограммы, опосля которого обязано идти служебное слово external.
Распределение памяти для локальных переменных.
Турбо Паскаль реализует последующий принцип распределения памяти для подпрограмм
Все глобальные переменные, также типизированные константы, располагаются в одном секторе данных и, как следует, не могут занимать пространство больше, чем 64 кБ. Локальные переменные располагаются в памяти динамически, при вызове подпрограммы, их содержащей. Опосля выполнения подпрограммы память, отведенная под локальные переменные, освобождается. память под локальные переменные выделяется в стеке. Общий размер стека ограничен одним сектором. По дефлоту программке отводится 16 кБ стековой памяти.
]]>