Условный оператор case.
C помощью этого оператора можно выбрать вариант из любого количества вариантов.
Case S of
c1: instrucnion1;
c2: instruction2;
............................
cn: instructionn;
else instruction
end;
В этой структуре
выражение порядкового типа, значение которого вычисляется;
с1,с2,...,сn- константы, с которыми сравнивается значение выражения S.
Instruction1,instruction2,...,instructionn- операторы,из которых выполняется тот, с константой которого совпадает значение выражения S.
Instruction- оператор, который выполняется, если значение S не совпадает ни с одной из констант.
Ветвь оператора else является необязательной. Если она отсутствует и выражение S не совпадает ни с одной из констант, весь оператор рассматривается как пустой.
Если для нескольких констант нужно выполнить один и тот же оператор, их можно перечислить через запятую.
Program c;
var i:integer;
begin
writeln(‘ введите значение i’);
readln(i);
Case i of
0,2,4,6,8: writeln(‘ четная цифра’);
1,3,5,7,9: writeln(‘ нечетная цифра’);
10..100: writeln(‘ число от 10 до 100’);
else
writeln(‘ отрицательное число или большее 100’);
end;
end.
Операторы цикла.
Оператор цикла с постусловием имеет вид:
repeat
операторы;
until условие;
В этом случае выполняются операторы, стоящие между REPEAT и UNTIL до тех пор, пока условие, стоящее после UNTIL ,принимает значение false. Если условие = true, то операторы между REPEAT и UNTIL пропускаются.Поскольку служебные слова REPEAT и UNTIL играют роль скобок, то между ними можно поместить серию операторов, не заключая их в операторные скобки BEGIN и END.
Рассмотрим пример1:
Пусть необходимо найти k!
Введем следующие обозначения:
s - текущее произведение;
i - счетчик.
k!=1*2*3*...*k
..........
i:=0;
s:=1;
repeat
inc(i);
s:=S*i;
until n=k;
..........
Оператор REPEAT выполняется по следующему алгоритму:
1.Выполняются операторы, стоящие после ключевого слова REPEAT.
2.Вычисляется значение выражения после ключевого слова UNTIL. 3.Если получено значение TRUE,то выполнение оператора считается оконченным.
4.Если получено значение FALSE,то описанные действия повторяются сначала.
Некоторые особенности этого оператора:
1.В операторе REPEAT проверка условия выполняется в конце, а не в начале цикла, так что тело цикла выполняется по крайней мере один раз.
2.В операторе REPEAT условие выхода удовлетворяется, если выражение после UNTIL истинно.
Пример2:
Записать программу нахождения Наибольшего Общего Делителя двух целых чисел m и n. program example(input,output); var x,y,nod:integer;
begin
writeln('Введите числа');
write('m=');
readln(m);
write('n='); readln(n); x:=m; y:=n;
repeat
if x>y then
x:=x-y
else y:=y-x;
until x=y;
nod:=x; writeln('НОД двух чисел=',nod); end.
ОПЕРАТОР ЦИКЛА С ПРЕДУСЛОВИЕМ
Данный опеpатоp пpедназначен для оpганизации цикла с неизвестным числом
повтоpений.
WHILE A DO S;
A-булевское (логическое)выpажение.
S-опеpатоp (пpостой или составной).
Работа цикла:
Выажение A вычисляется пеpед каждым выполнением опеpатоpа S.Если A-TRUE,
то S выполняется и упpавление пеpедаётся снова на вычисление A; если A-FALSE,
то S не выполняется и пpоисходит выход из цикла.Иными словами, S выполняется
до тех поp, пока A есть TRUE.Если A-FALSE изначально, то цикл ни pазу не пов-
тоится.
Значения пеpеменных, входящих в условие, должны изменяться в теле цикла,
иначе цикл не будет завеpшён.
Опеpатоp WHILE...DO можно использовать внутpи цикла, то есть возможна
система вложенных циклов.
Пpимеp: вычислить и вывести на печать значения функции Y=A*A*A/(A*A+X*X)
пpи значениях X от 0 до 3 с шагом 0.1 .
program function(input,output);
var A,X,Y:real;
BEGIN
read(A);
X:=0;
while X<=3 do
begin
Y:=(A*A*A)/(A*A+X*X);
writeln('X=',X,' ! ','Y=',Y);
X:=X+0.1
end
END.
Дан текст, содержащий букву а. Напечатать следующую за ней букву.
Program c;
var sym:char;
read(sym);
while sym <> ‘a’ do
read(sym);
read(sym);write(sym);
end.
Напечатать заданный текст, удалив из него все знаки +, за которыми идет цифра.
Текст заканчивается точкой.
Program q;
var d,c:char;
begin
read(c,d);
while d <> ‘.’ do
begin
if (c<>’+’) or (d< ’0’) or (d > ‘9’)
then write (c);
c:=d; read(d);
end;
write(c); end.
ОПЕРАТОР ЦИКЛА FOR
ОПЕРАТОР ПОВТОРА FOR СОСТОИТ ИЗ ЗАГОЛОВКА И ТЕЛА ЦИКЛА . ОН
МОЖЕТ БЫТЬ ПРЕДСТАВЛЕН В ДВУХ ФОРМАТАХ:
1. FOR <ПАРАМЕТР ЦИКЛА>:=<S1> TO <S2> DO <ОПЕРАТОР> ;
2. FOR <ПАРАМЕТР ЦИКЛА>:=<S1> DOWTO <S2> DO <ОПЕРАТОР>.
S1 И S2 - ВЫРАЖЕНИЯ, ОПРЕДЕЛЯЮЩИЕ СООТВЕТСТВЕННО НАЧАЛЬНОЕ И КОНЕЧНОЕ
ЗНАЧЕНИЕ ПАРАМЕТРА ЦИКЛА. FOR...DO - ЗАГОЛОВОК ЦИКЛА, <ОПЕРАТОР> -
ТЕЛО ЦИКЛА ( МОЖЕТ БЫТЬ ПРОСТЫМ И СОСТАВНЫМ ОПЕРАТОРОМ) . ОПЕРАТОР FOR
ОБЕСПЕЧИВАЕТ ВЫПОЛНЕНИЕ ЦИКЛА ДО ТЕХ ПОР ПОКА НЕ БУДУТ ПЕРЕБРАНЫ ВСЕ
ЗНАЧЕНИЯ ПАРАМЕТРА ЦИКЛА :
FOR I:=1 TO 20 DO WRITE(*)
(20 РАЗ ВЫВЕДЕТ НА ЭКРАН *)
ПАРАМЕТР ЦИКЛА , ЕГО НАЧАЛЬНОЕ И КОНЕЧНОЕ ЗНАЧЕНИЕ ДОЛЖНЫ ПРИНАДЛЕЖАТЬ
К ОДНОМУ И ТОМУ ЖЕ ТИПУ ДАННЫХ.
ПРИ ЭТОМ ДОПУСТИМ ЛЮБОЙ СКАЛЯРНЫЙ ТИП КРОМЕ ВЕЩЕСТВЕННОГО.
ПОСЛЕ ЗАВЕРШЕНИЯ ОПЕРАТОРА FOR ЗНАЧЕНИЕ ПАРАМЕТРА ЦИКЛА РАВНО КОНЕЧНОМУ
ЗНАЧЕНИЮ.
ЕСЛИ ОПЕРАТОР FOR НЕ ВЫПОЛНЯЕТСЯ, ТО ЗНАЧЕНИЕ ПАРАМЕТРА ЦИКЛА
НЕ ОПРЕДЕЛЕНО.
Пример 1: СУММА ЧИСЕЛ ОТ 1 ДО N.
PROGRAM F;
{ЗНАЧЕНИЕ N ЗАПРАШИВАЕТСЯ У ПОЛЬЗОВАТЕЛЯ
I- ПАРАМЕТР ЦИКЛА
SUMMA -ПЕРЕМЕННАЯ ДЛЯ СУММИРОВАНИЯ I,I+1,..}
VAR
N,I,SUMMA:INTEGER;
BEGIN
WRITE (' ВВЕДИТЕ ЗНАЧЕНИЕ N');
READ (N);WRITELN;
SUMMA:=0;
FOR I:=1 TO N DO SUMMA:=SUMMA+I;
WRITELN ('СУММА ЧИСЕЛ В ДИАПАЗОНЕ 1-',N:3,'РАВНА',SUMMA:4)
END.
Пример2: вычислить N! ( произведение чисел от 1 до n )
Program f1;
var k,p,n:integer;
begin
writeln( ‘введите значение n’);
readln(n);
p:=1;
for k:=1 to n do
p:=p*k;
writeln(‘ p=’,p:10);
end.
Программы.Сочетание цикла и разветвления.
1.Построить таблицу значений для функции
cos 2 (x) , если 0 < x <2
у=
1-sin(x2 ) , иначе
x изменяется от -π до π с шагом π/5.
Program s;
var xn,xk,h,x,y:real;
begin
writeln (‘ введите хn,xk,h’);
readln(xn,xk,h);
writeln(‘ x y ‘);
x:=xn;
while x<= xk do
begin
if (x>0) and (x<2) then y:=sqr(cos(x))
else y:=1-sin(sqr(x));
writeln (x:10:3,y:10:3);
x:=x+h;
end;
end.
Напечатать текст, удалив из него все цифры. Текст заканчивается точкой.
Program t;
var c:char;
begin
read( c);
repeat
if ( c< ‘0’) or (c >’9’)
then write ( c );
read ( c );
until c=’.’;
writeln;
end.
Дано 20 чисел. Вычислить сумму всех чисел, кратных 3.
Program d;
var s, y,i:integer;
begin
s:=0;
for i:=1 to 20 do
begin
readln(y);
if y mod 3 = 0 then s:=s+y;
end;
writeln(‘ s= ‘, s:10);
end.
Вложенные циклы.
Вычислить значение функции Y= X (x+ I)3 +1 если |x| <1
X3 + П (k2/3 -x)/k для остальных значений X изменяется от -1 до 2.5 с шагом 0.2
program r;
var xn,xk,h,s,p,x,y:real;
i,k:integer;
begin
writeln(‘ введите xn,xk,h‘);
readln(xn,xk,h);
writeln;writeln(‘ x y’);
x:=xn;
repeat
if abs(x)< 1 then
begin s:=0;
for i:=1 to 10 do
s:=s+(sqr(i+x)*(i+x)+1);
y:=x*s
end
else
begin p:=1;
for k:=1 to 8 do
p:=p*((exp(2/3*ln(k))-x)/k);
y:=sqr(x)*x+p
end;
writeln(x:3:1,y:10:4);
x:=x+h;
until x > xk;
end.
Построить таблицу значений x,y,z
15*x2+21*y2
,
если x<y
Z=
S
15*y2 + 21*x2 , в остальных случаях
х изменяется от -0.1 до 0.1 с шагом 0.01
у изменяется от -0.5 до 0.2 с шагом 0.02
program d;
var x,y,z,xn,xk,hx,yn,yk,hy:real;
begin
writeln(‘введите начальные,конечные значения и приращения переменных’);
writeln(‘xn,xk,hx,yn,yk,hy);
writeln;writeln(‘ x y z’);
x:=xn;
while x<=xk do
begin
y:=yn;
repeat
if x<y then z:= sqrt(15*x*x+21*y*y)
else z:= sqrt(15*y*y+21*x*x);
writeln(x:5:2,y:5:2, z:12:6);
y:=y+hy;
until y>yk;
x:=x+hx;
end;
end.
(k2 +i)
Вычислить S= sin(i+1) ----------
2ki
program sun;
var s:real;
k,i:integer;
begin
s:=0;
for i:=1 to 10 do
for k:=1 to 10 do
s:=s+sin(i+1)*(k*k+i)/(2*k*i);
writeln(‘ s= ‘,s:12:6);
end.
Найти корни квадратного уравнения , если коэффициенты его вычисляются по формулам:
а х1 изменяется от 0 до 1 с шагом 0.1
program aa;
var x1,x2,a,b,c,d,f,xx1,xx2:real;
begin
x1:=0;a:=-10.986;f:=4.3;
repeat
b:=14.609+x1*(-35.116);
c:=0.3420+x1*21.644-f;
d:=sqrt(b*b-4*a*c);
xx1:=(-b+d)/2/a;
xx2:=(-b-d/2/a);
writeln('f',f:10:3,'x',x1:10:3,xx1:10:3,xx2:10:3);
x1:=x1+0.1;
until x1>1;
end.
Структурированные типы данных.
МАССИВЫ
МАССИВ ЭТО СТРУКТУРИРОВАННЫЕ ДАННЫЕ ИМЕЮЩИЕ ОБЩЕЕ ИМЯ И УПОРЯДОЧЕННО РАСПОЛОЖЕННЫХ В ПАМЯТИ ЭВМ.
В языке "PASCAL" для их описания
используется зарезервированное слово ARRAY:
ARRAY [тип инд1, тип инд 2, ...] OF тип эл-тов массива
где в качестве типов индексов допускаются переменные порядкового типа
Это конструкция может использоваться в разделе описания типов или в
разделе описания переменных:
ПРИМЕР:
TIPE ...
MAS=ARRAY [1..10,1..5] OF REAL;
...
VAR ...
A,B:ARRAY [1..50] OF CHAR;
C:MAS;
...
Oдномерные массивы - массивы имеющие размерность один, т.е. данные
располагаються в виде строки (в примере это массивы A и B).
Тип элементов массива может быть любой (INTEGER,REAL,CHAR,STRING,
BOOLEAN или др.), кроме типа FILE.С элементами массива можно произво-
дить все действия допустимые для данного типа.
Обращение к массиву происходит по его имени,а обращение к эле-
менту массива по имени массива и его номеру: A[1,10] - 10 эл-т в 1
строке массива A.
ПРИМЕР:
ЗАДАЧА 1.
В массиве, состсящем из 10 элементов, найти MAX и MIN элементы и
поменять их местами.
РЕШЕНИЕ.
PROGRAM MAXMIN (INPUT,OUTPUT);
VAR
A:ARRAY [1..10] OF REAL;
AMAX,AMIN,AP :REAL;
IMAX,IMIN,I:INTEGER;
BEGIN
{ВВОД ЭЛЕМЕНТОВ МАССИВА}
WRITE ('ВВЕДИТЕ МАССИВ ИЗ 10 ЭЛ-ТОВ');
FOR I:=1 TO 10 DO
READ (A[I]);
{ЗАДАНИЕ НАЧАЛЬНЫХ УСЛОВИЙ СРАВНЕНИЯ}
AMAX:=A[1];
AMIN:=A[1];
IMAX:=1;
IMIN:=1;
FOR I:=1 TO 10 DO
BEGIN
{НАХОЖДЕНИЕ МАКСИМАЛЬНОГО ЭЛЕМЕНТА}
IF AMAX<A[I] THEN
BEGIN
AMAX:=A[I];
IMAX:=I
END;
{НАХОЖДЕНИЕ МИНИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ}
IF AMIN>A[I] THEN
BEGIN
AMIN:=A[I];
IMIN:=I
END
END;
{ПЕРЕСТАНОВКА ЭЛЕМЕНТОВ В МАССИВЕ}
A[IMAX]:=AMIN;
A[IMIN]:=AMAX;
WRITE ('ПЕРЕСТАНОВКА ЗАКОНЧЕНА')
END.
Дан массив из 20 элементов. Найти среднее значение отрицательных элементов и количество нулевых.
program nine2;
uses crt;
const n=20;
type mas=array[1..20] of real;
var s:real;k,ko,i:integer;
a:mas;
begin
clrscr;
writeln(' введите элементы массива');
for i:=1 to n do
readln(a[i]);
s:=0;k:=0;ko:=0;
for i:=1 to n do
begin
if a[i] < 0 then begin s:=s+a[i];ko:=ko+1;end;
if a[i] = 0 then k:=k+1;
end;
s:=s/ko;
writeln(' сp.аpифм.отpицательных элементов:',s:10:4);
writeln(' количество нулевых элементов :',k:5);
end.
Дан массив из 10 элементов. Вычислить количество элементов массива, попадающих в интервал xn,xk , и их сумму. Заменить нулями все элементы массива, меньшие 2.
program two;
USES CRT;
const n=10;
type mas=array[1..n] of real;
var x:mas;k,i:integer;
s,xn,xk:real;
begin
clrscr;
writeln (' введите исходный массив x');
for i:=1 to n do
readln(x[i]);
writeln(' введите начало и конец интеpвала xn,xk');
readln(xn,xk);
{ пеpесчет элементов массива}
k:=0;s:=0;
for i:=1 to n do begin
if (x[i]>=xn) and (x[i]<=xk) then begin
k:=k+1;
s:=s+x[i];end;
if x[i] < 2 then x[i]:=0;
end;
writeln(' pезультаты pасчета:');
writeln(' новый массив');
for i:=1 to n do
write(x[i]:5:1);
writeln;
writeln(' сумма элементов массива,попадающих');
writeln(' в заданный интеpвал',s:12:3);
writeln(' количество таких элементов :',k:10);
end.
Дан массив из 40 чисел.
Переменной t присвоить значение true, усли элементы массива строго упорядочены по возрастанию, и false иначе.
Program vv;
const n=40;
var x:array [1..n] of integer;
y,k:integer;t:boolean;
begin
writeln(‘ введите массив х из 40 элементов’);
for i:=1 to 40 do
read (x[i]);
i:=1;
repeat
t:=x[i]<x[i+1];
i:=i+1;
until (not t)or (i=n);
writeln(t);
end.
Вычислить величину
( x1 y1+x3y3+...+x29y29)/(x2y2+x4y4+...+x30y30)
program a;
const n=30;
var x,y:array[1..n] of real;
i:integer;s1,s2:real;
begin
for i:=1 to n read(x[i]);
for i:=1 to n read(y[i]);
s1:=0;s2:=0;
for i:=1 to n div 2 do
begin
s1:=s1+x[2*i-1]*y[2*i-1];
s2:=s2+x[2*i]*y[2*i];
end;
writeln(s1/s2);
end.
Дан массив, содержащий цвета ( из набора:красный ,желтый, зеленый, синий, черный, белый).
Найти номер минимального элемента в массиве и отсортировать по убыванию элементов массива.
program a(input,output);
type color=(red,yellow,green,blue,black,white);
var t:array [1..6] of color;
m,i,j,imint:integer;
c,mint:color;
begin
for i:=1 to 6 do
begin read(m);
case m of
1:t[i]:=red;
2:t[i]:=yellow;
3:t[i]:=green;
4:t[i]:=blue;
5:t[i]:=black;
6:t[i]:=white;
end;
end;
{ поиск минимального элемента }
mint:=t[1];imint:=1;
for i:=2 to 6 do
if mint> t[i]
then
begin mint:=t[i];
imint:=i;end;
writeln(' номер минимального элемента ',imint:5);
writeln(' минимальный элемент ');
case ord(t[imint]) of
0: write(' red');
1: write(' yellow');
2: write(' green');
3: write(' blue');
4: write(' black');
5: write(' white')
end;
writeln;
{ cортировка }
for j:=6 downto 2 do
for i:=1 to j-1 do
if t[i] < t[i+1] then
begin c:=t[i+1];t[i+1]:=t[i];t[i]:=c;
end;
writeln(' массив после сортировки :');
for i:=1 to 6 do
case ord(t[i]) of
0: write(' red');
1: write(' yellow');
2: write(' green');
3: write(' blue');
4: write(' black');
5: write(' white')
end;
end.
ДВУМЕРНЫЕ МАССИВЫ
program primin;
{Программа транспонирует введенную матрицу, вводя строки как столбцы, а
столбцы как строки.После чего выводит ее в рамке составленной из введен-
ного символа}
type mas1=array[1..5,1..5] of integer;
var m:mas1;ob:char;k,i,j:integer;
begin
write('Введите символ рамки ');readln(ob);
{Вводится и транспонируется матрица}
writeln('Ввод элементов матрицы');
for j:=1 to 5 do
begin
for i:=1 to 5 do read(m[i,j]);
writeln
end;
{Вывод транспонированной матрицы в рамке}
for i:=1 to 20 do write(ob);
writeln;
for i:=1 to 5 do
begin
write(ob);
for j:=1 to 5 do write(' ',m[i,j]);
writeln(' ',ob)
end;
for i:=1 to 20 do write(ob);
readln(k)
end.
Найти сумму абсолютных значений отрицательных элементов
матрицы x
program nine3;
uses crt;
type mas=array[1..5,1..5] of real;
var s:real;i,j:integer;
x:mas;
begin
clrscr;
writeln (' введите элементы массива х постpочно:');
for i:=1 to 5 do
begin
for j:=1 to 5 do
read(x[i,j]);readln;
end;
s:=0;
for i:=1 to 5 do
for j:=1 to 5 do
if x[i,j] < 0 then s:=s+abs(x[i,j]);
writeln(' сумма абсолют.значений отpиц.элементов:',s:10:4);
end.
{ найти сумму элементов массива из заштpихованной области}
program m2;
var a:array[1..9,1..9] of real;
i,j:integer;
s:real;
begin
{ ввод элементов массива}
for i:=1 to 9 do
begin
for j:=1 to 9 do
read(a[i,j]);
readln;
end;
{
pасчет
суммы
}
s:=a[1,1]+a[9,1]+a[1,9]+a[9,9];
for i:=2 to 8 do
s:=s+a[1,i]+a[9,i]+a[i,1]+a[i,9];
writeln(' сумма элементов в указанной области = ',s:10:4);
end.
{ найти сумму элементов массива из заштpихованной области}
program m2;
var a:array[1..9,1..9] of real;
i,j:integer;
s:real;
begin
{
ввод элементов массива}
for
i:=1 to 9 do
begin
for
j:=1 to 9 do
read(a[i,j]);
readln;
end;
{
pасчет суммы }
s:=0;
for i:=1 to 9 do
s:=s+a[i,i]+a[10-i,i];
s:=s-a[5,5];
writeln(' сумма элементов в указанной области = ',s:10:4);
end.
{ найти сумму элементов массива из заштpихованной области}
program m2;
var a:array[1..9,1..9] of real;
i,j:integer;
s:real;
begin
{
ввод элементов массива}
for
i:=1 to 9 do
begin
for
j:=1 to 9 do
read(a[i,j]);
readln;
end;
{
pасчет
суммы
}
s:=0;
{
веpхний
тp-ник}
for i:=1 to 5 do
for j:=i to 10-i do
s:=s+a[i,j];
{ нижний тp-ник}
for i:=6 to 9 do
for j:=10-i to i do
s:=s+a[i,j];
writeln(' сумма элементов в указанной области = ',s:10:4);
end.
СТРОКИ В ПАСКАЛЕ
ОПИСАНИЕ ТИПА
Для обработки последовательностей символов в ТУРБО-ПАСКАЛЕ
предусмотрены строчные типы. Строчные типы - это структурные ти-
пы.
Количество символов в строке (длина строки) может динами-
чески изменяться от 0 до 255. Для определения данных строкового
типа используется идентификатор string, за которым следует заключенное
в квадратные скобки значение максимально допустимой длины строки
данного типа. Если размер строки не указан, то он считается равным 255.
Переменную строкового типа
можно определить через описание типа в разделе описания типов или
непосредственно в разделе описания переменных. Строковые данные
могут использоваться также в качестве констант. Недопустимо при-
менение строковых переменных в качестве селектора в операторе
case.
Формат: Type
<имя типа> = string [максимальная длина строки];
Var
<идентификатор,...> : <имя типа>;
иначе
Var
<идентификатор,...> : string [максимальная длина строки];
Строковая переменная занимает определённую максимальную дли-
ну байт в памяти плюс один байт, содержащий её текущую длину. От-
дельные символы в строке индексируются от 1 до длины строки.
СТРОКОВЫЕ ВЫРАЖЕНИЯ
Выражения, в которых операндами служат строковые данные, на-
зываются строковыми выражениями. Они состоят из строковых
констант, переменных, указателей функций и знаков операций.
ОПЕРАЦИЯ СЦЕПЛЕНИЯ (+) применяется для сцепления нескольких
строк в одну результирующую строку. Длина результирующей строки
не должна превышать 255.
Выражение Результат
'Дом '+'номер'+' 5/43' 'Дом номер 5/43'
ОПЕРАЦИИ ОТНОШЕНИЯ (=, <>, >, <, >=, <=) проводят сравнение
двух строковых операндов и имеют меньший приоритет, чем операция
сцепления. Результат выполнения операций отношения над строковыми
операндами всегда имеет булевский тип. При сравнении двух срок
одиночные символы сравниваются слева направо. Если строки имеют
разную длину, но одинаковы, за исключением последних символов бо-
лее короткой строки, более короткая строка считается меньшей.
Строки равны, если их длины и содержание одинаковы.
Выражение Результат
'akkord'>'AKKORD' True
'Принтер '<'Принтер' False
Для присваивания строковой переменной результата строкового
выражения используется оператор присваивания (:=).
П р и м е р:
Str1 := 'Группа учащихся';
Str2 := Str1 + ' первого курса';
Если значение переменной после выполнения оператора присва-
ивания превышает по длине максимально допустимую при описании ве-
личину, все лишние символы справа отбрасываются.
Допускается смешение в одном выражении операндов строкового
и литерного типа. Если при этом литерной переменной присваивается
значение строкового типа, длина строки должна быть равна единице,
иначе возникает ошибка выполнения.
К отдельным символам строки можно обратиться по номеру (ин-
дексу) данного символа в строке. Индекс определяется выражением
целочисленного типа, которое записывается в квадратных скобках
сразу за идентификатором строковой переменной или константы.
ПРОЦЕДУРЫ
Delete(St,Pos,N) - удаление N символов строки St, начиная с
позиции Pos. Если значение Pos > 255, возникает ошибка.
Значение St Выражение Результат
'река Волга' Delete(Str, 1, 5); 'Волга'
Insert(Str1,Str2,Pos) - вставка строки Str1 в строку Str2,
начиная с позиции Pos. П р и м е р:
Var S1, S2, S3 : string[11];
...
S1 := ' ЕС '; S2 := 'ЭВМ1841 '; S3 := Insert(S1,S2,4);
Р е з у л ь т а т:
'ЭВМ ЕС 1841'.
Str(IBR,St) - преобразование числового значения величины IBR
и помешение результата в строку St. После IBR может записываться
формат, аналогичный формату вывода.
Значение Выражение Результат
4.8E+03 Str(IBR:10,St); ' 4800'
Val(St,IBR,Cod) - преобразует значение St в величину целочисленного
или вещественного типа и помещает результат в IBR. Значение St не
должно содержать незначащих пробелов в начале и в конце. Cod -
целочисленная переменная. Если во время операции преобразования
ошибки не обнаружено, значение Cod равно нулю, если ошибка обна-
ружена, Cod будет содержать номер позиции первого ошибочного сим-
вола, а значение IBR не определено.
Значение Выражение Результат
'14. 2E+02' Val(St,IBR,Cod); 1420 Cod=0
ФУНКЦИИ
Copy(St,Pos,N) - выделяет из St подстроку длиной N символов,
начиная с позиции Pos. Если Pos > Length(St), то результатом бу-
дет пробел; если Pos > 255, возникает ошибка при выполнении.
Concat(Str1,Str2,...,StrN) - выполняет сцепление строк
Str1,Str2,..., StrN в том порядке, в каком они указаны в списке
параметров. Сумма символов всех сцепленных строк не должна превы-
шать 255.
Length(St) - вычисляет длину строки St в символах. Результат
имеет целочисленный тип.
Pos(Str1,Str2) -обнаруживает первое появление в строке Str2
подстроки Str1. Результат имеет целочисленный тип и равен номеру
той позиции, где находится первый символ подстроки Str1. Если в
строке Str2 подстроки Str1 не найдено, результат равен нулю.
UpCase(Ch) - преобразует строчную букву в прописную. Пара-
метр и результат имеют литерный тип. Обрабатывает буквы только
латинского алфавита.
ПРИМЕРЫ:
{ Дана стpока 80 символов . Вычислить общее число символов
'+','-','*' в данной стpоке.}
program st1;
const n=10;
var s:string[n];
i,m:integer;
begin readln(s);m:=0;
for i:=1 to length(s) do
if (s[i]='+') or (s[i]='-')or (s[i]='*') then m:=m+1;
writeln('m=',m);
end.
{ пpовеpить, является ли введенная совокупность символов
именем месяца на pусском языке}
program m;
const
instance:array [1..12] of string[10]=
('янваpь','февpаль','маpт','апpель','май',
'июнь','июль','август','сентябpь','октябpь','ноябpь','декабpь');
month:boolean=false;
var str:string[10];
i:integer;
begin
writeln('введите заглавные символы: ');
readln(str);
for i:=1 to 12 do
if str=instance[i] then month:=true;
if month then
writeln( ' введено имя месяца') else
writeln(' введено не имя месяца ');
end.
Записи.
Запись есть структура данных,построенная из компонент,имеющих в общем случае разные типы данных.
Например,чтобы описать в программе время суток 10.45 утра или 7.15 вечера) , можно использовать структуру данных следующего формата:
-
часы
минуты
до полудня
в которой 10.45 утра может храниться как
|
10 |
45 |
true |
а 7.15 вечера :
|
7 |
15 |
false |
Эта структура является записью с тремя компонентами.
Компонент записи называется полем и обозначается идентификатором: именем поля.
Описание записей определяются
а) с применением типов:
type
timetype= record
hour:1..12;
minute:0..59;
befornoon:boolean
end;
var now,later:timetype;
Т.о. описан тип timetype , являющийся записью, состоящей из 3-х полей, и две переменные этого типа now и late.
Б) в разделе описания переменных :
var
now, later: record
hour:1..12;
minute:0..59;
befornoon:boolean
end;
Секция записи определяет одно или несколько имен полей и тип соответствующей компоненты. Если в секции перечисляется несколько имен полей, то все они однотипны.
Тип компонента в секции записи может быть любым типом данных и быть именем предопределенного типа, именем ранее определенного типа.
К каждому компоненту записи можно обратиться, используя имя переменной типа записи и имя поля, разделенные точкой: now.hour, later.befornoon;
Рассмотрим программу bestseller ( лучший товар), которая вводит с клавиатуры данные по сбыту за несколько лет, распечатывает их и находит продукцию с максимумом сбыта.
Входные данные :
Каждая вводимая строка содержит информацию о продаже в следующей форме:
год продажи: целое в диапазоне 1900..2099;
код продукции: четырехзначное целое ;
общий объем сбыта: вещественное число, обозначающее сумму в денежных единицах.
Ввод заканчивается,когда введена строка с отрицатедьным значением года.
program bestseller;
{ находит наиболее ходкий товаp из отчетов по пpодаже}
var any,best: record
year:1900..2099;
number:0..9999;
sales:real
end;
begin
best.sales:=0.0;
writeln(' введите');
writeln(' год пpодукт сумма пpодаж');
readln(any.year,any.number,any.sales);
while any.year > 0 do
begin
readln(any.year,any.number,any.sales);
if any.sales> best.sales then
best:=any;
end;
writeln;
writeln(' лучший товаp:',best.number:4,' с общей суммой пpодаж ');
writeln(' гpивнив :',best.sales:10:2,' в ',best.year:4);
end.
Оператор присоединения.
Приведенные операторы ввода можно записать более компактно, используя оператор присоединения with.
Простейшая форма оператора присоединения:
with V1 do
s1;
где V1-имя переменной записи, а S1- оператор.
S1- тело оператора присоединения и внутри него выборка поля переменной V1 может быть обозначена просто именем этого поля.
program bestseller;
{ находит наиболее ходкий товаp из отчетов по пpодаже}
var any,best: record
year:1900..2099;
number:0..9999;
sales:real
end;
begin
best.sales:=0.0;
writeln(' введите');
writeln(' год пpодукт сумма пpодаж');
with any do
begin
readln(year,number,sales);
end;
while any.year > 0 do
begin
readln(any.year,any.number,any.sales);
if any.sales> best.sales then
best:=any;
end;
end;
writeln;
writeln(' лучший товаp:',best.number:4,' с общей суммой пpодаж ');
writeln(' гpивнив :',best.sales:10:2,' в ',best.year:4);
end.
Массивы записей.
Ввести список студентов из 5 человек, включающий в себя фамилию (10 символов), год рождения ( четырехзначное целое), оценки ( массив из 5 целых чисел).
Выдать данный список, добавив к нему средний балл. Выдать список отличников, упорядоченных по году рождения.
Например,
|
Фамилия |
Год рождения |
Оценка 1 |
Оценка2 |
Оценка 3 |
Оценка 4 |
Оценка 5 |
|
Иванов |
1976 |
5 |
5 |
3 |
4 |
3 |
|
Петров |
1975 |
5 |
5 |
5 |
5 |
5 |
|
Сидоров |
1967 |
3 |
4 |
5 |
4 |
4 |
|
Кузькина |
1974 |
5 |
5 |
5 |
5 |
5 |
|
Синицына |
1977 |
5 |
5 |
5 |
5 |
5 |
program a(input,output);
type stud=record
fio:string[10];
godr:integer;
ocen:array [1..5] of integer;
end;
var gr:array[1..5] of stud;
ff:string[10] ;
s1:stud;m,k,i,r,j:integer;sr:array[1..5] of real;s:real;
begin
for i:=1 to 5 do
begin
read (s1.fio);
read(s1.godr);
for j:=1 to 5 do read(s1.ocen[j]);
gr[i]:=s1;readln;
sr[i]:=0;
for j:=1 to 5 do
sr[i]:=sr[i]+gr[i].ocen[j];
sr[i]:=sr[i]/5; end;
writeln('список группы');
for i:=1 to 5 do begin
write (gr[i].fio,' '); write(gr[i].godr:5);
for j:=1 to 5 do write(gr[i].ocen[j]:3);writeln(sr[i]:4:1);
end;
for k:=5 downto 2 do
begin
m:=1;
for i:=2 to k do
if gr[i].godr > gr[m].godr then m:=i;
r:=gr[k].godr;
gr[k].godr:=gr[m].godr;
gr[m].godr:=r;
ff:=gr[k].fio;
gr[k].fio:=gr[m].fio;
gr[m].fio:=ff;
s:=sr[k];
sr[k]:=sr[m];
sr[m]:=s;end;
writeln(' Список отличников, упорядоченный по году рождения');
for i:=1 to 5 do begin
with gr[i] do begin
if sr[i] >= 5 then
write( fio,' ',godr:4);
writeln;end;end;
end.
Записи с вариантами.
При определении типа записи в нее можно включать вариантную часть. Это означает, что разные переменные, хотя они относятся к одному типу, могут иметь различные структуры.
Например, пусть необходимо задать информацию о некотором человеке, указав фамилию и год рождения, а также, если это мужчина, то сообщить , военнообязан ли он и какую имеет специальность, а если это женщина, то указать, замужем ли она и сколько имеет детей.
Type pol=(m,w);
people=record
fam:string[20];
godro:1000..2000;
mw:pol;
case pol of
m: ( voen:boolean;spec:string[15]);
w: ( merry:boolean;child:integer)
end;
var p1,p2: people;
Вариантная часть записи начинается оператором case и следует за общей частью; после ее окончания в записи не могут появляться никакие другие поля, поэтому оператор case закрывается служебным словом end.
Любая запись может иметь только одну вариантную часть, которая должна размещаться в конце записи ( после фиксированной части). Однако, внутри какого-либо варианта, в свою очередь, другая вариантная часть, вложенная в первую.
При записи варианта ( списков элементов) обязательно наличие круглых скобок, даже если в них ничего не заключается.
Все имена элементов должны быть различными, даже если они встречаются в разных вариантах.
К элементам вариантной части можно обращаться так же,как к элементам фиксированной части записи. P1.mw:=m; p1.voen:=true; p2.child:=2;
В процессе выполнения программы в структуру записи включается тот вариант, элементам которого в данный момент было присвоено значение. Как только какому-либо элементу другого варианта присваивается некоторое значение, в структуру записи включается этот вариант, а элементы предыдущего варианта становятся неопределенными.
МНОЖЕСТВА В ПАСКАЛЕ.
Под множеством в языке ПАСКАЛЬ понимают ограниченный, неупо-
рядоченный набор различных элементов одинакового типа. Тип эле-
ментов, входящих в множество, называется базовым. В качестве ба-
зового типа можно использовать простые типы: стандартный, кроме
действительного, перечисляемый и ограниченный.
Множество включает в себя все подмножества данного множест-
ва, в том числе и пустое подмножество, которое не содержит ни од-
ного элемента.
Объявляются множества, как и другие типы, могут либо в раз-
деле переменных, либо с использованием раздела типов.
Объявление множества в разделе переменных имеет вид:
VAR имя множества: SET of базовый тип;
Например:
var C:SET of char;
var GOD:SET of 1880..2000;
Объявление множества с использованием раздела типов:
TYPE имя типа = SET of базовый тип;
VAR имя множества : имя типа;
Значение переменных и констант множества задаются в разделе
операторов с помощью конструктора. Конструктор представляет собой
список элементов базового типа, заключенный в квадратные скобки.
Например:
ФИГУРА:=[круг, ромб, квадрат];
М3:=[ ];
В языке ПАСКАЛЬ имеются следующие операции над множествами :
Объединение множеств : S1+S2 .
Множество S1+S2 содержит элементы, которые принадлежат либо S1,либо S2, либо и тому и другому вместе.
Пересечение множеств : S1*S2 .
Множество S1*S2 содержит элементы, которые принадлежат как S1, так и S2 (общие).
Разность множеств : S1-S2 .
Множество S1-S2 содержит элементы из S1, которые не принадлежат S2.
Равенство множеств : S1=S2.
S1=S2 тогда и только тогда, когда оба множества содержат одни и те же элементы.
Включение множества : S1<=S2 , S2>=S1 .
S1<=S2 принимает значение true, когда все элементы S1 являются также элементами S2.
6. Принадлежность множеству .
Для проверки принадлежности множеству применяется операция
IN : X in S1
Результат выполнения операции TRUE, если X принадлежит мно-
жеству S1 . Проверка на принадлежность множеству используется в
программах для исключения сложных условий. Выражение с использо-
ванием логических операций вида : (ch>='0') and (ch<='9') с
использованием операции IN будет иметь вид:
СН IN ['0'..'9']
Действия с множествами выполняются быстрее , чем сложные вы-
ражения с использованием логических операций.
Язык ПАСКАЛЬ допускает использование множественного типа
данных в качестве элемента любого другого структурированного типа
(массива, записи ), что значительно расширяет возможность языка.
Дано 20 первых чисел. Определить числа, кратные 6, 2 или 3.
PROGRAM PASSET(input,output);
const n=20;
var
N2,N3,N6,N23:set of 1..n;
K:integer;
begin
N2:=[];
N3:=[];
for k:=1 to n do
begin
if K mod 2=0 then N2:=N2+[K];
if K mod 3=0 then N3:=N3+[K]
end;
N6:=N2*N3;
N23:=N2+N3;
writeln('числа , кратные 6 : ');
for k:=1 to n do
if k in N6 then write(k:3);
writeln;
writeln('кратные 2 или 3 : ');
for k:=1 to n do
if k in N23 then write(k:3)
end.
{ дана стpока символов с точкой в конце стpоки.
Hужно опpеделить число pазличных букв, входящих в данную стpоку}
program mn;
var m:set of char;
i:char;
mos:integer;
begin
{ ввод множества m}
m:=[]; read(i);
while i<> '.' do
begin
m:=m+[i];
read(i);
end;
mos:=0;
for i:='a' to 'z' do
if (i in m ) then mos:=mos+1;
write(' кол-во pазных букв=',mos);
end.
ФАЙЛОВЫЙ ТИП . .
ФАЙЛОВЫЙ ТИП ,является составным типом , образуется из компо-
нент одинакового типа , которые называются элементами .В отличие
от массивов количество элементов файла в описании не установле-
но,оно зависит от того с каким набором данных будет связан файл .
Описание файлового типа состоит из ключевого слова file ,за
которым следует ключевое слово of , а за ним описание типа эле-
ментов файла .Элементами файла могут быть объекты любых простых
типов .
Операции над файлами могут осуществляться только при помощи
процедур и функций. Перед этим файл должен быть открыт ,связь фай-
ла с набором данных происходит с помощью процедуры assign ,откры-
тие файла осуществиться с помощью reset и rewrite.Для закрытия
файла служит процедура close.
После открытия указатель файла находится в начальном положе-
нии .Указатель можно изменить с помощью процедуры seek .Текущий
размер файла можно определить с помощью функции filesize ,а теку-
щее положение указателя с помощью функции filepos .если файл
установлен в промежуточном положении ,то есть между началом и
концом ,то каждое выполнение процедуры write приведет к изменению
ближайшего элемента файла .Это изменение никак не повлияет на
остальные элементы файла .Поэтому файлы с элементами установлен-
ного типа могут представлять наборы данных с последовательным и
прямым доступом .
|
функции и процедуры |
назначение |
|
assign (var F:file;name:string); |
связывает файл с набором данных на диске .
|
|
reset (var F:file); |
открывает файл ,указатель файла устанавливается в начальное положение , т.е. перед первым элементом |
|
read ( var F:file;var x1,x2,...,xn); |
обеспечивает чтение с файла в заданную переменную; - |
|
write(var F:file;x1,x2,...,xn); |
обеспечивает запись в файл заданной переменной |
|
rewrite (var F:file); |
обеспечивает установку указателя файла в начало для записи,файл стирается |
|
seek (var F:file;n:longint); |
устанавливает указатель файла на нужную позицию ; |
|
close (var F:file); |
закрывает файл ; |
|
erase (var F:file); |
удаление файла ; |
|
rename (var F:file;newname:string); |
переименование файла; |
|
eof (var F:file):boolean; |
указатель конца файла ; |
|
filesize (var F:file):longint; |
определяет количество элементов файла |
|
filepos(var F:file):longint; |
отыскание последовательности элементов в файле ; |
program thr;
var upn :file of real;
{ Сфоpмиpовать файл из 10 вещественных чисел,
пpовеpить на упоpядоченность компонентов файла}
a,b:real;
t:boolean;i:integer;
begin
assign(upn,'e:\dat.dat');
rewrite(upn);
for i:=1 to 10 do
begin
read(a);write(upn,a);
end;close(upn);
reset (upn);
t:=true;
read(upn,a);
while not eof(upn) and t do
begin read(upn,b);
if a>b then t:=false
else a:=b;
end;
if t then write(' компоненты упоpядочены')
else write(' компоненты неупоpядочены');
end.
{ Coздать файл,содеpжащий фамилию студента, его возpаст,
факультет;конец ввода- ввод без фамилии,
вывести на экpан студетов заданного факультета,стаpше 25 лет}
program c;
type zap=record
fio:string[20];
age:0..99;
fac:string[5];
end;
var f:file of zap;facult:string[5];i:integer;ved:zap;t:boolean;
begin
assign(f,'facul.dat');i:=1; t:=false;
rewrite(f);
repeat
write(' студент N',i:3,' фамилия:');readln(ved.fio);
if ved.fio='' then t:=true else begin
write(' возpаст: ');readln(ved.age);
write(' факультет: ');readln(ved.fac);
i:=i+1;
write(f,ved);
end;
until t;
close(f);
writeln(' введите название факультета '); readln(facult);
{ чтение из файла записи и анализ ее}
reset(f);
while not eof(f) do
begin
read(f,ved);
if (ved.age >25) and (ved.fac=facult) then writeln(ved.fio);
end;
close(f);
end.
{ добавить данные к файлу;
a) откpытие существующего файла пpоцедуpой reset
b) установление указателя файла за последним его компонентом пpоцедуpой seek
c) записать дополнительные данные
d) закpыть файл close}
program c;
type zap=record
fio:string[20];
age:0..99;
fac:string[5];
end;
var f:file of zap;facult:string[5];i,k:integer;ved:zap;t:boolean;
begin
assign(f,'facul.dat') ;
reset(f);
seek(f,filesize(f));
writeln(' введите новую запись:');
write(' студент: ',' фамилия:');readln(ved.fio);
write(' возpаст: ');readln(ved.age);
write(' факультет: ');readln(ved.fac);
write(f,ved);
close(f);
{ коppектиpовка данных в файле:
a) откpыть коppектиpуемый файл(reset)
b) подвести указатель файла к коppектиpуемому элементу(seek)
c) считать коppектиpуемый элемент(read)
d) откоppектиpовать элемент файла
e) повтоpить пpоцедуpу подвода указателя элемента ( seek)
f) записать откоppектиpованный элемент (write)
g) закpыть файл( close)}
writeln( ' Коppектиpовка записи с данным поpядковым номеpом');
writeln('--------------------------------------------------');
write(' введите номеp коppектиpуемой записи');readln(k);
reset(f);
seek(f,k-1);read(f,ved);
writeln(' запись будет изменена');
write('cтудент',ved.fio);write(' возpаст ',ved.age);
writeln(' фак ',ved.fac);
writeln(' введите новую запись');
write(' студент N',k:3,' фамилия:');readln(ved.fio);
write(' возpаст: ');readln(ved.age);
write(' факультет: ');readln(ved.fac);
seek(f,k-1);
write(f,ved);
close(f);
end.
Пример корректировки на экране текста , записанного в файл, элементами которого
являются двухмерные массивы символьного типа, с использованием модуля Crt.
Коды клавиатуры см. в разделе “ Модуль Crt”.
program korr(input,output);
uses Crt;
const strok=25;wstroke=80;ch=' ';
type obrazz=array[1..25,1..80] of char;
var fdisz:file of obrazz;
kk,l,j,m:integer;
obrazstrekr,rm:obrazz;
chh,kod:char;i,k,st,wstr:byte;
s:string[80];
procedure wiwobr;
begin
for i:=1 to strok do
for k:=1 to wstroke do
begin
(* GotoXY(k,i);*)
if(i=strok) and (k=wstroke) then exit else
write(obrazstrekr[i,k]);
end;
GotoXY(1,1);
end;
procedure zapobr;
begin assign (fdisz,'e:\tp\ucheb\fdisz.data');
rewrite (fdisz);
for l:=1 to 25 do
for j:=1 to 80 do
rm[l,j]:='a';
write(fdisz,rm);
close(fdisz);
end;
procedure korrobr;
label 50,60;
begin
TextMode(Co80);
st:=1;wstr:=1;
CLrscr;wiwobr;
50: GotoXY(st,wstr);while keypressed do
kod:=Readkey;
kod:=Readkey;
if kod =#0 then begin
kod:=Readkey;
kk:=ord(kod);
if kod = #72 then begin
if wstr > 1 then wstr:=wstr-1
else wstr:=1;
goto 50;end;
if kod= #80 then begin
if wstr < 25 then wstr:=wstr+1
else wstr:=25;
goto 50;end;
60: if (kod=#77) then begin
if (st < 80)
then st:=st+1
else st:=80;
goto 50;end;
if (kod=#75) then begin
if (st >1 )
then st:=st-1
else st:=1;
goto 50;end;
if (kod=#71) then begin st:=1;
goto 50;end;
if kod =#79 then begin st:=80;
goto 50;end;
if kod=#83 then begin
for m:=st to 79 do
obrazstrekr[wstr,m]:=obrazstrekr[wstr,m+1];
obrazstrekr[wstr,80]:=' ';GotoXY(1,wstr);
for m:=1 to 80 do
write(obrazstrekr[wstr,m]);
goto 50; end;
if kod=#82 then begin chh:=Readkey;write(chh);
for m:=79 downto st do
obrazstrekr[wstr,m+1]:=obrazstrekr[wstr,m];
obrazstrekr[wstr,st]:=chh;GotoXY(1,wstr);
for m:=1 to 80 do begin
write(obrazstrekr[wstr,m]);end;
goto 50;
end;end;
if (kod > #31) and (kod < #239)then begin
chh:=kod;
obrazstrekr[wstr,st]:=chh;
write(chh);
kod:=#77;
goto 60 ;end;
if kod=#25 then begin Delline;
for i:=wstr to 24 do
for j:=1 to 80 do
obrazstrekr[i,j]:=obrazstrekr[i+1,j];
for j:=1 to 80 do
obrazstrekr[25,j]:=ch;end;
if kod =#14 then begin Insline;
for i:=24 downto wstr do
for j:=1 to 80 do
obrazstrekr[i+1,j]:=obrazstrekr[i,j];
for j:=1 to 80 do
obrazstrekr[wstr,j]:=ch;
goto 50;end;
if kod <>#13 then goto 50;
end;
procedure zap1;
begin
rewrite(fdisz);
write(fdisz,obrazstrekr);
close(fdisz);
end;
procedure ctenobr;
begin
reset(fdisz);
read(fdisz,obrazstrekr);
close(fdisz);
end;
begin
Clrscr; assign(fdisz,'e:\tp\ucheb\fdisz.data');
(* zapobr;*)
ctenobr;korrobr;zap1;
end.
Особым типом файлов являются текстовые файлы. Эти файлы содержат некоторый текст, который состоит из обычных символов. Символы текстового файла разбиты на строки , подобно тому, как они записываются на бумаге.
Олисание текстового файла имеет следующий вид:
var имя_файла : text;
Здесь text- стандартный идентификатор , точно такой же, как real, char и т.п.
Отличие текстового файла от файла типа char или string заключается в том, что текстовый файл состоит из последовательности строк различной длины, каждая из которых содержит величины типа char и заканчивается специальным символом конца строки. Для определения конца строки используется функция
eoln( var f:text):boolean
Она принимает значение true, если достигнут конец строки, и значение false - в противном случае. Если в Eoln параметр f опущен , то подразумевается использование стандартного файла ввода input.
Для работы с текстовыми файлами используются дополнительные процедуры
|
имя процедуры |
Назначение |
|
Append( var F:text); |
Открытие уже существующего текстового файла F для добавления данных в конец файла |
|
Readln(var F:file); |
Переход к началу следующей строки текстового файла F ( при его чтении ) |
|
Writeln( var F:file); |
Завершение текущей строки текстового файла F ( при его записи ) |
|
Writeln(var F:file,x1,x2,...,xn); |
запись в текстовый файл F значений переменных x1,x2,...,xn с завершением текущей строки |
|
Readln(var F:file,x1,x2,...,xn); |
чтение n символов файла с переходом к новой строке |
|
|
|
Данные для текстового файла можно готовить с помощью обычного текстового редактора.
Прочитать из текстового файла А все записанные в него целые числа, преобразовать их в вещественные и вывести в текстовый файл В по 4 числа в строчку.
program ex;
var f1,f2:text;
x:real;i:integer;
begin
assign(f1,'e:\tp\bin\A');
reset(f1);
assign(f2,'e:\tp\bin\B');
rewrite(f2);
repeat
for i:=1 to 4 do
if not eof(f1) then
begin
read(f1,x);
write(f2,x:18);
end;
writeln(f2);
until eof(f1);
close(f1);
close(f2);
end.
ПРОЦЕДУРЫ и ФУНКЦИИ ЯЗЫКА ПАСКАЛЬ
В практике программирования типичной является такая ситуация , когда в разных местах программы приходится выполнять по сути дела один и тот же частный алгоритм , который имеет достаточно самостоятельное значение , т.е. предназначен для решения некоторой подзадачи , выделенной из основной решаемой задачи , например нахождение наибольшего общего делителя двух натуральных чисел , упорядочение компонентов вектора и т.д. Если этот частный алгоритм достаточно сложен и представляется достаточно большим фрагментом текста , то было бы явно нерационально выписывать его каждый раз заново в том месте программы , где этот алгоритм должен использоваться.
Для обеспечения большей компактности программы и повышения её наглядности язык Паскаль позволяет выделить любой частный алгоритм из программы и записать его только один раз, представив этот частичный алгоритм в качестве самостоятельной программной единицы , называемой процедурой.
1.ПОДПРОГРАММА-ПРОЦЕДУРА
1.1.Описание процедур. Процедуры описываются в специальном разделе основной программы вслед за разделом переменных. Любая процедура является логически законченной программной единицей и поэтому содержит внутри себя теже разделы , что и основная программа :
раздел описаний (меток , констант , типов , переменных процедур и функций);
раздел операторов, представляющий собой составной оператор BEGIN-END.
Процедура состоит , аналогично программе , из заголовка и тела процедуры.
Заголовок процедуры имеет вид:
PROCEDURE имя (список формальных параметров);
где PROCEDURE-служебное слово; имя-имя процедуры , определяемое в соответствии с общими правилами образования идентификаторов; список формальных параметров-перечень имен для обозначения исходных данных и результатов работы процедуры с указанием их типов.
Допускается описание процедуры не содержащей формальных параметров:
PROCEDURE имя;
Всякая подпрограмма-процедура может содержать свои внутренние или вложенные процедуры.Степень вложенности определяется возможностями машины.
Заканчивается блок процедуры точкой с запятой.
ПРИМЕР 1.1.Оформить в виде процедуры вычисление степени c натуральным показателем N.
procedure STEP1 (N:integer;X:real;var Y:real);
var
I:integer;
begin
Y:=1;
for I:=1 to N do
Y:=Y*X;
end;
В заголовке процедуры с именем STEP1 перечислены парамет ры N,X, определяющие исходные данные программы и параметр Y, обозначающий значение искомой степени-результат выполнения процедуры.Указан также тип всех формальных параметров.Подроб-ней о параметрах будет расказано ниже.
1.2.Обращение к подпрограмме-процедуре
Описание процедуры , расположенное в разделе описаний ,
само по себе никаких действий не вызывает.Чтобы исполнить процедуру необходимо в нужном месте программы поместить обра-щение ней.Обращение производится с помощью оператора вызова процедуры или оператора процедуры , имеющего вид:
имя (список формальных параметров);
где имя-имя вызываемой процедуры; список формальных па-
раметров-перечень конкретных зна чений (выражений) и
имен , передаваемых из основной программы в процеду-
ру на место формальных параметров
При вызове процедуры формальные параметры заменяются фактичес кими в порядке их следования.Число и тип формальных и факти-ческих параметров должны попарно совпадать.
ПРИМЕР 1.2.Составить программу использующую в своём теле вызов процедуры , описанной в ПРИМЕРЕ 1.1.(вычисление степени с натуральным показателем).
program MAIN (input,output);
var
M:integer;
A,Z:real;
procedure STEP1(N:integer;X:real;var Y:real);
var
I:integer;
begin
Y:=1;
for I:=1 to N do
Y:=Y*X;
end;
begin
read(A,M);
STEP1(M,A,Z);
write(‘ M=’,M,’ A=’,A,’ Z=’,Z)
end.
В данном примере оператор процедуры осуществляет её вызов.В теле процедуры произойдёт замена формальных переменных на фактические. Затем выполняется совокупность действий, предусмотренных операторами процедуры , и в основную программу будет возвращен результат Z.
Дан массив. Вычислить количество элементов массива, кратных 6. В программе предусмотреть процедуры ввода и вычисления количества элементов.
program d;
type mas=array[1..100] of integer;
var n,i,n6:integer;
m:mas;
procedure vvod(var x:mas;n:integer);
begin
for i:=1 to n do
read(x[i]);
end;
procedure shet(x:mas;n:integer;var k:integer);
begin
k:=0;
for i:=1 to n do
if x[i] mod 6 =0 then k:=k+1;
end;
begin
writeln(' введите количество элементов массива');readln(n);
writeln('ввод элементов :');
vvod(m,n);shet(m,n,n6);
writeln(' количество чисел, кратных 6=',n6:2);
end.
2.ФУНКЦИИ
Заголовок содеpжит заpезеpвиpованное слово
FUNCTION,идентификатоp(имя) функции,заключенный в кpуглые скобки,необязатель-ный список фомальных паpаметpов и тип возвpащаемого функцией значения. FUNCTION <имя> {(фоpмальные паpаметpы)}:<тип pезультата>;
Имя функции-уникальный идентификатоp в пpеделах блока.Возвpащаемый pезультат может иметь любой скаляpный тип,тип string и тип “указатель”. Тело функции пpедставляет собой локальный блок,по стpуктуpе аналогичный пpогpамме:
function<имя>{(фоpмальные паpаметpы)}:<тип pезультата>;
<pазделы описаний>
begin
<pаздел опеpатоpов>
end;
В pазделе опеpатоpов должен находиться по кpайней меpе один опеpатоp,пpисваивающий идентификатоpу функции значение.Если таких пpисваиваний несколько,то pезультатом выполнения функции будет значение последнего опеpатоpа пpисваивания Обpащение к функции осуществляется по имени с необязательным указанием списка аpгументов.Каждый аpгумент должен соответствовать фоpмальным паpаметpам,ука-занным в заголовке и иметь тот же тип.В качестве фоpмальных паpаметpов можно использовать:паpаметpы-значения,паpаметpы-пеpеменные,паpаметpы-пpоцедуpы и паpаметpы-функции.
Для иллюстpации использования функций pассмотpим подпpогpамму,котоpая воз-дит в степень положительное или отpицательное число.
Program DemoFunction(input,output);
var
z:integer; k:real;
Function Step(F:real;Exp:integer):real;
var
c:integer;
T:real;
begin
if Exp=0 then Step:=1
else
begin
T:=F;
for c:=2 to Abs(Exp) do T:=T*F;
if Exp<0 then Step:=1/T
else Step:=T end;
Begin
writeln(‘введите число:’);
read(z);
writeln(Step(z,3));
writeln(Step(z,4));
k:=1.4;
writeln(Step(k,4))
End.
10 5
Вычислить u=x iy10-i + (x-y)i z 10-i
i=1 i=2
program f;
var u,t,x,y,z:real;
function s( a,b:real;n,m:integer):real;
var sum:real;i:integer;
begin
sum:=0;
for i:=n to m do
sum:=sum+exp(i*ln(a))*exp((10-i)*ln(b));
s:=sum;
end;
begin
writeln(' введите значение x,y,z');
readln(x,y,z);
t:=x-y;
u:=s(x,y,1,10)+s(x-y,z,2,5);
writeln(' u=',u:12:6);
end.
Max(a,b,c)-min(a, b 2,c)
Вычислить
Z=
min(a+b,b+c,a+c)+max(a 2,b 2, c2)
program ABC;
var a,b,c,z:real;
function min( d,f,g:real):real;
var m:real;
begin
if d<f then m:=d
else m:=f;
if m>g then m:=g;
min:=m;
end;
function max( d,f,g:real):real;
var m:real;
begin
if d>f then m:=d
else m:=f;
if g>m then m:=g;
max:=m;
end;
begin
writeln('введите a,b,c');
read(a,b,c);
z:=(max(a,b,c)-min(a,b*b,c))/(min(a+b,b+c,a+c)+max(a*a,b*b,c*c));
writeln(' z=' ,z:15:3);
readln; readln;
end.
Процедурные типы данных.
В Turbo Pascale процедуры и функции можно рассматривать как некоторые параметры и можно использовать переменные, принимающие значение процедуры или функциию С этой целью вводятся процедурные типы, которые указывают , какой вид подпрограммы можно использовать в качестве параметра и с какими параметрами должны быть эти подпрограммы.
Описание переменных процедурного типа:
type имя_типа1=procedure( формальные_параметры);
имя_типа2=function(формальные параметры): тип;
var имя1:имя_типа1;
имя2:имя_типа2;
Все процедуры и функции , имена которых присваиваются процедурным переменным, необходимо транслировать в режиме { $F+}. Вложенные функции и процедуры, т.е. , описанные внутри других процедур , с процедурными переменными использовать нельзя.Это не должны быть также стандартные роцедуры и функции.
type proc=procedure;
func=function (x,y:integer):integer;
var p1:proc;f:func;p2:pr;
n:integer;
n
Составить программу вычисления суммы f(x) , когда вид функции заранее неизвестен.
x=1
program pr;
type Func=function(x:integer):real;
var s1,s2:real;
{$F+}
function f1(x:integer):real;
begin f1:=x/(x+1);
end;
function f2(x:integer):real;
begin f2:=5*x*x+2;
end;
{$F-}
function Sum(n:integer;f:func):real;
var i:integer;
s:real;
begin
s:=0;
for i:=1 to n do s:=s+f(i);
sum:=s;
end;
begin { main program}
s1:=sum(100,f1);
s2:=sum(200,f2);
writeln(‘ s1=’, s1,’ s2=’,s2);
end.
ДИНАМИЧЕСКИЕ ОБЪЕКТЫ И ССЫЛКИ
Динамическими объектами называются программные объекты, которые
возникают в процессе выполнения программы и размер значений которых
определяется (или изменяется) при выполнении программы.
Для работы с динамическими объектами предусматривается специальный
тип значений - ссылочный тип. Значением этого типа является ссылка на
какой-либо программный объект, по которому осуществляется непосредст-
венный доступ к этому объекту. На машинном языке такая ссылка как раз и
представляется указанием места в памяти (адресом) соответствующего
объекта.
Для описания действий над динамическими объектами каждому тако-
му объекту в программе сопоставляется статическая переменная ссылочного
типа - в терминах этих ссылочных переменных и описываются действия над
соответствующими динамическими объектами. Значения же переменных ссы-
лочного типа, как обычно, определяются уже в процессе выполнения прог-
раммы, а для достаточно удобного формирования таких значений в языке
предусмотрены соответствующие средства.
В паскале с целью повышения надежности программ - в этом задании
обязательно должен фигурировать тип значений тех динамических прог-
раммных объектов, на которые будут указывать значения переменных заЎа-
ваемого ссылочного типа.
VAR
p:^ INTEGER
или
TYPE
mas = ARRAY [1...12] of CHAR
VAR
g:^ mas
где стрелка • - это признак ссылочного типа;
p,g - имеют либо стандартный, либо ранее описанный тип
значения.
Значениями переменных определенного таким образом ссылочного типа
могут быть ссылки на динамические объекты, причем только того типа, имя
которого указано в задании после стрелки. В задании ссылочного типа
после стрелки может фигурировать только имя типа динамического объекта,
но не непосредственное его задание.
Значения всех статических ссылочных переменных указывают место в
памяти соответствующего динамического объекта, поэтому переменные ссы-
лочного типа часто называют указателями.
*
объект
Здесь звездочкой изображено значение указателя p, а стрелка, исхо-
дящая из этой звездочки, указывает, что значением указателя является
ссылка на объект, посредством которой он и доступен в программе.
В некоторых случаях возникает необходимость в качестве значения
указателя принять такую ссылку, которая не связывает с данным указате-
лем никакого объекта, т.е. "пустую" ссылку. Такое значение задается
служебным словом NIL и принадлежит любому ссылочному типу. Результат
выполнения оператора присваивания p:=NIL можно изобразить следующим об-
разом:
*
В начальный момент после введения в употребление ссылочной пере-
менной в разделе описаний, она не ссылается ни на какой программный
объект и даже не имеет в качестве своего значения пустой ссылки NIL.
Таким образом, описание
VAR V: ^ Т
лишь вводит в употребление статическую переменную V ссылочного типа, но
не вводит в употребление никакого программного объекта типа Т, на кото-
рый будет указывать значение этой ссылочной переменной V. Это описание
говорит лишь о том, что значениями переменной V могут быть ссылки на
такие объекты. Для порождения же самого динамического объекта служит
стандартная процедура с именем new, например NEW(p). В результате вы-
полнения оператора процедуры такого вида порождается новый объект типа,
указанного в описании той ссылочной переменной, которая задана в ка-
честве фактического параметра, и в качестве значения этой ссылочной пе-
ременной присваивается ссылка на этот вновь порожденный объект. В дан-
ном случае порождается переменная типа INTEGER, а указателю р в качест-
ве значения присваивается ссылка на эту только что порожденную перемен-
ную.
При этом порожденному динамическому объекту не присваивается како-
го-либо значения, так что для динамического объекта процедура NEW игра-
ет ту же роль, что и описание для статического объекта.
Для ссылки на динамический объект в языке имеется такое понятие,
как переменная с указателем:
VAR
p:^ INTEGER
BEGIN
.
.
.
p^ = 37
.
.
END
Ccылочная переменная р есть имя той статической перменной ссылоч-
ного типа, которая в программе поставлена в соответствие данному дина-
мическому объекту. Стрелка • после ссылочной переменной свидетельствует
о том, что здесь речь идет не о значении самой ссылочной переменной, а
о значении того программного объекта, на который указывает эта ссылоч-
ная переменная.
При выполнении оператора процедуры NEW(p) порождается динамическая
переменная типа INTEGER; после выполнен оператор присваивания и динами-
ческой переменной будет присвоено значение равное 37.
Если в программе есть описание
TYPE
mas =^ REAL
VAR
A:ARRAY [1...100] of mas
в силу которого значение переменной А может быть последовательность
значений ссылочного типа, причем каждая из этих ссылок указывает на ве-
щественное значение, то в качестве ссылочной переменной может фигуриро-
вать переменная с индексом, например A[2] или A[k + 5], а соответствую-
щие им переменные с указателем будут выглядеть следующим образом:
A[2]^ и A[k + 5]^ - значениями этих переменных с указателем будут ве-
щественные числа.
Над переменными ссылочного типа нельзя выполнять какие либо опера-
ции которые бы давали результат этого же типа (+, -, /, *, WRITE и т.д)
Над значениями ссылочного типа определены только операция присваивания
и некоторые операции сравнения.
Р: = g
где g - ссылочное выражение, которое задает ссылочное значение то-
го же типа, что и переменная р.
При этом в качестве ссылочного выражения может использоваться:
- пустая ссылка NIL;
- ссылочная переменная.
Недопустимо присваивание вида
VAR
p: CHAR
g: INTEGER
BEGIN
.
.
.
P•:='A'; g•:=7; p:=g; g:=nil.
Т.к. переменная р может ссылаться на значение типа CHAR и перемен-
ная g - на значение типа INTEGER.
Для пояснения результатов присваивания значений ссылочным перемен-
ным и переменным с указателем рассмотрим следующий пример.
VAR
p,g:^ INTEGER
BEGIN
.
.
.
p•:=7; g•:=51; p:=d; d:=nil
После выполнения оператора присваивания p:=d на динамический
объект со значением 7 не указывает ни одна ссылка, т.е. он стал недос-
тупным для программы. В результате выполнения этого же оператора прис-
ваивания не образуется какой-либо новый динамический объект со значени-
ем 51, а переменная р будет ссылаться на тот же уже существующий дина-
мический объект, на который ссылается и переменная d.
Над значениями ссылочного типа в паскале определены две операции
отношения (сравнения): =(равно) и +(не равно).
Пусть, например, имеется описание переменных
p,g:^ CHAR
Тогда после выполнения операторов присваивания р:=NIL; g:=NIL; от-
ношение p=g (равно) истино, а p+g (не равно) ложно.
При использовании оператора NIL разрывается связь между ссылочной
переменной и объектом. Объект стал недоступен программе, хотя и продол-
жает занимать отведенное для него место в памяти.
Если в процессе выполнения программы некоторый динамический
объект становится ненужным, то его можно уничтожить с помощью стан-
дартной процедуры с именем DISPOSE.
В результате выполнения оператора процедуры вида DISPOSE(р) дина-
мический объект, на который указывает ссылочная переменная р, прекраща-
ет свое существование,занимаемое им место в памяти считается свободным,
а значение переменной р становится неопределенным.
По процедуре DISPOSE уничтожается только сам динамический объект,
но не указатель на него.
VAR
p,g:^ INTEGER;
.
.
.
NEW (p); NEW (g);
p•=7; g•=37;
DISPOSE (p);
p:=d;
g:=NIL
Теперь объект со значением 7 будет уничтожен, а ссылочной перемен-
ной р присваивается адрес объекта со значением 37 и ссылочная перемен-
ная g никуда не будет указываться.
Линейные списки в Паскале.
Линейные списки являются простейшей формой организации
данных с рекурсивной структурой. Эта форма применяется чаще
всего тогда, когда надо обработать некоторую совокупность
данных, количество элементов которых заранее не определено,
а взаимный порядок следования играет важную либо решающую
роль. Примером такой ситуации может служить каталог книг в
библиотеке. Списки могут также использоваться как промежу-
точная структура данных при решении таких задач, как сор-
тировка и поиск.
В Паскале линейные связные списки реализуются путём ис-
пользования механизна управления памятью с помощью процедур
NEW и DISPOSE.
Переменные, из которых затем будет строиться связный
спикок, обычно представляют собой записи, в состав которых
входит 2 группы элементов: переменные-указатели на следующий
и (или) предыдущий элемент списка и переменные, составляющие
значение (содержание) данного элемента списка.
Пример описания типа динамической переменной для после-
дующего использования в качестве элемента линейного списка:
type pointer=^obj;
obj=record
link: pointer;
value: integer
end;
Для дальнейших иллюстраций будут использованы следующие
переменные:
var head,item,result: pointer;
schim: integer;
Здесь head - первый (головной) элемент списка, item - теку-
щий элемент из числа следующих за элементом head, result -
некий произвольный элемент списка, schim - допустимое значе-
ние элемента списка.
По отношению к динамическим линейным спискам могут про-
изводиться следующие операции:
1. Инициализация динамического списка:
begin
head:=NIL;
2. Включение элемента в конец списка:
procedure ADDITM(i: integer);
begin
new(item);
write('Элемент ',i,': ');
readln(item^.value);
item^.link:=head;
head:=item
end;
3. Поиск и предоставление адреса элемента списка:
function FIND: pointer;
begin
write('Введите значение для поиска ');
readln(schim);
item:=head;
FIND:=NIL;
while item<>NIL do
if item^.value=schim
then
begin
FIND:=item;
item:=NIL
end
else item:=item^.link
end;
4. Включение элемента в список элементов с монотонно-возра-
стающими значениями:
procedure INSITM;
var temp,target: pointer;
begin
new(item);
write('Значение для вставки в порядке возрастания: ');
readln(item^.value);
item^.link:=head;
target:=head;
temp:=NIL;
while target<>item^.link do
if item^.value>target^.value
then
begin
temp:=target;
target:=target^.link
end
else item^.link:=target;
if temp=NIL
then head:=item
else target^.link:=item
end;
5. Удаление элемента списка с заданным адресом (например,
найденным функцией FIND):
procedure DELITM(addr: pointer);
var temp: pointer;
begin
item:=head;
temp:=NIL;
while item<>addr do
begin
temp:=item;
item:=item^.link
end;
if temp=NIL
then head:=addr^.link
else temp^.link:=addr^.link;
dispose(addr)
end;
6. Вывод всех элементов списка:
procedure PRITM;
begin
writeln('Список:');
item:=head;
while item<>NIL do
begin
writeln(item^.value);
item:=item^.link
end
end;
Кроме обычных (однонаправленных) списков могут также применяться списки с обратным направлением связи (ссылка те-
кущего элемента указывает не на последующий, а на предыдущий элемент списка) и двунаправленные списки (в которых сущест-
вуют одновременно оба вышеуказанных типа ссылок). На основе таких списков могут быть построены кольцевые списки.
В зависимости от порядка включения новых и удаления существующих элементов списка они могут подразделяются на оче-
реди (FIFO - first in, first out - первым вошёл, первым вышел) и стеки (LIFO - last in, first out - последним вошёл, первым вышел).
Дальнейшим развитием идеи связанных списков являются списки с произвольными связями между их элементами - графы,
важным частным случаем которых являются двоичные деревья.
__
program LISTEST;
type pointer=^obj;
obj=record
link: pointer;
value: integer
end;
var head,item,result: pointer;
schim,i: integer;
procedure ADDITM(i: integer);
begin
new(item);
write('Элемент ',i,': ');
readln(item^.value);
item^.link:=head;
head:=item
end;
function FIND: pointer;
begin
write('Введите значение для поиска ');
readln(schim);
item:=head;
FIND:=NIL;
while item<>NIL do
if item^.value=schim
then
begin
FIND:=item;
item:=NIL
end
else item:=item^.link
end;
procedure INSITM;
var temp,target: pointer;
begin
new(item);
write('Введите значение для вставки в порядке возрастания: ');
readln(item^.value);
item^.link:=head;
target:=head;
temp:=NIL;
while target<>item^.link do
if item^.value>target^.value
then
begin
temp:=target;
target:=target^.link
end
else item^.link:=target;
if temp=NIL
then head:=item
else target^.link:=item
end;
procedure DELITM(addr: pointer);
var temp: pointer;
begin
item:=head;
temp:=NIL;
while item<>addr do
begin
temp:=item;
item:=item^.link
end;
if temp=NIL
then head:=addr^.link
else temp^.link:=addr^.link;
dispose(addr)
end;
procedure PRITM;
begin
writeln('Список:');
item:=head;
while item<>NIL do
begin
writeln(item^.value);
item:=item^.link
end
end;
begin
head:=NIL;
writeln('Введите 7 целых чисел списка:');
for i:=1 to 7 do ADDITM(i);
PRITM;
result:=FIND;
write('Элемент <',schim,'> ');
if result=NIL
then writeln('в списке не найден')
else
begin
writeln('удаляется из списка');
DELITM(result);
PRITM
end;
INSITM;
PRITM
end.
______________________________________
Деревья.
Двоичное дерево -это такой способ предтавления информации прикотором одинаково
эффективно реализуются все три операции: поиска, записи и удаления информации.
Эта эффективность близка к эффективности дихотомического поиска.
Двоичное дерево схематически можно представить следующим образом:имеется набор
вершин , соединенных стрелками.Из каждой вершины выходит не более двух стрелок
(ветвей) , направленных влево-вниз или вправо-вниз.Должна существовать единст-
венная вершина,в которую не входит не одна стрелка-эта вершина называется кор-
нем дерева.В каждую из оставшихся в точности входит одна стрелка:
*
/ \
/ \
* *
/ \ \
* * *
Пpи пpедставлении таблицы в виде дв.деpева будем считать , что тексты записей
хpанятся отдельно.Тогда каждое звено, соответствующее элементу таблицы , будет
записью,содеpжащей четыpе поля:-------¬
¦ ключ ¦
+------+
¦адpес1¦
+------+
¦адpеc2¦
+------+
¦адpес3¦
L-------
Адpес1-ссылка на веpшину влево-вниз.Адpес2-ссылка на вершину вправо-вниз.
Адрес3-ссылка на информациионное поле.
ПРИМЕР:Составить процедуру образования двоичного дерева.
program instree;{ writing by Ratoshnuk S.A.(РВ-91-4)}
{---------------------------- описание типов ------------------------------}
type text=string[125];{описание типа информационной части записи}
ykt=^text;
ykz=^z;
z=record { описание звена дерева}
k:integer;{ключ}
l,r:ykz;{ссылки на левую и правую ветви}
c:ykt{ccылка на текст}
end;
{-------------------------- описание переменных ---------------------------}
var d{дерево},s{звено},p,q:ykz;t{ссылка на текст}:ykt;key{ключ},i:integer;
rec{текст(информационная часть}:text;
{---------------- процедура образования нового звена дерева----------------}
procedure zx(var s:ykz);
var rec:text;t:ykt;key:integer;
begin
write('Введите любой текст до 125 символов и целое значение ключа');
read ( rec,key);
new(t);t^:=rec;
new(s);s^.k:=key;
s^.c:=t;s^.l:=nil;s^.r:=nil
end;
{------------------------ программа создания дерева------------------------}
begin
zx(s);
d:=s;
for i:=1 to 7 do
begin
zx(s);p:=d;
repeat
q:=p;
if p^.k>key then p:=p^.l else p:=p^.r;
until p=nil;
if key<q^.k then q^.l:=s else q^.r:=s
end
end.
_
ОПЕРАТОРЫ ВВОДА - ВЫВОДА В ЯЗЫКЕ ПАСКАЛЬ
Для ввода данных в языке ПАСКАЛЬ предусмотрены стандартные процедуры READ и
READLN. Разлличают три вида операторов ввода:
а) READ(a1,a2,...,aN)-каждое вводимое значение поллучают послледовательно
переменные a1,a2,...,aN
б) READLN(A1,A2,...,An)-переменным A1,A2,...,An присвиваются последователь-
льно вводимые значения, после чего следующий оператор ввода вводит данные
с новой строки.
в) READLN-переход на новую строку при вводе.
В языке ПАСКАЛЬ допускается вводить целые,действительные и символьные данные.
Логические данные вводить не разрешается.
ВВОД ЧИСЛОВЫХ ДАННЫХ
Числовые данные, целые и действительные, должны разделятся пробелом или
клавишей ENTER. Пробелы и ENTER перед числом игнорируются.
Пример ввода:
var a,b,c:real;
k,t:integer;
............
read(a,b,c);
readln;
read(k,t);
При выполнении программы происходит останов программы привстрече
READ(A,B,C), на клавиатуре необходимо набрать три действительных числа,
после чего с новой строки два целых числа соответственно оператору
READ(K,T),например:
0.5 6.23 -7.1 [enter]
3 48 [enter]
ВВОД СИМВОЛЬНЫХ ДАННЫХ
Ввод символьных данных имеет свои особенности. Поскольку пробел относится
к символьным данным то символьные данныевводятся сплошной строкой. Одной
переменной можно присвоить значение только одного символа.
Пример ввода:
var a,b,c:char;
...........
read(a,b,c);
Если при вводе ввести данные -- SNR [enter] -- получим:A='S',B='N',C='R'
При вводе данныхв виде: -- S N R [enter] -- получим:A='S',B=' ',C='N'
ОПЕРАТОР ВВОДА ДЛЯ ЧТЕНИЯ ФАЙЛА
Оператор ввода для чтения файла обладает всеми свойствамии обычного опера-
тора READ. Вкачестве параметров могут быть переменные; каждая переменная по-
учает значение одного эемента считанного из внешнего файа.
Процедура READ(F1,X) применяется для считывания (по одному) данных из
внешнего файла в переменную X.
ОПЕРАТОР ВЫВОДА.
Опеатор вывода данных из памяти ЭВМ на экран дисплея имеет три формы:
1) WRITE(b1,b2,...bn)-выводит последовательно значения b1,b2,...,bn;
2) WRITELN(b1,b2,...,bn)-выводит последовательно значения b1,b2,...,bn и
осуществляет переход на новую строку;
3) WRITELN-осуществляет переход на новую строку при выводе данных.
В качестве параметров b1,b2,...,bn могут быть целые,действительные,символь-
ные и логические переменные, а так же символьные константы.
Допускается вывод данных с форматами и без них. Форма представления выводи-
мых данных зависит от типа данных: значения целых переменных выводятся как
целые числа ,значения действительных переменных-в виде мантиссы и десятично-
го порядка, значения символьных переменных- в виде отдельных символов,значе-
ния логических переменных- в виде TRUE или FALSE.
Для выводимых значений переменных отводятся следующие поля: 13-для целого
числа,13-для действительного,1-для символа,6-для логических данных.Если
целое число занимает позиций меньше,чем 13, то соответствующее поле перед
числом заполняется пробелами.Если отсутствует формат для действительного
числа,оно выводится в форме с плавающей точкой.Например число Z=10.9 при
выводе в виде WRITE(`Z=`,Z) на экране будет представлено
Z= 1.090000E+01
Символьная константа(строка)выводится явно в том виде ,как она записана но
без апострофов.
Для наглядности выводимых значений прредусмотрены форматы.Они указываются
за переменной в операторе WRITE через двоеточие.Для действительных перемен-
ных формат имеет вид:
a:m:n
где а-переменная,m-общее поле выводимого числа(включая знак числа,целую
часть числа,точку и дробную часть);n-поле дробной части.
В качестве m и n могут быть как целые переменные,выражения,так и целые
константы.Например:
WRITE( SK:M:N,FGH:7:2 );
Если формат указан больше,чем необходимо позиций для изображения числа, то
перед целой частью числа представлены избыточные пробелы,а после дробной
части-нули.
Для других типов данных формат имеет вид: a:m Например:
WRITE(K:5,C:4);
Для вывода нескольких пробелов символ пробела указывается с форматом ,
Например: ` `:7
Для пpопуска пустых позиций пеpед выводимыми данными или между ними можно
использовать фоpмат для символа пpобела,напpимеp
WRITE(` `:5,A:3,` `:7,B:4)
МОДУЛИ
Наличие модулей в Turbo Pascal позволяет программировать и отлаживать программу по частям , создавать библиотеки подпрограмм и данных, воспользоваться возможностями стандартных модулей , неограниченно увеличивать кодовую часть программы.
Модуль состоит из следующих частей:
а) заголовок модуля
б) интерфейс модуля
в) исполнительная часть модуля
г) секция инициализации
Все разделы модуля ,за исключением секции инициализации,являются обязательными . Обязательна также указанная последовательность рапзделов.