Комментарии
Комментарий – это произвольная последовательность любых символов, поясняющая текст программы. Комментарий разрешается вставлять в любое место программы, где по смыслу может стоять пробел. В качестве ограничителей комментария используются фигурные скобки « { » и« } », а также пары символов: « (* » - слева от комментария и « *) » - справа от него:
{ Это комментарий }
(* Это тоже комментарий *)
Оператор присваивания
Под операторами в языке Паскаль подразумевают описание действий. Операторы отделяются друг от друга точкой с запятой. Если оператор стоит перед end, until или else, то в этом случае точка с запятой не ставятся.
Общий вид оператора присваивания:
v:=a;
здесь v – переменная, а – выражение, := - операция присваивания. Выражение а может содержать константы, переменные, названия функций, знаки операций и скобки. В операторе v:=a переменная v и выражение а должны иметь один и тот тип.
Примеры.
f:=3*c+2*sin(x);
х:=х+1;
Замечание. Разрешается присваивать переменной типа real выражение типа integer. Но нельзя присваивать переменной типа integer выражение типа real.
Процедура ввода информации
Общий вид:
Read (v1, v2, …,vn);
или
Readln (v1, v2, …,vn);
здесь v1, v2, …,vn – идентификаторы переменных.
Значения переменных вводятся с клавиатуры и должны соответствовать типам переменных. В случае использования процедуры readln, после ввода происходит переход на следующую строку.
Процедура вывода информации на печать
Общий вид оператора:
write(p1, p2, …, pn);
или
writeln(p1, p2, …, pn);
Здесь p1, p2, …, pn - список выражений, значения которых выводятся на печать.
Оператор write оставляет курсор в конце выведенной строки текста.
В случае использования процедуры writeln, после печати происходит переход на следующую строку.
Кроме значений выражений, на печать можно выводить и произвольный набор символов, заключенный в апострофы, например
writeln(’p=’,p);
Этот оператор выполняется так: сначала выводятся символы, заключенные в апострофы. Затем выводится значение переменной р, например 13.5. На экране в результате работы оператора появится:
р=13.5
Пример 1. Вычислить длину окружности радиуса 5,785.
program t10;
(* Программа вычисления длины окружности*)
const r=5.785;
var l:real;
begin
l:=2*3.1416*r;
writeln(' l=',l);
end.
либо
program t11;
var r:real;
begin
readln(r);
writeln(' l=',2*3.1416*r);
end.
Имеется возможность задать ширину поля (число позиций) М для выводимой величины Р:
Write (P1:M1, P2:M2, …PN:MN);
Для вещественных чисел можно задавать поля М и N, где М – общее число позиций, отводимых под все число, N –число позиций под его дробную часть.
Например,
Write (P:10:2);
Здесь под Р отводится 10 позиций, 2 из них под дробную часть.
Пример 2. Назначение следующей программы - ввести с клавиатуры два целых числа, найти результат деления первого числа на второе и вывести числа и полученный результат на экран в виде таблицы.
Program Input_Output;
{Программа вводит два целых числа
и выводит частное от деления 1-го на 2-е}
Var
n1,n2:Integer; {n1 и n2 - вводимые целые}
x:real; {x - результат}
Begin
Write('n1='); {Сообщение о вводе n1}
ReadLn(n1); {Ввод n1}
Write('n2='); {Сообщение о вводе n2}
ReadLn(n2); {Ввод n2}
Х:=n1/n2; {Вычисление результата}
WriteLn('---------------------------'); {Печать таблицы}
WriteLn('| n1 | n2 | Частное |');
WriteLn('---------------------------');
WriteLn(n1:8,n2:8,x:8:4);{Вывод n1, n2 и x}
WriteLn('-------------------------');
End.
Переменные типа массив. Назначение, описание и доступ к элементам массива. Примеры.
Структурированные типы
Структура — расположение, порядок, совокупность устойчивых связей объекта, обеспечивающих его целостность и тождественность самому себе, т.е. сохранение основных свойств при различных внешних и внутренних изменениях.
Общие понятия.
Рассмотрим следующую задачу: ввести с клавиатуры 20 действительных чисел и вычислить их сумму, при этом каждое из чисел сохранить в памяти для последующей обработки. Мы будем вынуждены ввести 20 имен переменных, что, естественно очень неудобно.
Паскаль позволяет работать с более сложными по своей конструкции типами. Они называются типами данных пользователя и относятся к структурированным типам (от слова структура). Отличаются они тем, что переменные структурного типа состоят не из одного элемента (как все стандартные типы — целые, вещественные, символьные и логические), а из нескольких элементов.
К структурированным типам относятся массивы, записи, множества и файлы.
Массивы.
МАССИВ — а) область машинной памяти, в которой могут размещаться совокупности значений одного и того же типа
б) набор переменных, объединенных общим назначением и имеющих одно имя.
Элемент массива— отдельная переменная, входящая в массив.
Размерность массива— количество элементов, которое содержит массив.
Индекс — числовой или буквенный указатель, которым снабжаются математические выражения для того, чтобы отличать их друг от друга.
Индекс элемента массива — номер элемента в массиве.
Особенность массивов заключается в том, что все элементы массива являются данными одного типа (возможно и структурированного).
При назначении массиву имени соблюдаются те же требования, какие предъявляются к именам переменных простых типов.
Доступ к элементам массива.
Массив можно условно изобразить в виде прямоугольника с n делениями, каждое деление — это элемент массива, он имеет свой номер (индекс). Индекс записывается рядом с именем массива в квадратных скобках.
Пример А[1] — первый элемент массива; А[5] - пятый элемент массива; А[1] — 1-тый элемент массива, в последнем примере мы указали в качестве индекса переменную 1. Каждая переменная в Паскале должна быть объявлена, следовательно, и переменная, указывающая индекс (индексная переменная) тоже.
Прежде чем приступить к описанию типа, назначим имена — имя типа массив и имя переменной, которая относится к типу массив. В описании типа мы должны указать, что объявляется тип массив для этого используется служебное слово аrrау, указать границы изменения индексов. У нас 20 элементов, следовательно, индекс изменяется от 1 до 20. Синтаксически это записывается следующим образом 1..20, называется такая запись —диапазон.
Все вышесказанное записывается в программе на языке Паскаль следующим образом:
A :array [1..20] of integer
Необходимо помнить, что значением переменной а является весь массив.
Потребность использовать массив возникает всякий раз, когда при решении задачи приходится иметь дело с большим, но конечным количеством однотипных данных, которые необходимо хранить в памяти.
Предположим, что мы наблюдали температуру воздуха в течение некоторого периода времени (например, месяца). Закончив наблюдения, приступаем к обработке полученных данных: поиску самого холодного или самого теплого дня, вычислению среднемесячной температуры и т.д.
Создание (описание) массивов |
Итак, мы решили создать и использовать в своей программе массив из чисел. Для примера возьмем ту программу, которую я придумал в описании понятия массива: найти среднее арифметическое среди 100 чисел.
Массив - это переменная и как все переменные описывается в разделе var программы. Описание переменной - массива состоит из:
Имени переменной;
Служебного слова Array, означающего "массив";
Описания размера массива (в нашем случае 100 чисел). Диапазон записывается в квадратных скобках - [ и ]. Внутри пишется сам диапазон, в виде двух чисел, разделенных двоeточием: начало..конец;
Задании типа для элементов массива (в нашем случае - целые числа, или Integer). Задание типа начинается со служебного слова of;
Вот пример описания массива на 100 чисел:
var
Mas: Array [1..100] of Integer;
Выпишите этот пример на бумагу. Он вам понадобиться в дальнейшем, так как с первого раза не все его запоминают.
Теперь в программе можно обратиться к любому элементу этого массива - от 1 до 100. Делается это посредством указания имени переменной с номером элемента в квадратных скобках. Вот примеры:
begin
Mas[1] := 100;
Readln(Mas[2]);
Write(Mas[4);
if Mas[100] < 18 then Halt;
Mas[50] := Mas[49] + Mas[1];
end.
Думаю, из примера видно, что с отдельным элементом массива можно делать все, что с любой переменной.
Ну а теперь давайте всеже напишем нашу программу.
Program N1; var M: Array [1..100] of Integer; A: Real; I: Byte; begin Randomize; For I := 1 to 100 do M[I] := Random(500); For I := 1 to 100 do A := A + M[I]; A := A / 100; Write('Среднее арифметическое всех чисел массива: ', A); end. |
Вот такая программа. Здесь я использую новую функцию Random , думаю, она вам не знакома. Очень интересная функция.
Функция Random(A: Integer);.
Данная функция возвращает от своей работы случайное число. Что значит "случайное число"? Это значит, что функция возвращает от своей работы какое-то число, каждый раз новое. В качестве параметра задается максимальное значение случайного числа, иначе говоря функция не возвратит число большего диапазона. Для того, чтобы использовать эту функцию, необходимо включить (так говорят, однако мне нравиться больше "инициализировать" - на включение это мало похоже) датчик случайных чисел. Тогда функция начнет нормально работать и возвращать действительно случайные значения.
Инициализация датчика случайных чисел (ДСЧ) происходит вызовом процедуры Randomize. Вы видите ее перед циклом.
Теперь посмотрите, как я использую эту функцию в программе. Дело в том, что вводить с клавиатуры 100 чисел не так уж и приятно, верно? Вот я и заполняю массив случайными числами. Диапазон до 500 вполне здесь подходит, числа будут не очень большие, но и не очень маленькие. При этом я циклом изменяю значение массива и с помощью переменной I пробегаюсь по всем его элементам, заполняя их случайными числами.
Этот пример хорошо демонстрирует создание массива и доступ к его элементам.
Ну а теперь давайте напишем еще одну программу, демонстрирующую работу с массивом. На сей раз мы уже коснемся одного из множества алгоритмов по обработке массивов, а именно алгоритма поиска максимального числа.
Итак, давайте заведем массив. Вводить его будем с клавиатуры, поэтому давайте не будем делать его слишком большим, а ограничимся, скажем, десятью элементами. После этого мы составим алгоритм, находящий максимальное число среди введенных чисел и выведем его на экран.
Текст программы:
Program N2; var M: Array [1..10] of Integer; Max: Integer; I: Byte; begin Writeln('Введите 10 чисел: '); For I := 1 to 10 do begin Write('N',i,': '); Readln(M[i]); end; Max := M[1]; For I := 1 to 10 do if Max < M[i] then Max := M[i]; Write('Максимальное число: ', Max); Readln; end. |
Алгоритм работы этой программы очень и очень прост. Среди введенных чисел мы находим максимальное следующим образом:
Сначала за максимальное принимается первое число;
После оно сравнивается со всеми оставшимися числами, при этом:
Если следующий элемент больше принятого за максимум (переменная Max), то оно принимается за максимум.
После сравнения всех элементов в конце концов остается одно число, которое больше всех в массиве.
Надеюсь, это не сложно. Если вы не поняли работы этого алгоритма, то задумайтесь получше, перепишите программу и поэкспериментируйте. В дальнейшем таких алгоритмов будет множество. В большинстве своем они простые, но есть и довольно (и даже очень!) сложные. Без понимания таких простеньких на первых порах алгоритмов невозможно усвоить серьезные.
Паскаль. Двухмерные массивы. |
Сегодня я продолжаю тему массивов. Останавливаться пока, я считаю рано - во-первых, массивы как таковые очень часто используются в программировании, во-вторых, мы еще не прошли все возможности, связанные с массивами.
Одна из такие возможностей - пожалуй, самая главная, это создание многомерных массивов. Многомерность означает, что массив содержит не только элементы, упорядоченные один за другим в строку:
1 |
2 |
3 |
4 |
5 |
, но и дополнительные элементы - например, помимо строк массив имеет и столбцы:
1 |
2 |
3 |
4 |
5 |
2 |
4 |
6 |
8 |
10 |
3 |
6 |
9 |
12 |
15 |
4 |
8 |
12 |
16 |
18 |
5 |
10 |
15 |
20 |
25 |
Чаще всего среди многомерных массивов используются двухмерные массивы, пример которого вы и можете видеть выше. Двухмерный - значит измеряющийся двумя индексами. Здесь первым индеском служит строка, сторым - столбец.
Как описываются такие массивы и где применяются я покажу немножко ниже, а пока давайте разберем, как поисходит эта самая индексация по номерам строк и символов в них (столбцов).
К примеру, имеем вышеописанный массив - таблица Пифагора то 1го до 5ти. Как мы можем обратиться к элементу, который находится в строке 5, столбце 3 (число 15)? Вот и всплывает упомянутое выше измерение двумя индеками. Мы так и поступим: в качестве первого индекса укажем номер строки, в качестве второго - столбец. Смотрите, что получиться:
Mas[5,3];
Думаю, вы поняли как происходит обращение к элементам такого массива. Более конкретные примеры использования см. ниже. А теперь давайте разберемся, как же такие массивы создаются в программе.
Создание 2х мерных массивов |
Создать такой массив не сложнее, чем одномерный. Вот пример:
var
Mas: Array[1..5, 1..5] of Integer;
Здесь создается двухмерный массив, размером в 5 строк и 5 столбцов. Сначала указывается количество строк, после - через запятую - количество столбцов. Вот еще один пример создания массива:
var
Mas: Array[1..50, 1..25] of Integer;
А теперь давайте посмотрим, как же эти массивы можно использовать. Для начала напишем маленькую программу, которая будет создавать массив и записывать в него таблицу умножения, после чего распечатывать ее на экран. Вот сама программа:
Program N1;uses Crt;var Mas: Array[1..10, 1..10] of Integer; I, J: Byte;Begin ClrScr; For I := 1 to 10 do For J := 1 to 10 do Mas[I, J] := I * J; For I := 1 to 10 do Begin For J := 1 to 10 do If Mas[I, J] < 10 then Write(Mas[I, J], ' ') else Write(Mas[I, J], ' '); Writeln; end; Readln;end. |
Запустите эту программу. Видите, массив распечатыват таблицу умножения, причем наглядно видна сама структура массива. Сразу бросается в глаза, что это 2х мерный массив, не так ли?
При выполнении этой программы я использую очень простой алгоритм для заполнения массива таблицей умножения. Вы должны помнить его по прошлым выпускам, когда мы просто ее печатали.
Также заметьте, я использую изученый модуль CRT - и его процедуру ClrScr. Учитесь использовать модули, это очень важно.
Двигаемся дальше. Я считаю, что это тема не должна вызывать затруднений, так как с массивами вы уже знакомы, а 2х мерные - это всего лишь интерпритация.
Итак, давайте теперь напишем программу, которая будет интенсивно использовать массивы. На этот раз это будет пример реализации "бегущих огней", которая пока использует одномерный массив, но тем не менее показывает новый алгоритм по его обработке. а именно сдвиг элементов по массиву.
Бегущие огни:
uses crt; const n=80; Var A:array[1..n] of byte; i,r:byte; c:char;Begin clrscr; write(' Esc -> Exit'); for i:=1 to n do a[i]:=random(2); repeat for i:=1 to n do begin gotoxy(i,4); if a[i]=0 then write('*') else write('-'); gotoxy(81-i,8); if a[i]=0 then write('*') else write('-'); end; r:=a[1]; for i:=1 to n-1 do a[i]:=a[i+1]; a[n]:=r; c:=readkey; until c=#27;end. |
Запустите эту программу. Теперь нажмите любую клавишу. Видите, происходит сдвиг огней? Разноцветные огни реализованы двумя символами " * " и " - ".
Как же Огонек бежит по кругу? Если цепочку лампочек представить массивом чисел (1010010) то 1 шаг огней, есть сдвиг элементов массива на 1 (0100101) то есть:
a[1]:=a[2];
a[2]:=a[3]; и т.д.
a[n]:= {то что было в a[1], надо запомнить! }
Итак сдвиг всех элементов массива на 1 шаг влево это:
R:=a[1];
for i:=1 to N -1 do a[i]:=a[i+1];
a[n]:=R;
Алфавит языка Паскаль. Идентификаторы.
Алфавит и словарь языка программирования Паскаль. Программа формируется из предложений, состоящих из лексем и разделителей, которые в свою очередь формируются из конечного набора литер, образующих алфавит языка Pascal. Этот язык состоит из букв латинского алфавита (прописных – А, В, С, D ... X, Y, Z, строчных – а, b, с ... x, у, z), арабских цифр (0, 1, 2, 3,4, 5, 6, 7,8,9) и специальных символов.
Использование строчных букв эквивалентно построению соответствующих конструкций из прописных букв и применяется для стилистического оформления программы. Иными словами, регистр при написании программ роли не играет. Разделителями являются:
пробел,
конец строки,
; – точка с запятой (конец предложения)
комментарий, представляющий собой текст, ограниченный слева и справа фигурными скобками.
Лексемы включают: зарезервированные слова, идентификаторы (стандартные и пользовательские), специальные символы (простые и составные), метки.
Зарезервированные слова представляют собой составную часть языка, имеют фиксированное начертание и определенный смысл (например, зарезервированное слово VAR открывает раздел описания переменных).
Стандартные идентификаторы служат для определения заранее зарезервированных идентификаторов предопределенных типов данных, констант, функций и процедур (например, стандартная функция ABS возвращает модуль своего аргумента).
Идентификаторы пользователя применяются для обозначения констант, переменных, процедур и функций. Пользователь должен выбирать имя идентификатора отличное от зарезервированных слов и стандартных идентификаторов.
Правила составления идентификаторов.
Идентификатор начинается с буквы, или знака подчеркивания.
Содержит только буквы, цифры или знак подчеркивания.
Между двумя идентификаторами должен стоять разделитель.
Максимальная длина 127 символов. Все символы значимы.
Идентификатор не может повторять зарезервированное слово.
Если идентификатор пользователя повторяет стандартный, то действие стандартного идентификатора – отменяется.
Примеры пользовательских идентификаторов: x, s, s23, asd_sd45.
Специальные символы:
Простые: «+», «-», «*», «/», «=», «>», «
Составные: «:=», «», «..», «=».
Метки используются для идентификации операторов в программе при переходе по оператору GOTO. Правила написания меток отличаются от правил составления идентификаторов, следующим – на первом месте может стоять цифра.
Чтобы программа решения задачи обладала свойством массовости, следует вместо конкретных значений величин использовать их обозначения, чтобы иметь возможность изменять их значения по ходу выполнения программы. Для обозначения переменных и постоянных величин, различных процедур, функций, объектов используются имена – идентификаторы, устанавливающие соответствие между объектом и некоторым набором символов.
Для обозначения заранее определенных разработчиками языка типов данных, констант, процедур и функций служат стандартные идентификаторы, например: integer, Sin, Cos, Ln, Sqr, Sqrt, Read, Readln, Write, Writeln. В этом примере стандартный идентификатор Sin вызывает функцию, вычисляющую синус заданного угла, Read, Readln вызывают процедуру, организующую ввод данных, Write, Writeln вызывают процедуру, организующую вывод данных. Любой из стандартных идентификаторов, в отличие от зарезервированных слов, можно переопределить, но это чаще всего приводит к ошибкам. Поэтому на практике стандартные идентификаторы лучше использовать без каких-либо изменений.
Для обозначения меток, констант, переменных, процедур и функций, определенных самим программистом, применяются пользовательские идентификаторы. При этом идентификаторы в программе должны быть уникальными, т. е. в каждом блоке программы один идентификатор не может использоваться для обозначения более чем одной переменной или постоянной величины, и т. д.
Компилятор Turbo Pascal строго следит за этим, и если это требование не соблюдается, то компиляция прерывается, а на экран выводится сообщение об ошибке «Error 4: Duplicate identifier» и указывается дублирующийся идентификатор.
В идентификатор не могут входить пробелы и специальные символы. Обратите внимание, что буквы русского алфавита не могут входить в идентификатор Turbo Pascal.
При написании программ следует соблюдать общие правила написания идентификаторов:
1. Идентификатор может начинаться только с буквы или знака подчеркивания (исключение составляют метки, которые могут начинаться также и с цифры);
2. Идентификатор может состоять из букв, цифр и знаков подчеркивания (пробелы, точки и другие специальные символы недопустимы);
3. Между двумя идентификаторами должен быть по крайней мере один пробел;
4. Максимальная длина идентификатора составляет 127 символов, но значимыми являются только первые 63 символа;
5. При записи идентификаторов можно использовать как прописные, так и строчные буквы. Компилятор не делает различий между ними, хотя они и имеют различные ASCII-коды. На практике рекомендуется применять эту особенность для более простого чтения и понимания значений идентификаторов. Так, вместо идентификатора nomerotdela лучше написать NomerOtdela, выделив прописными буквами каждую из двух смысловых частей.
Правильно выбранные идентификаторы значительно облегчают чтение и понимание программы, а также уменьшают вероятность появления ошибок при модификации программ. Например, значение даты удобнее обозначить идентификатором Data, чем просто буквой D или любым другим символом.
Примеры:
Metkal2
2graph – ошибка, идентификатор начинается с цифры
Block_56
Nomer.Doma – ошибка, идентификатор содержит точку
Сумма – ошибка, идентификатор содержит буквы русского алфавита.
Типовые алгоритмы обработки массивов. Заполнение массивов данными, вывод массивов на экран.
Для этого мы должны составить алгоритм и программу осуществляющие обработку данных.
Основные алгоритмы для работы с одномерными массивами
Одномерным массивом будем называть массив, в котором для указания местоположения элемента достаточно одного индекса.
В разделе описания переменных мы объявили тип массив, а затем отнесли переменную к данному типу. В памяти ЭВМ будет отведено место для размещения элементов массива. Следует особо отметить, что размерность (количество элементов) массива определяется при объявлении типа и изменить количество элементов в процессе работы программы нельзя. Можно пользоваться меньшим количеством элементов.
Наша задача заполнить массив, т.е. каждому элементу дать свое значение, а затем уже обрабатывать по заданному алгоритму. Есть несколько основных алгоритмов, которые необходимо знать. Любую задачу по обработке одномерных массивов можно решить, используя эти основные алгоритмы (такие алгоритмы мы уже называли базовыми).
Перечислим базовые алгоритмы:
1. заполнение одномерного массива значениями;
2. вывод на экран значений элементов одномерного массива;
3. нахождение суммы элементов одномерного массива;
4. подсчет количества элементов, удовлетворяющих заданному условию;
5. поиск максимального (минимального) элемента одномерного массива и его номера.
При этом надо помнить, что массивы нужны тогда, когда для решения задачи необходимо хранение последовательности значений.
Заполнение.
Заполнить элементы одномерного массива значениями мы можем:
• вводя значения с клавиатуры;
• случайным образом;
• по формуле.
Надо помнить, что во всех трех случаях нам не обойтись без организации цикла.
Поиск максимального (минимального) элемента массива.
Пусть мы имеем одномерный массив:
20,-2, 4, 10,7, 21,-12, 0, 4, 17.
Подумаем, какие операции нужно выполнить, если требуется найти максимальный элемент. Естественно, операцию сравнения Мы не задумываемся над тем, что сравниваем всегда пару, "пробегая" глазами все элементы массива. Алгоритм поиска максимального (минимального) элемента мы построим таким образом чтобы сравнивать пару чисел, повторяя действие сравнения нужное количество раз.
Итак, нам необходимо ответить на два вопроса:
1) какие числа входят в пару, составляющую операцию отношения;
2) сколько раз необходимо повторить операцию сравнения. Введем дополнительную переменную с именем mах. Она и будет одним из чисел, второе число — это очередной элемент массива. Для того, чтобы провести первую операцию сравнения необходимо переменной mах присвоить некоторое начальное значение. Здесь могут быть два варианта:
1) присвоить переменной mах первый элемент массива;
2) присвоить число заведомо меньшее всех элементов массива.
Массив содержит сведения о количестве студентов каждой группы I курса. Определить группу с максимальным количеством студентов, считая, что номер группы соответствует порядковому номеру числа в массиве (считаем, что такая группа единственная).
Другими словами, мы должны найти максимальный элемент и его номер.
program max_num;
type mas=array[ 1.. 10] of byte;
var a: mas;
num, i: byte;
max: byte;
begin
{блок заполнения}
for i:=l to 7 do
readln(a[i]);
{поиск максимального и его номера}
max:==0;
{вводим самое маленькое число для данного массива}
for i:=l to n do
if a[i]>max then begin
num:=i;
max:=a[i]
end;
writeln('максимальное число студентов=',mах);
writeln('номер группы=',num);
end.
3) Найти минимальный элемент среди четных элементов массива.
Пояснение: мы не можем переменной min присвоить первый элемент массива, т.к. он может быть нечетным. Следовательно мы должны выбрать какое-то очень большое число для данного типа данных.
Если мы объявим элементы массива integer, то таким числом будет +32767.
program min_even;
var
a:array [1..10] of integer;
i: integer;
min:integer;
begin
for i:=l to 10 do beein
writeln('введите очередной элемент массива ');
readln(a[i]) ;
end;
min:=32767;
for i:=l to 10 do
if (a[i]<min) and (a[i] mod 2=0) then min:=a[i];
if min=32767 then writeln ('в массиве нет четных элементов') else writein ('минимальный элемент среди четных элементов массива=',min)
end.
Обратите внимание: необходимо проверить, изменилось ли значение переменной min, т.к. четных элементов могло и не быть.
Двумерные массивы
В предыдущих параграфах мы рассматривали массивы, каждый элемент которых содержал только один индекс. Такие массивы мы называли одномерными. В математике часто используют многомерные массивы, т.е. массивы массивов. Особенно широкое распространение получили двумерные массивы. Такие массивы условно можно изобразить в виде таблицы. С информацией, представленной в виде таблицы, мы очень часто встречаемся в различных областях знаний — экономике, статистике, математике физике, химии и т.д.
Каждый элемент таблицы имеет два индекса, значения которых позволяют указать местоположение элемента (его координаты).
В математике квадратные и прямоугольные таблицы часто называют матрицами.
Первый индекс — это номер строки, который изменяется только с переходом на следующую строку; второй индекс _ номер столбца. При решении экономических, статистических задач очень часто информация заносится в таблицы, в информатике каждая таблица это тоже двумерный массив.
Про матрицу, имеющую m строк и n столбцов, говорят, что она имеет размер m*n.
Перемещаться по таблице мы можем, двигаясь по строке в этом случае индекс строки изменяется медленнее, чем индекс столбца, и, соответственно, по столбцу (индекс столбца будет изменяться медленнее, чем индекс строки).
При решении задач с использованием двумерных массивов во всех случаях (кроме некоторых частных) организуются вложенные циклы.
Перемещение по строке:
For i:=l to m do —> внешний цикл, изменяется номер строки
For j:=l to n do —> внутренний цикл, изменяется номер столбца
Перемещение по столбцу:
For j:=l to n do —> внешний цикл, изменяется номер столбца
For i:=l to m do —> внутренний цикл, изменяется номер строки
Перечислим базовые алгоритмы и рассмотрим каждый из них. Заполнение двумерного массива:
а) по строке,
б) по столбцу.
2. Печать в виде таблицы.
3. Вычисление суммы элементов каждой строки и каждого столбца.
4. Поиск максимального (минимального) элементов каждой строки (столбца) и их индексов.
5. Сумма элементов массива.
6. Максимальный (минимальный) элемент массива.
Заполнение двумерного массива по строке.
Массив содержит 3 строки и 4 столбца, т.е. 3х4=12 элементов.
Заполним значениями элементы первой строки:
For j:=l to 4 do
a[i]:=random(100);
Для того, чтобы перейти к заполнению элементов второй строки, мы должны изменить индекс строки на 1 и получить два, и т.д. Индекс строк меняется медленнее, чем индекс столбца. Фрагмент программы для общего случая:
for i:=l to 3 do
for j:=l to 4 do
a[i,j]:=random(100);
Заполнение двумерного массива по столбцу.
Заполним двумерный массив, перемещаясь по столбцу.
for j:=l to 4 do {внешний цикл: j — индекс столбца; он меняется медленнее}
for i:=l to 3 do
a[i,j]:==random(100);
Обратите внимание на порядок расположения индексов a [i,j] !
Печать содержимого двумерного массива в виде таблицы.
for i:=l to 3 do begin
for j:=l to 4 do
write(a[i,j],' '); {печатаем элементы строки, не перемещая курсор}
writeln() {перемещаем курсор}
end;
При составлении программ ранее использовались переменные. Для каждой переменной компьютер отводит ячейку памяти обращение к которой выполняется по имени переменной. Недостатком такого способа написания программ – при работе с большим количеством данных пришлось бы выделять большое количество переменных. Зачастую работа с одним типом данных проводится по одному принципу меняется лишь числовое значение. Гораздо легче данные одного типа обозначать одной переменной меняя лишь номер ячейки в которой хранится значения. Такая организация данным называется массив.
Массивом называется упорядоченная последовательность величин, обозначенная одним именем. В языках программирования массивы могут быть одномерные и двухмерные. Если в одномерном массиве указывается имя и номер ячейки, то в двух мерном указывается имя, номер строки и номер столбца, на котором он расположен. Чтобы получить доступ к ячейкам необходимо указать имя массива и его индекс. Один – для одномерного массива и два для двухмерного.
Под массивы, также как и под переменные, машина должна выделять память. Если для переменной машина выделяет одну ячейку памяти, то для массива машина резервирует память сразу под весь массив. Для этого компьютеру необходимо указать, сколько памяти, сколько ячеек необходимо зарезервировать, т.е. какие массивы будут использованы в программе и их размер.
Массив - это упорядоченная структура однотипных данных, хранящая их последовательно. Доступ к элементу массива осуществляется через его индекс. Массивы описываются следующим образом:
Имя типа = ARRAY [ диапазоны индексов ] OF тип элемента массива;
В качестве типа для элементов массива можно использовать любые типы Турбо Паскаля кроме файловых. Диапазоны индексов представляют собой один или несколько диапазонов, перечисленные через запятую. В качестве диапазонов индексов нельзя использовать диапазоны с базовым типом Longint.
ПРИМЕР: Три способа описания одного и того же типа массива:
type {1} M1 = array [0..5] of integer;
M2 = array [char] of M1;
M3 = array [-2..2] of M2;
{2} M3 = array [-2..2] of array [char] of array [0..5] of integer;
{3} M3 = array [-2..2,char,0..5] of integer;
var A:M3;
{Обращаться к элементам массива можно следующим образом:}
begin
read(A[-1,'a',3]);
read(A[1]['x'][0]);
A[1]['c',1]:=100;
end.
Глубина вложенности, т.е. количество индексов, при определении массивов не ограничена. Играет роль только суммарный объем данных в программе. В стандартном режиме работы Турбо Паскаля этот объем ограничен размерами сегмента, т.е. 64 килобайта. Целиком над массивами допускается применение только операции присваивания массивов (подмассивов) одинаковых типов. Остальные операции должны выполняться поэлементно.
ПРИМЕР: Вычисление значения многочлена степени N, коэффициенты которого находятся в массиве A в точке X по схеме Горнера.
Pn(x) = A[0]*X^n + A[1]*X^(n-1) + ... + A[n-1]*X + A[n] =
= (...((A[0]*X + A[1])*X + A[2])*X + ... + A[n-1])*X + A[n].
program Scheme_Gorner;
type Mas = array[0..100] of integer;
var A:Mas; i,j,n:integer; x,p:real;
begin
write('степень многочлена = '); read(n);
writeln('введите целые коэффициенты : ');
for i:=0 to n do read(A[i]);
write('значение X = '); read(x);
p:=0;
for i:=0 to n do p:=p*x+A[i];
writeln('Pn(X) = ',p);
end.
В программировании даже при написании самых простых программ возникает необходимость в большом количестве переменных. Обычно они разные по типам и по использованию, но бывают ситуации, когда эти переменные одинаковы и их необходимо очень большое количество.
Для того, чтобы Вы лучше поняли, я приведу простой пример. Давайте представим работу такой программы, как нахождение среднего арифметического среди 100 чисел. Что нам понадобиться для написания такой программы? Конечно, сами числа. Для хранения 100 чисел мы должны использовать 100 переменных. Описать их можно, скажем, следующим образом:
var
n1,n2,n3,n4,n5,
n6,n7, ..., n100: Integer;
Это будет выглядеть крайне громоздко, не так ли? Вот здесь и возникает понятие массивов. Массив - это на самом деле одна переменная, но она содержит в себе большое количество отдельных элементов, того типа, который определит программист, и столько, сколько он захочет. (При этом размер массива несколько ограничен). Что это означает? Что заведя переменную-массив мы как бы создаем цепочку переменных. После чего мы можем обратиться к любому элементу этой цепочки: прочитать его, изменить, сделать с ним все, что можно сделать с обычной переменной.
Помните строку? Я имею в виду тип String, который позволяет обратиться к любому символу своему символу:
S: String; S[2] := 'a';
Так вот, String - это и есть своего рода массив. Массив из переменных типа Char. Посмотрите, мы заводим всего одну переменную, после чего можем обратиться к любому ее символу, изменить его, прочитать и т.д. (Однако предупрежу, String - это всеже не массив. Просто этот тип очень подходит для примера).
Также мы можем создать цепочку и из чисел, и из символов, да и вообще из чего угодно. Сегодня мы разберем создание массивов из чисел, а далее по ходу рассылки разберемся и с другими типами массивов.
Классификация типов данных в Паскале.
Под типом данных понимается множество допустимых значений этих данных, а также совокупность операций над ними.
3.1. Классификация типов данных
В Turbo Pascal можно выделить следующие группы типов:
- простые типы;
- структурированные типы;
- указатели;
- процедурные типы;
- объекты.
Среди типов, используемых в языке, есть стандартные (предопределенные) и определяемые программистом. К стандартным типам, не требующим предварительного определения, относятся целые типы, вещественные типы, логические типы, символьный тип - Char, тип-строка - string, ASCIIZ-строка - PChar, текстовый файл - Text, тип-указатель - Pointer. Все другие используемые типы данных должны быть определены либо в разделе объявления типов, либо в разделе объявления переменных или типизированных констант.
Раздел объявления типов начинается зарезервированным словом type, после которого определяются вводимые типы. Определение каждого нового типа начинается с идентификатора типа. За ним следует знак равенства, а далее - само определение, завершающееся точкой с запятой:
type
<имя типа 1> = <определение типа 1>;
<имя типа 2> = <определение типа 2> ;
<имя типа N> = <определение типа N>;
В качестве примера см. п. 3.2.4.
В данном разделе будут описаны только простые типы данных, все остальные типы будут рассмотрены после описания переменных, констант и выражений.
3.2. Простые типы данных
Простой тип определяет допустимое множество значений данных этого типа а также совокупность операций над ними.
В Turbo Pascal имеются следующие группы простых типов:
- целые типы;
- перечисляемый тип;
- логический тип;
- тип-диапазон;
- символьный тип;
- вещественные типы.
Все простые типы, за исключением вещественных, являются порядковыми типами. Для величин порядковых типов определены: следующее значение и предыдущее значение. Для величин порядковых типов определены стандартные процедуры и функции: Dec, Inc, Ord, Pred, Succ.
3.2.1. Целые типы
В отличие от языка Паскаль, где определен единственный целый тип Integer, в Turbo Pascal имеется пять стандартных типов целых чисел: Shortint, Integer, Longint, Byte, Word.
Характеристики этих типов приведены в табл. 2.
Таблица 2. Целые типы данных
Тип Диапазон Формат Размер в байтах
Shortint -128 .. 127 Знаковый 1
Integer -32768 .. 32767 Знаковый 2
Longint -2147483648 .. 2147483647 Знаковый 4
Byte 0.. 255 Беззнаковый 1
Word 0.. 65535 Беззнаковый 2
3.2.2. Логический тип
Стандартный логический тип Boolean (размер - 1 байт) представляет собой тип данных, любой элемент которого может принимать лишь два значения: True и False.
При этом справедливы следующие соотношения:
False < True Succ (False) = True
Ord (False) = 0 Pred(True) = False
Ord(True) = 1
В Turbo Pascal 7.0 добавлено еще три логических типа ByteBool (размер - 1 байт), WordBooL (размер - 2 байта) и LongBool (размер - 4 байта). Они введены для унификации с другими языками программирования и со средой Windows. Отличие их от стандартного типа Boolean заключается в фактической величине параметра этого типа, соответствующей значению True. Для всех логических типов значению False соответствует число 0, записанное в соответствующее количество байтов. Значению же True для типа Boolean соответствует число 1, записанное в его байт, а для других типов значению True соответствует любое число, отличное от нуля (хотя функция Ord в этом случае дает значение 1).
3.2.3. Символьный тип
Стандартный символьный тип Char определяет полный набор ASCII-символов. Функция Ord от величины типа Char дает код соответствующего символа. Сравниваются величины символьного типа по своим кодам.
3.2.4. Перечисляемый тип
Перечисляемый тип не является стандартным и определяется набором идентификаторов, с которыми могут совпадать значения параметра. Список идентификаторов указывается в круглых скобках, идентификаторы разделяются запятыми:
type
<имя типа> = (<идентификатор 1, идентификатор 2, ... , идентификатор М>);
Важно, в каком порядке перечислены идентификаторы при определении типа, т. к. первому идентификатору присваивается порядковый номер 0, второму - 1 и т. д. Один и тот же идентификатор можно использовать в определении только одного перечисляемого типа. Функция Ord от величины перечисляемого типа дает порядковый номер ее значения.
Пример. Перечисляемый тип,
type Operat = (Plus, Minus, Mult, Divide);
Логический тип является частным случаем перечисляемого типа:
type Boolean = (False, True);
3.2.5. Тип-диапазон
В любом порядковом типе можно выделить подмножество значений, определяемое минимальным и максимальным значением, в которое входят все значения исходного типа, находящиеся в этих границах, включая и сами границы. Такое подмножество определяет тип - диапазон. Тип-диапазон задается указанием минимального и максимального значений, разделенных двумя точками:
type
<имя типа> = <мин. значение> .. <макс. значение>;
Минимальное значение при определении такого типа не должно быть больше максимального.
Пример. Определение типов-диапазонов.
type
Dozen = 1..12; {числа от 1 до 12}
AddSub = Plus..Minus; {операции сложения и вычитания}
3.2.6. Вещественные типы
В отличие от стандарта языка Паскаль, где определен только один вещественный
тип Real, в Turbo Pascal имеется пять стандартных вещественных типов:
Real, Single, Double, Extended, Comp.
Характеристики этих типов см. в табл. 3.
Таблица 3. Вещественные типы данных
Тип Диапазон Число Размер значащих цифр в байтах
Real 2.9*10-39..1.7*1038 11-12 6
Single 1.5*10-45..3-4*1038 7-8 4
Double 5.0*10-324..1.7*10308 15-16 8
Extended 3.4*10-4932..1.1*104932 19-20 10
Comp -263.. +263-1 19-20 8
Тип Comp фактически является типом целых чисел увеличенного диапазона, однако порядковым не считается.
Типы Single, Double, Extended и Comp можно использовать в программах только при наличии арифметического сопроцессора или при включенном эмуляторе сопроцессора
Типовые алгоритмы обработки массивов. Вычисление суммы, среднего, произведения.
Задача:
Найти средние арифметические пяти массивов, состоящих их десяти целых чисел.
Описание переменных:
arr – массив, состоящий их 5 элементов-массивов, каждый из которых в свою очередь содержит 10 целых чисел;
average – массив, содержащий средние арифметические вложенных массивов массива arr;
Алгоритм решения задачи:
Заполняем массивы целыми числами с помощью функции fill_array. Функция вызывается в цикле for 5 раз и возвращает очередной подмассив массива arr.
Для каждого вложенного массива целых чисел вычисляется среднее арифметическое с помощью функции found_average. Результат заносится в массив average.
Программа на языке Паскаль:
const n = 10; m = 5;
type
type_numbers = array[1..n] of integer;
type_arr = array[1..m] of type_numbers;
type_average = array[1..m] of real;
var
arr: type_arr; {array of arrays}
average: type_average; {array of averages}
i,j: byte;
function fill_array():type_numbers;
var i:byte; a:type_numbers;
begin
for i:=1 to n do a[i]:=random(50)+1;
fill_array := a;
end;
function found_average(a:type_numbers):real;
var i:byte; sum:integer;
begin
sum := 0;
for i:=1 to n do sum:=sum+a[i];
found_average := sum / n;
end;
begin
randomize;
for i:=1 to m do arr[i] := fill_array();
for i:=1 to m do begin
for j:=1 to n do write(arr[i,j]:3);
average[i]:=found_average(arr[i]);
writeln(' -- ', average[i]:6:2);
end;
readln
end.
Нахождение суммы элементов массива
Пусть известно, что в автопарке, имеющем 18 машин марки КАМАЗ, каждый из КАМАЗов перевез за день определенный объем груза. Определить суммарный объем перевозок грузов за день.
При решении задачи будем использовать тип массива KAMAZ для описания всех КАМАЗов автопарка; переменную Р[i] для описания объема груза, перевезенной i-ой машиной за день (i меняется от 1 до 18).
Алгоритм решения задачи:
Текст программы может иметь при этом следующий вид:
Program pr1;
Type KAMAZ =array[1..18] of real;
Var i:integer;
P:KAMAZ;
S:real;
Begin
S:=0;
For i:=1 to 18 do
Begin
Writeln (‘Введите объем перевозок ', i, ‘-й машины, т');
Readln (p[i]);
S:=S+p[i];
End;
Writeln (‘Суммарный объем перевозок S=',S:8:2,' т');
End.
Накопление суммы в данном примере будет проводиться по шагам, при вводе для очередной машины значения объема перевозок сумма будет увеличиваться на данную величину.
Аналогично реализуется и алгоритм нахождения произведения элементов массива (с заменой начального значения суммы S:=0 на начальное значение произведения S:=1, и с заменой операции сложения элементов массива «+» на операцию умножения «*»).
Целые типы данных в языке Турбо-Паскаль.
Данные целого типа используются в тех случаях, когда величину нужно представить абсолютно точно, например, число предметов. К данным целого типа относятся константы и переменные. Константа целого типа - это десятичное число, записанное без точки. Если константа отрицательная, то перед ней ставится знак минус.
Знак плюс можно не указывать.
Пример: 7, -140, +357, 0, 999.
Константы могут быть обозначены именем. В этом случае они задаются в разделе const.
Пример: const k=15; p1=-46; p2=46;
Переменная целого типа принимает значение целого десятичного числа. Описание переменной обозначается integer.
Пример: var a,b:integer; b1,b2:integer;
Данные целого типа (integer) принимают значения от -32768 до +32767. В памяти машины эти значения представлены точно.
В разделе операторов переменные целого типа должны принимать значения целых десятичных чисел.
Пример: a:=25; S:=0;
Типовые алгоритмы обработки массивов. Нахождение минимального и максимального значения на массиве.
Одной из наиболее распространенных задач обработки массивов является поиск минимального (максимального) элемента.
Пример 31. В массиве X из 20 вещественных чисел поменять местами наибольшие и наименьшие элементы.
Уточним пространство решений. В массиве X может присутствовать несколько максимальных и минимальных элементов. Возможен неординарный случай для этой задачи, который состоит в том, что все элементы массива равны между собой. Переменные, используемые в программе, и их тип описаны в следующей таблице:
Эту задачу нужно решать с помощью двух последовательных просмотров массива X. Целью первого просмотра является вычисление наибольшего МАХ и наименьшего МIN значений элементов массива X. В начале просмотра значение первого элемента Х[1] считается одновременно наибольшим и наименьшим, что справедливо в том случае, если в массиве всего один элемент. Далее со второго элемента Х[2] и до последнего Х[20] сравниваются значение текущего элемента с MIN. Если значение текущего элемента меньше, то оно с этого момента считается минимальным. По окончании цикла в рабочей ячейке MIN окажется число, равное значению наименьшего элемента. Аналогично поступаем для нахождения МАХ.
Далее нужно сравнить между собой MIN и МАХ. Если эти величины равны между собой, то массив состоит из 20 равнозначных элементов. Следовательно, переставлять их местами нет необходимости. Если MIN≠МАХ, то нужно наименьшим элементам присвоить значение МАХ, а наибольшим элементам присвоить значение MIN. Эти действия являются основой для второго просмотра массива X.
PROGRAM PR31;
VAR
X: ARRAY [ 1.. 20] OF REAL;
I: INTEGER;
MIN, MAX: REAL;
BEGIN
WRITELN('Введите массив X, из 20 вещественных чисел');
FOR I := 1 ТО 20 DO READ(X[I]);
MIN :=Х[1];
МАХ :=Х[1];
FOR I := 2 ТО 20
DO BEGIN
IF MIN>X[I]
THEN MIN := X[I];
IF MAX<X[I]
THEN MAX := X[I];
END;
IF MIN <> MAX
THEN FOR I := 1 TO 20
DO BEGIN
IF MAX = X[I]
THEN X[I] := MIN
ELSE IF MIN = X[I]
THEN X[I]:=MAX;
END;
WRITELN('Элементы массива X имеют значения:');
FOR I := 1 TO 20 DO WRITE(X[I]: 4:1,' ');
WRITELN
END.
Вещественные типы данных в языке Турбо-Паскаль.
Действительный (вещественный) тип данных в Turbo Pascal
Данные действительного (вещественного) типа необходимы тогда, когда числовые значения могут содержать дробные части. Действительный тип данных используется для описания действительных переменных, т.е. таких переменных, значением которых может быть действительное или целое число.
В Turbo Pascal константа действительного типа может быть представлена в двух видах:
Числом с фиксированной точкой.
Числом с плавающей точкой.
Число с фиксированной точкой изображается десятичным числом с дробной частью (она может быть и нулевой). Дробная часть отделяется от целой с помощью точки. Например: 19.56; 0.05; -376.18; Следует обратить внимание на то, что в записи действительных чисел вместо десятичной запятой, как принято в математике, используется ДЕСЯТИЧНАЯ ТОЧКА!
Очень большие и очень маленькие числа в математике принято записывать в виде чисел с порядком, т.е. в виде умножения значащих цифр на степень числа 10. В Turbo Pascal такая запись называется записью числа с плавающей точкой. Число с плавающей точкой записывается в виде: mEp, где m - мантисса числа, p - порядок числа.
Операции над действительными числами: сложение +, вычитание -, умножение *, деление /. Одно из двух данных при этом может быть целого типа, но результат операции будет действительным числом.
К действительным числам можно применять встроенные функции:
sin(x);
cos(x);
exp(x);
ln(x);
sqr(x);
sqrt(x);
arctan(x);
abs(x);
pi=3.14159...;
int(x) - целая часть числа;
frac(x) - дробная часть числа; random(x) - случайное число (от 0 до 1).
Вывод действительных данных возможен с форматом и без формата. Если формат отсутствует, то число выводится с плавающей точкой с мантиссой и порядком, при этом на изображение числа отводится 17 позиций. В целой части мантиссы присутствует только 1 значащая цифра, в дробной части 10 цифр, а на порядок с учетом знака отводится 3 позиции.
Пример: -3.2648375386Е-01.
Для наглядности выводимых результатов предусмотрены форматы.
Формат указывается в операторе вывода write вслед за выводимым данным через двоеточие: R:m:n, где R - выводимое данное действительного типа, m - общее поле выводимого числа (включая знак числа, целую часть, точку и дробную часть), n - поле дробной части.
В качестве m и n могут быть целые константы, переменные, выражения. Чаще всего это целые числа. При использовании форматов число выводится с фиксированной точкой. Пример: Для вывода числа R:=-0.18 достаточно указать в операторе write(R:5:2); Если формат указан больше, чем необходимо, то перед целой частью располагаются избыточные пробелы, а после дробной части - нули.
Типовые алгоритмы обработки массивов. Поиск элементов, удовлетворяющих определенным условиям.
Нахождение количества элементов массива, удовлетворяющих некоторому условию
Известны результаты экзамена 22 студентов одной группы по информатике. Определить, сколько студентов сдали экзамен на 4 и 5.
Один из вариантов решения поставленной задачи имеет следующий вид:
Program pr3;
Label 1;
Type INF=array[1..22] of integer;
Var stud:INF;
i,p:integer;
begin
p:=0;
for i:=1 to 22 do
begin
1: writeln(‘Введите оценку ',i,'-го студента');
readln(stud[i]);
if (stud[i]<1) or (stud[i]>5) then goto 1;
if stud[i]>3 then p:=p+1;
end;
writeln(‘На 4 и 5 сдали экзамен ',p:2,' студентов');
end.
В данной программе для обозначения списка оценок по информатике использовался тип массива INF, для обозначения оценок конкретных студентов - переменная stud. Программа предусматривает проверку корректности вводимых данных: при попытке ввода несуществующей по пятибалльной системе оценки, программа повторяет ее ввод. Для этого используется оператор перехода GOTO, где имя метки, к которой осуществляется переход (в данном случае 1), описывается в разделе описания меток LABEL.
Типизированные файлы. Пример поиска в файле
Типизированный файл – это файл, в котором содержатся однотипные данные. Типизированный файл задается с помощью 2-х ключевых слов «file of». После слова «of» указывается тип файла, например integer, real, char, string и т.д. Тип файла может быть любым за исключением файлового типа (не может быть файла файлов) и комбинированного типа, один из компонентов которого имеет файловый тип.
В отличие от текстовых файлов, в типизированном файле информация хранится в двоичном представлении (в текстовом файле информация хранится в виде цепочки символов). Данный факт позволяет производить чтение и запись в файл более быстрым способом, т.к. отсутствует необходимость в преобразовании данных. Кроме того, в типизированном файле возможен прямой доступ к записям файла (в текстовом файле возможен только последовательный доступ).
Напишем программу, которая создаст своеобразную базу данных, хранящей сведения о студентах: их именах, номерах курса и групп.
Типизированные файлы в Паскаль.
Program file11;
uses crt;
Type Student = record
fio: string [20];
kurs, group: integer;
end;
var zap : student;
f: file of student;
name: string;
begin
clrscr;
Writeln ('Задайте имя файла');
Readln (name);
Assign (f, name);
Rewrite (f);
Writeln ('Введите фамилию и инициалы студента');
Readln (zap.fio);
While zap.fio <> ' ' do
Begin
Writeln ('Введите номер курса и группы');
Readln (zap.kurs, zap.group);
Write (f, zap);
Writeln ('Введите фамилию и инициалы следующего студента ');
Readln (zap.fio);
End;
Close(f);
Writeln ('Файл создан');
readln
End.
Переменные и константы строкового типа. Основные процедуры и функции для работы с ними.
В качестве значения строковой константы может выступать любая последовательность символов. Эта последовательность заключается в апострофы. Строковая константа отличается от символьной константы тем, что здесь в качестве значения константы можно использовать не один символ, а несколько.
view source
print?
01.Program number25;
02.Uses Crt;
03.Const hello = 'Привет, ';
04.Var name: string;
05.Begin
06.ClrScr;
07.Write('Введите имя: ');
08.Readln(name);
09.Write(hello, name, '!');
10.ReadLn
11.End.
Строки в Паскале – это данные типа string. Они используются для хранения последовательностей символов. В Паскале длина стандартной строки ограничена 255 символами. Под каждый символ отводится по одному байту, в котором хранится код символа. Кроме того, каждая строка содержит еще дополнительный байт, в котором хранится длина строки.
Если заранее известно, что длина строки будет меньше 255 символов, то программист может сам задать максимальную длину строки.
Примеры описания строк:
type
str_type = string[12];
const
n = 50;
var
s1: string;
s2, s3: str_type;
s4: string[n];
s5, s6, s7: string[7];
…
Длина строки хранится в первом ее байте, индекс которого равен 0. Объявление типизированной константы для типа string осуществляется так:
const
s: string = 'FreePascal'
…
Существует понятие пустой строки, т.е. строки, которая не имеет элементов. Пустая строка обозначается двумя рядом стоящими апострофами (например, st := '').