 |
Основная структура программы.
|
|
|
|
ИСТОРИЯ ВОЗНИКНОВЕНИЯ
Язык программирования создал профессор Высшей федеральной технической школы в Цюрихе Николаус Вирт и назвал его именем известного французского математика и философа Блеза Паскаля (1623-1662 гг.).
Начало создания Паскаля связано с усилиями Н.Вирта и К.Хоора переработать язык программирования Алгол-60 и на его основе создать новый язык. Примерно в 1968 г. бал подготовлен проект языка и начата разработка его транслятора для вычислительной машины CDC 6400, который был готов в 1970 г. В 1971 г. было представлено первое официальное описание языка.
В 1975 г. была создана ассоциация пользователей Паскаля. Позже язык подвергся критике. Пользователи были не удовлетворены слишком строгими ограничениями некоторых конструкций языка. В 1977 г. была создана группа по разработке стандарта языка Паскаль. Ею руководил А.Эддиман. В 1983 г. 1 декабря был объявлен международный стандарт языка Паскаль ИСО 7185.
В 1992 г. фирма Borland International выпустила два пакета программирования, основанные на использовании языка Паскаль - Borland Pascal 7.0 и Turbo Pascal 7.0.
Пакет Borland Pascal 7.0 включает в себя три режима работы в обычном режиме операционной системе MS DOS, в защищенном режиме MS DOS и в среде Windows. Обладая расширенными возможностями, пакет требует значительных ресурсов (~ 30 Mb на жестком диске и і 2 Mb ОЗУ). Пакет Turbo Pascal 7.0 обладает ограниченными возможностями и позволяет работать только в обычном режиме MS DOS, но может быть использован практически на любой машине (вплоть до 286) и стоит дешевле.
В настоящее время, язык Паскаль является общепризнанным языком обучения программированию, сочетающем в себе все основные свойства серьезного алгоритмического языка программирования высокого уровня и доступную форму, позволяющую начинающему программисту освоить технологию создания программы. Кроме того, существуют пакеты, основанные на использовании Паскаля (Delphi, компонентный Паскаль), использующие современный объектно-ориентированный подход.
|
|
|
Основные понятия.
Как и любой алгоритм, являющийся, как вы помните, последовательностью инструкций, программа на языке Паскаль состоит из команд (операторов), записанных в определенном порядке и формате.
Команды позволяют получать, сохранять и обрабатывать данные различных типов (например, целые числа, символы, строки символов, т.д.). Однако кроме команд в записи программы участвуют еще так называемые "служебные слова". Это и есть элементы формальности, организующие структуру программы. Их не так много, но их значение трудно переоценить. Служебные слова можно использовать только по своему прямому назначению. Переопределять их не разрешается.
Вам уже известно, что основное назначение компьютера - облегчить человеку работу с большими объемами информации, поэтому подавляющее большинство программ построено по одному, довольно простому принципу: получение данных из внешнего мира (ввод), обработка их по соответствующему алгоритму, хранение необходимой информации и вывод во внешний (по отношению к компьютеру) мир полученных результатов. Все эти действия реализуются через имеющиеся в языках программирования команды, алгоритмические структуры и структуры данных.
СТАНДАРТНЫЕ ТИПЫ
ДАННЫХ
К стандартным относятся целые, действительные, логические,
символьный и адресный типы.
ЦЕЛЫЕ типы определяют константы, переменные и функции, значения которых реализуются множеством целых чисел, допустимых в данной ЭВМ.
| тип | диапозон значений | требуемая память |
| Shortint | -128.. 127 | 1 байт |
| Integer | -32768.. 32767 | 2 байт |
| Longint | -2147483648.. 2147483647 | 4 байт |
| Byte | 0.. 255 | 1 байт |
| Word | 0.. 65535 | 2 байт |
|
|
|
Над целыми операндами можно выполнять следующие арифметические операции: сложение, вычитание, умножение, деление, получение остатка от деления.
Знаки этих операций: +, -, *, div, mod
Результат арифметической операции над целыми операндами есть величина целого типа. Результат выполнения операции деления целых величин есть целая часть частного. Результат выполнения операции получения остатка от деления - остаток от деления целых. Например:
17 div 2 = 8, 3 div 5 = 0.
17 mod 2 = 1, 3 mod 5 = 3.
Операции отношения, примененные к целым операндам, дают результат логического типа TRUE или FALSE (истина или ложь).
В языке ПАСКАЛЬ имеются следующие операции отношения: равенство =,
неравенство <>,
больше или равно >=,
меньше или равно <=,
больше >, меньше <.
К аргументам целого типа применимы следующие стандартные (встроенные) функции, результат выполнения которых имеет целый тип:
Abs(X), Sqr(X), Succ(X), Pred(X),
и которые определяют соответственно абсолютное значение Х, Х в квадрате, Х+1, Х-1.
Следующая группа стандартных функций для аргумента целого типа дает действительный результат:
Sin(X), Cos(X), ArcTan(X), Ln(X), Exp(X), Sqrt(X).
Эти функции вычисляют синус, косинус и арктангенс угла, заданного в радианах, логарифм натуральный, экспоненту и корень квадратный соответственно.
Результат выполнения функции проверки целой величины на нечетность Odd(X) имеет значение истина, если аргумент нечетный, и значение ложь, если аргумент четный:
X=5 Odd(X)=TRUE, X=4 Odd(X)=FALSE.
Для быстрой работы с целыми числами определены процедуры:
Inc(X) X:=X+1
Inc(X,N) X:=X+N
Dec(X) X:=X-1
Dec(X,N) X:=X-N
ДЕЙСТВИТЕЛЬНЫЕ типы определяет те данные, которые реализуются подмножеством действительных чисел, допустимых в данной ЭВМ.
1.Тип Диапазон 2. Количество цифр 3. Требуемая
значений 4.мантиссы память (байт)
1 2 3 4
---------------------------------------------------------------
Real 2.9e-39.. 1.7e+38 11 6
Single 1.5e-45.. 3.4e+38 7 4
Double 5.0e-324.. 1.7e+308 15 8
Extended 3.4e-4932.. 1.1e+4932 19 10
Comp -9.2e+18.. 9.2e+18 19 8
---------------------------------------------------------------
Над действительными операндами можно выполнять следующие арифметические операции, дающие действительный результат:
сложение +, вычитание -, умножение *, деление /.
К величинам действительного типа применимы все операции отношения, дающие булевский результат.
Один из операндов, участвующих в этих операциях, может быть целым. К действительным аргументам применимы функции, дающие действительный результат:
|
|
|
Abs(X), Sqr(X), Sin(X), Cos(X), ArcTan(X), Ln(X), Exp(X),
Sqrt(X), Frac(X), Int(X), Pi.
Функция Frac(X) возвращает дробную часть X, функция Int(X) – целую часть X.
Безаргументная функция Pi возвращает значение числа Пи действительного типа.
К аргументам действительного типа применимы также функции
Trunc(X) и Round(X),
дающие целый результат. Первая из них выделяет целую часть действительного аргумента путем отсечения дробной части, вторая округляет аргумент до ближайшего целого.
ЛОГИЧЕСКИЙ тип (Boolean) определяет те данные, которые могут принимать логические значения TRUE и FALSE.
К булевским операндам применимы следующие логические операции:
not and or xor.
Логический тип определен таким образом, что FALSE < TRUE. Это позволяет применять к булевским операндам все операции отношения.
СИМВОЛЬНЫЙ тип (Char) определяет упорядоченную совокупность символов, допустимых в данной ЭВМ. Значение символьной переменной или константы - это один символ из допустимого набора.
Символьная константа может записываться в тексте программы тремя способами:
-как один символ, заключенный в апострофы, например:
'A' 'a' 'Ю' 'ю';
-с помощью конструкции вида #K, где K - код соответствущего символа, при этом значение K должно находиться в пределах 0..255;
-с помощью конструкции вида ^C, где C - код соответствущего управляющего символа, при этом значение C должно быть на 64 больше кода управляющего символа.
К величинам символьного типа применимы все операции отношения.
Для величин символьного типа определены две функции преобразования
Ord(C) Chr(K).
Первая функция определяет порядковый номер символа С в наборе символов, вторая определяет по порядковому номеру К символ, стоящий на К-ом месте в наборе символов. Порядковый номер имеет целый тип.
К аргументам символьного типа применяются функции, которые определяют предыдущий и последующий символы:
Pred(C) Succ(C). Pred('F') = 'E'; Succ('Y') = 'Z'.
При отсутствии предыдущего или последующего символов значение соответствующих функций не определено.
Для литер из интервала 'a'..'z' применима функция UpCase(C), которая переводит эти литеры в верхний регистр 'A'..'Z'.
|
|
|
АДРЕСНЫЙ тип (Pointer) определяет переменные, которые могут содержать значения адресов данных или фрагментов программы. Для хранения адреса требуются два слова (4 байта), одно из них определяет сегмент, второе - смещение.
КОНСТАНТЫ
Тип констант в языке ПАСКАЛЬ определяется по их виду: константы целого типа - это целые числа, не содержащие десятичной точки, константы действительного типа - действительные числа, логические константы - логические значения TRUE и FALSE, символьные константы - либо строки длиной в один символ, либо конструкции вида #K или ^K. Язык ПАСКАЛЬ допускает использовать синонимы для обозначения констант, в этом случае текст программы содержит раздел описания констант, например: { }
ПЕРЕМЕННЫЕ
Тип переменных определяется пользователем в разделе описания переменных.
В настоящее время в профессиональном программировании принято записывать имена переменных с использованием так называемой венгерской нотации.
Венгерская нотация - это соглашение о наименованиях переменных и функций. Соглашение широко используется при программировании на языках PASCAL, C и в среде WINDOWS.
Венгерская нотация основывается на следующих принципах:
-имена переменных и функций должны содержать префикс, описывающий их тип;
-имена переменных и функций записываются полными словами или словосочетаниями или их сокращениями, но так, чтобы по имени можно было понять назначение переменной или действие, выполняемое функцией. Префиксы записываются малыми буквами, первая буква каждого слова заглавная, префиксы и слова записываются либо слитно, либо через сим вол _ (подчеркивание).
Для языка PASCAL могут быть рекомендованы следующие префиксы для скалярных переменных и функций:
Префикс Тип
---------------------
by Byte
sh Shortint
i Integer
w Word
l Longint
r Real
si Single
d Double
e Extended
c Comp
ch Char
b Boolean
p Pointer
x,у координаты символа или точки на экране
Для величин структурированного типа могут быть использованы следующие префиксы:
a --Array
s --String
sz --Stringz
se --Set
re --Record
f ---File
t ---Text
Например:
rV, arVector[1..20], sName, iCount.
В откомпилированной программе для всех переменных отведено место в памяти, и всем переменным присвоены нулевые значения. Для задания начальных значений переменным (инициализации переменных) TURBO PASCAL позволяет присваивать начальные значения переменным одновременно с их описанием. Для этого используется конструкция
имя переменной: тип = значение;
которая должна быть размещена в разделе описания констант, например:
const rWeight: Real = 0.4;
ОПЕРАТОРЫ ВВОДА И ВЫВОДА
|
|
|
Рассмотрим организацию ввода и вывода данных с терминального устройства. Терминальное устройство - это устройство, с которым работает пользователь, обычно это экран (дисплей) и клавиатура. Для ввода и вывода данных используются стандартные процедуры ввода и вывода Read и Write, оперирующие стандартными последовательными файлами INPUT и OUTPUT.
Эти файлы разбиваются на строки переменной длины, отделяемые друг от друга признаком конца строки. Конец строки задается нажатием клавиши ENTER.
Для ввода исходных данных используются операторы процедур ввода:
Read(A1,A2,...AK);
ReadLn(A1,A2,...AK);
ReadLn;
Первый из них реализует чтение К значений исходных данных и присваивание этих значений переменным А1, А2,..., АК. Второй оператор реализует чтение К значений исходных данных, пропуск остальных значений до начала следующей строки, присваивание считанных значений переменным А1, А2,..., АК. Третий оператор реализует пропуск строки исходных данных.
При вводе исходных данных происходит преобразование из внешней формы представления во внутреннюю, определяемую типом переменных. Переменные, образующие список ввода, могут принадлежать либо к целому либо к действительному, либо к символьному типам. Чтение исходных данных логического типа в языке ПАСКАЛЬ недопустимо.
Операторы ввода при чтении значений переменных целого и действительного типа пропускает пробелы, предшествующие числу. В то же время эти операторы не пропускают пробелов, предшествующих значениям символьных переменных, так как пробелы являются равноправными символами строк. Пример записи операторов ввода:
var rV, rS: Real;
iW, iJ: Integer;
chC, chD: Char;
................
Read(rV, rS, iW, iJ);
Read(chC, chD);
Значения исходных данных могут отделяться друг от друга пробелами и нажатием клавиш табуляции и Enter.
Для вывода результатов работы программы на экран используются операторы:
Write(A1,A2,...AK);
WriteLn(A1,A2,...AK);
WriteLn;
Первый из этих операторов реализует вывод значений переменных А1, А2,...,АК в строку экрана. Второй оператор реализует вывод значений переменных А1, А2,..., АК и переход к началу следующей строки. Третий оператор реализует пропуск строки и переход к началу следующей строки.
Переменные, составляющие список вывода, могут относиться к целому, действительному, символьному или булевскому типам. В качестве элемента списка вывода кроме имен переменных могут использоваться выражения и строки.
Вывод каждого значения в строку экрана происходит в соответствии с шириной поля вывода, определяемой конкретной реализацией языка.
Форма представления значений в поле вывода соответствует типу переменных и выражений: величины целого типа выводятся как целые десятичные числа, действительного типа - как действительные десятичные числа с десятичным порядком, символьного типа и строки - в виде сим волов, логического типа - в виде логических констант TRUE и FALSE.
Оператор вывода позволяет задать ширину поля вывода для каждого элемента списка вывода. В этом случае элемент списка вывода имеет вид А:К, где А - выражение или строка, К - выражение либо константа целого типа. Если выводимое значение занимает в поле вывода меньше позиций, чем К, то перед этим значением располагаются пробелы. Если выводимое значение не помещается в ширину поля К, то для этого значения будет отведено необходимое количество позиций. Для величин действительного типа элемент списка вывода может иметь вид А:К:М, где А - переменная или выражение действительного типа, К - ширина поля вывода, М - число цифр дробной части выводимого значения. К и М - выражения или константы целого типа. В этом случае действительные значения выводятся в форме десятичного числа с фиксированной точкой. Пример записи операторов вывода:
............
var rA, rB: Real; iP,iQ:Integer;
bR, bS: Boolean; chT, chV, chU, chW: Char;
............
WriteLn(rA, rB:10:2);
WriteLn(iP, iQ:8);
WriteLn(bR, bS:8);
WriteLn(chT, chV, chU, chW);
Основная структура программы.
Правила языка Паскаль предусматривают единую для всех программ форму основной структуры:
Program <Имя программы>;
<Раздел описаний>
Begin
<Тело программы>
End.
Здесь слова Program, Begin и End являются служебными. Правильное и уместное употребление этих слов является обязательным.
ЦИКЛИЧЕСКИЕ СТРУКТУРЫ
На языке Pascal структура цикла "Пока" записывается следующим образом:
While <условие> Do <оператор>;
Здесь, так же как в формате условного оператора, подразумевается выполнение только одного оператора. Если необходимо выполнить несколько действий, то может быть использован составной оператор. Тогда формат оператора принимает такой вид:
While <условие> Do
Begin
<оператор #1>;
<оператор #2>;
<оператор #3>;
...
End;
Цикл "ДО"
Этот вид цикла отличается от предыдущего в основном тем, что проверка условия повторения тела цикла находится не перед ним, а после. Поэтому цикл "До" называют циклом "с постусловием", а "Пока" - "с предусловием".
Обратите также внимание на то, что новая итерация (повторное выполнение тела цикла) происходит не тогда, когда условие справедливо, а как раз тогда, когда оно ложно. Поэтому цикл и получил свое название (выполнять тело цикла до выполнения соответствующего условия).
Интересно, что в случае, когда условие цикла изначально истинно, тело цикла все равно будет выполнено хотя бы один раз. Именно это отличие "до" от "пока" привело к тому, что в программировании они не подменяют друг друга, а используются для решения задач, к которым они более подходят.
Формат цикла на языке Pascal:
Repeat
<оператор #1>;
<оператор #2>;
<оператор #3>;
...
Until <условие>;
Читается так: "Выполнять оператор #1, оператор #2.: до выполнения условия".
Здесь не требуется использование составного оператора, потому, что сами слова Repeat и Until являются операторными скобками.
Цикл "С параметром".
В данном случае параметром будет являться целочисленная переменная, которая будет изменяться на единицу при каждой итерации цикла. Таким образом, задав начальное и конечное значения для такой переменной, можно точно установить количество выполнений тела цикла. Нарисовать блок-схему такой структуры вы сможете сами после некоторых пояснений.
Форматов у этого вида цикла предусмотрено два:
For <И.П.>:=<Н.З.> To <К.З.> Do <оператор>;
For <И.П.>:=<Н.З.> Downto <К.З.> Do <оператор>;
Здесь И.П. - имя переменной-параметра, Н.З. - его начальное значение, К.З. - соответственно конечное значение параметра. В качестве начального и конечного значений
Читается данная структура так: "Для переменной (далее следует ее имя) от начального значения до конечного выполнять оператор (являющийся телом цикла)". Иногда цикл с параметром даже называют "Для" или "For". В первом случае параметр с каждой итерацией увеличивается на единицу, во втором - уменьшается.
Выполняется этот цикл по следующему алгоритму:
1. переменной-параметру присваивается начальное значение;
2. выполняется тело цикла;
3. переменная-параметр автоматически увеличивается на 1 (в первом случае формата);
4. если параметр превышает конечное значение, то происходит выход из цикла, иначе - переход к пункту 2.
Примечание: при использовании Downto параметр автоматически уменьшается на 1, а выход из цикла происходит тогда, когда параметр становится меньше конечного значения.
Таким образом, в отличие от первых двух видов цикла, этот цикл используется тогда, когда известно необходимое количество выполнений тела цикла.
Вообще говоря, цикл "Пока" является универсальным, то есть любая задача, требующая использования цикла, может быть решена с применением этой структуры. Циклы "До" и "С параметром" созданы для удобства программирования.
Пример.
Найти сумму квадратов всех натуральных чисел от 1 до 100.
Решим эту задачу с использованием всех трех видов циклов.
I. С использованием цикла "Пока".
Program Ex1;
Var
A: Integer;
S: Longint;
Begin
A:=1; S:=0;
While A<=100 Do
Begin
S:=S+A*A;
A:=A+1
End;
Writeln(S)
End.
II. С использованием цикла "До".
Program Ex2;
Var
A: Integer;
S: Longint;
Begin
A:=1; S:=0;
Repeat
S:=S+A*A;
A:=A+1
Until A>100;
Writeln(S)
End.
III. С использованием цикла "С параметром".
Program Ex3;
Var
A: Integer;
S: Longint;
Begin
S:=0;
For A:=1 To 100 Do S:=S+A*A;
Writeln(S)
End.
Теперь вам известны все основные алгоритмические структуры языка Паскаль. Комбинируя их, возможно запрограммировать решение любой задачи, конечно, если таковое существует. Тем не менее, изучение языка на этом не закачивается, так как для написания хороших программ по утверждению уважаемого Никлауса Вирта (за время моей работы у меня не появилось оснований в этом сомневаться) нужны кроме алгоритмических, еще удобные структуры данных. В рассматриваемом языке таких структур множество, для каждого вида определены свои команды и операции. К их рассмотрению мы и переходим.
Строковые операции
До сих пор мы с вами рассматривали программы, реализующие алгоритмы обработки числовых данных. Однако хоть ЭВМ изначально и были созданы только для этой цели, по мере развития аппаратной части появилась возможность оцифровывать данные других типов, хранить их в памяти машины, перерабатывать, выводить во внешний по отношению к компьютеру мир. Проще всего можно было так поступить с текстовой информацией. Если не ставить перед машиной задачу "понимания" смысла текста, то задача оцифровки сводится к установлению правил замены символов (литер) при вводе в компьютер на их коды и обратной замены при выводе информации на экран или принтер. Такие правила, конечно же, были составлены. Как водится, сначала их было множество (вспомните разнообразие таблиц кодировки), затем весь мир остановился на ASCII.
Все языки программирования высокого уровня имеют средства работы с литерными величинами. Паскаль - не исключение. Как вам уже известно, в стандарте языка описаны два типа переменных для литерных величин. Это - String и Char. Напомню - переменная типа Char может содержать в себе только один единственный символ, тип String предназначен для хранения строковых величин до 255 символов длиною. Кстати, вы знаете не все о типе String. При описании переменной этого типа вы можете сами указать максимальное число символов, которое можно занести в нее. Конечно же, это число не должно превышать 255. Делается это так:
Var
S: String[30];
Для чего это нужно?
Дело в том, что при компиляции для каждой переменной отводится свой участок памяти. Если мы будем выделять для всех переменных типа String по 256 байт, то это приведет к тому, что при использовании достаточно большого их количества, памяти может и не хватить? Но если в переменной мы собираемся хранить, например, фамилию пользователя, то тридцати символов (тридцати байт) для этого вполне достаточно. Таким образом, экономится память и увеличивается быстродействие программ.
Переменным строкового типа можно присваивать строковые величины (внутри программы они заключаются в апострофы), значения выражений, которые приводят к строковым величинам. Значения можно также вводить с клавиатуры. При этом апострофы не используются. Как вам известно, в числовую переменную нельзя ввести строковую величину. Сделать наоборот - возможно, однако число, находящееся в строковой переменной представляет собой просто последовательность символов (цифр), поэтому в арифметических выражениях участвовать не может.
Также, новым для вас явится то, что при использовании строковой переменной, к каждому ее символу можно обратиться отдельно. Необходимо только знать номер нужного символа от начала строки. Его достаточно поставить после имени переменной типа String в квадратных скобках.
Пример: S[5] - пятый символ строки S.
С отдельным символом строки можно производить все действия, которые можно производить с любой символьной переменной (ввод, присвоение, вывод на экран, участие в выражениях и т.д.).
Обратите внимание на то, что нумерация символов в строке начинается с единицы. Внутри квадратных скобок вместо числа может находиться выражение, результатом которого является целое число. Главное чтобы символ с таким номером в строке существовал. Но как же узнать, сколько символов в данный момент находится в строковой переменной? Для этого существует специальная функция, которая возвращает длину строковой переменной в символах. Это функция Length. Ее формат: Length(S)
Здесь S - либо строковая величина, либо строковая переменная.
Приведенная далее программа выводит на экран длину введенной пользователем строковой величины.
Program Str1;
Var
S: String;
Begin
Writeln('Введите последовательность символов');
Readln(S);
Writeln('Вы ввели строку из ',Length(S), ' символов')
End.
Другой пример:
Решим задачу: "Введенную строку вывести на экран по одному символу в строке экрана".
Program Str2;
Var
S: String;
I: Byte;
Begin
Writeln('Введите строку');
Readln(S);
For I:=1 to Length(S) do {организуем цикл, начиная с первого символа}
Writeln(S[I]) {строки, до последнего (номер последнего}
{совпадает с количеством символов строки S) }
End.
Какие же еще действия можно выполнять с переменными строкового типа?
Две строковые величины можно состыковывать. Эта операция называется конкатенацией и обозначается знаком "+".
Например, результатом выполнения следующих команд:
R:= 'kadabra';
H:= 'abra';
S:=H+R;
в переменной S будет значение 'abrakadabra'.
Для конкатенации результат зависит от порядка операндов (в отличие от операции сложения). Следует помнить о том, какой максимальной длины может быть результирующая переменная, так как в случае превышения значением выражения числа, указанного после String в описании переменной, "лишние" символы в переменную не попадут.
Строковые величины можно сравнивать между собой. Это относится также и к строковым переменным. Но как же компьютер определяет, какая строка больше:
- та, которая длиннее?
- та, которая содержит больше заглавных букв?
На самом деле такая проверка проходит довольно сложно: компьютер сравнивает сначала первые символы строк. Большим из двух считается тот, код которого больше (вспомните, что такое код символа). Если равны первые символы, то так же анализируется следующая пара до тех пор, пока не будет найдено различие. Если начало строк совпадает, а одна из них кончается раньше, то вторая автоматически называется большей.
Код символа в Паскале можно определить при помощи функции Ord.
Ее формат: Ord(C), где С - либо непосредственно указанный символ, либо переменная символьного типа, либо один символ строковой переменной. Вообще, функция Ord имеет более глубокий смысл, но об этом - позже. Есть и обратная функция, которая возвращает символ по известному коду. Это функция Chr(N), где N - выражение, приводящее к целому числу в интервале от 0 до 255 (возможные значения кода символа). Очевидно, что Chr(Ord(C))=C, Ord(Chr(N))=N.
Следующая маленькая программа выводит на экран кодовую таблицу:
Program Str3;
Var
I: Byte;
Begin
For I:=32 to 255 do
Write('VV',I:4, '-',Chr(I))
End.
Цикл в программе начинается с 32 потому, что символы с кодами от 0 до 31 являются управляющими и не имеют соответствующего графического представления.
Задача: "Определить, является ли введенная строка "перевертышем". Перевертышем называется такая строка, которая одинаково читается с начала и с конца. Например, "казак" и "потоп" - перевертыши, "канат" - не перевертыш".
Поступим следующим образом: из введенной строки сформируем другую строку из символов первой, записанных в обратном порядке, затем сравним первую строку со второй; если они окажутся равны, то ответ положительный, иначе - отрицательный. Естественно, предложенный способ решения не является единственно возможным.
Program Str4;
Var
S,B: String;
I: Byte;
Begin
Writeln('Введите строку');
Readln(S);
B:=''; {Переменной B присваиваем значение "пустая строка"}
For I:=1 to Length(S) do
B:=S[I]+B; {Конкатенация. Символы строки S пристыковываются к}
{переменной B слева. Самым левым окажется последний.}
If B=S Then Writeln('Перевертыш') Else Writeln('Не перевертыш')
End.
Число, записанное в строковую переменную, естественно числом не является, но очень часто требуется его все же использовать в качестве числа. Для этого нужно произвести преобразование типа. Перевод строкового представления числа в числовое выполняет в Паскале оператор Val.
Его формат:
Val(S,X,C);
Здесь S - строка, содержащая число, X - числовая переменная, в которую будет помещен результат, С - переменная целочисленного типа, в которую помещается первого встреченного в S отличного от цифры символа. Если после выполнения оператора Val переменная С имеет значение 0, то это означает, что преобразование типа прошло совершенно успешно и в строке нецифровых символов не встретилось.
Противоположное действие осуществляет оператор Str. Формат оператора:
Str(X,S);
X - число (либо арифметическое выражение), S - строковая переменная.
В переменную S попадает строковое представление числа X. Это нужно, например, при необходимости выводить на экран числа в графическом режиме (будет изучено позже), так как стандартные процедуры вывода на экран там работают только со строковыми величинами.
Для иллюстрации рассмотрим такую задачу: "Найти сумму цифр введенного натурального числа". Используя только числовые переменные, решить ее можно, но предлагаемое здесь решение, по-моему, проще.
Program Str5;
Var
S: String;
I,X,A,C: Integer;
Begin
Writeln('Введите натуральное число');
Readln(S); {Число вводится в строковую переменную}
A:=0;
For I:=1 To Length(S) Do
Begin
Val(S[I],X,C); {Цифровой символ превращается в число}
A:=A+X {Цифры суммируются}
End;
Writeln('Сумма цифр равна ',A)
End.
Теперь рассмотрим еще несколько действий над строками:
- оператор DELETE(S,I,C) из строковой переменной S удаляет C символов, начиная с I-того;
- оператор INSERT(SN,S,I) вставляет подстроку SN в строковую переменную S перед символом с номером I;
- функция COPY(S,I,C) возвращает подстроку строки S из C символов, начиная с символа с номером I;
- функция Pos(SN,S) возвращает номер символа, с которого в строке S начинается подстрока SN (позицию первого вхождения подстроки в строку). Если такой подстроки нет, то возвращается ноль.
Пример их использования:
"Во введенной строке заменить все вхождения подстроки 'ABC' на подстроки 'KLMNO'".
Program Str6;
Var
S: String;
A: Byte;
Begin
Writeln('Введите строку');
Readln(S);
While Pos('ABC',S)<>0 Do
Begin
A:= Pos('ABC',S);
Delete(S,A,3);
Insert('KLMNO',S,A)
End;
Writeln(S)
End.
Определение типов
Как было упомянуто ранее, в изучаемом языке возможно определять новые типы переменных. После определения этот тип становится доступным для описания переменных, также как и стандартные типы.
Новый тип перед первым его использованием должен быть описан в соответствующем разделе описаний. Его заголовок - служебное слово Type.
Type
<Имя типа> = <Описание типа>;
Есть несколько способов описания. Иногда говорят даже о видах типов (как бы это странно ни звучало).
Итак, первым рассмотрим так называемый перечисляемый тип.
Перечисляемый тип используется для повышения наглядности программ, позволяя записывать в переменные этого типа названия разнообразных объектов, исследуемых программой. Этот тип представляет собой набор идентификаторов, с которыми могут совпадать значения параметров.
Формат описания следующий: <Имя типа> = (<Ид.1>, <Ид.2>,? <Ид.n>);
Далее можно определить любое число переменных уже описанного типа. Обратите внимание на то, что каждый идентификатор может участвовать в описании только одного перечисляемого типа.
Этим переменным можно присваивать только значения из списка, определенного при описании типа. Эти значения не являются ни числами, ни строковыми величинами, ни даже величинами логического типа, поэтому они не могут участвовать в арифметических, строковых, логических выражениях, а также не могут быть выведены на экран или принтер. Величины перечисляемого типа можно сравнивать между собой, над их множеством в языке Паскаль определены несколько функций:
Ord(X) - порядковый номер значения переменной X в списке идентификаторов.
Succ(X) - следующее значение для величины Х.
Pred(X) - предыдущее значение данного типа.
Обратите внимание на то, что для функции Ord нумерация среди значений идет, начиная от нуля. Для последнего значения нельзя применять функцию Succ, для первого - Pred.
Переменные различных перечисляемых типов несовместимы друг с другом.
Множество стандартных порядковых типов в языке Паскаль на самом деле определены как перечисляемые. Это типы Char, Integer, другие. Достоинства стандартных порядковых типов лишь в том, что над каждым из них уже определены специфические действия. Например, тип Boolean описан так:
Type
Boolean = (False, True);
Единственное его отличие от перечисляемых типов, определяемых программистом, состоит в том, что значения типа Boolean можно выводить на экран. Можете проверить, Ord(False)=0.
Интересно, что переменная перечисляемого типа может быть счетчиком в цикле "с параметром".
Пример:
Program T1;
Type
Colors = (Black, Blue, Green, Cyan, Red, Magenta, Brown, Yellow, White);
Var
C1,C2: Colors;
Begin
C1:=Green;
C2:=Red;
Writeln(Ord(C1), Ord(Succ(C2)))
End.
Во время выполнения на экране появятся числа "2" и "5", что соответствует номерам значений Green и Magenta.
Следующий тип, который можно определить в программе - тип-диапазон.
Здесь не нужно перечислять все значения этого типа, потому, что возможными для него являются значения поддиапазона уже определенного до него любого порядкового типа (стандартного или описанного ранее перечисляемого типа). Достаточно лишь указать начальную и конечную величину отрезка порядкового типа. Единственное условие: начальное значение не должно превышать конечное.
Формат описания отрезочного типа:
Type
<Имя типа>=<Нач.>..<Кон.>;
Примеры:
Type
Age=0..150; {Целое число в интервале от 0 до 150}
Lat='A'.. 'Z'; {Заглавные буквы латинского алфавита}
Month=(January, February, March, April, May, June, July, August, September, October, November, December);
Spring=March..May; {Весенние месяцы}
Есть еще одна возможность определить новый тип, о существовании которой можно было бы и догадаться.
Type
<Имя типа>=<Имя ранее определенного или стандартного типа>;
Пример:
Type
Number=Byte;
Массивы
До сих пор мы рассматривали переменные, которые имели только одно значение, могли содержать в себе только одну величину определенного типа. Исключением являлись лишь строковые переменные, которые представляют собой совокупность данных символьного типа, но и при этом мы говорили о строке, как об отдельной величине.
Вы знаете, что компьютер предназначен в основном для облегчения работы человека с большими информационными объемами. Как же, используя только переменные известных вам типов, сохранить в памяти и обработать данные, содержащие десяток, сотню, тысячу чисел или, к примеру, строк? А ведь такие задачи встречаются в любой области знания. Конечно, можно завести столько переменных, сколько данных, можно даже занести в них значения, но только представьте, какой величины будет текст такой программы, сколько времени потребуется для его составления, как много места для возможных ошибок? Естественно, об этом задумывались и авторы языков программирования. Поэтому во всех существующих языках имеются типы переменных, отвечающие за хранение больших массивов данных. В языке Паскаль они так и называются: "массивы".
Массивом будем называть упорядоченную последовательность данных одного типа, объединенных под одним именем. Кстати, под это определение подходит множество объектов из реального мира: словарь (последовательность слов), мультфильм (последовательность картинок) и т. д. Проще всего представить себе массив в виде таблицы, где каждая величина находится в собственной ячейке. Положение ячейки в таблице должно однозначно определяться набором координат (индексов). Самой простой является линейная таблица, в которой для точного указания на элемент данных достаточно знания только одного числа (индекса). Мы с вами пока будем заниматься только линейными массивами, так как более сложные структуры строятся на их основе.
Описание типа линейного массива выглядит так:
Type <Имя типа>=Array [<Диапазон индексов>] Of <Тип элементов>;
В качестве индексов могут выступать переменные любых порядковых типов. При указании диапазона начальный индекс не должен превышать конечный. Тип элементов массива может быть любым (стандартным или описанным ранее).
Описать переменную-массив можно и сразу (без предварительного описания типа) в разделе описания переменных:
Var <Переменная-массив>: Array [<Диапазон индексов>] Of <Тип элементов>;
Примеры описания массивов:
Var
S, BB: Array [1..40] Of Real;
N: Array ['A'..'Z'] Of Integer;
R: Array [-20..20] Of Word;
T: Array [1..40] Of Real;
Теперь переменные S, BB и T представляют собой массивы из сорока вещественных чисел; массив N имеет индексы символьного типа и целочисленные элементы; массив R может хранить в себе 41 число типа Word.
Единственным действием, которое возможно произвести с массивом целиком - присваивание. Для данного примера описания впоследствии допустима следующая запись:
S:=BB;
Однако, присваивать можно только массивы одинаковых типов. Даже массиву T присвоить массив S нельзя, хотя, казалось бы, их описания совпадают, произведены они в различных записях раздела описания.
Никаких других операций с массивами целиком произвести невозможно, но с элементами массивов можно работать точно также, как с простыми переменными соответствующего типа. Обращение к отдельному элементу массива производится при помощи указания имени всего массива и в квадратных скобках - индекса конкретного элемента. Например:
R[10] - элемент массива R с индексом 10.
Фундаментальное отличие компонента массива от простой переменной состоит в том, что для элемента массива в квадратных скобках может стоять не только непосредственное значение индекса, но и выражение, приводящее к значению индексного типа. Таким образом реализуется косвенная адресация:
BB[15] - прямая адресация;
BB[K] - косвенная адресация через переменную K, значение которой будет использовано в качестве индекса элемента массива BB.
Такая организация работы с такой структурой данных, как массив, позволяет использовать цикл для заполнения, обработки и распечатки его содержимого.
Если вы помните, с такой формой организации данных мы встречались, когда изучали строковые переменные. Действительно, переменные типа String очень близки по своим свойствам массивам типа Char. Отличия в следующем: строковые переменные можно было вводить с клавиатуры и распечатывать на экране (с обычным массивом это не проходит); длина строковой переменной была ограничена 255 символами (255 B), а для размера массива критическим объемом информации является 64 KB.
Теперь рассмотрим несколько способов заполнения массивов и вывода их содержимого на экран. В основном мы будем пользоваться числовыми типами компонент, но приведенные примеры будут справедливы и для других типов (если они допускают указанные действия).
Program M1;
Var
A: Array [1..20] Of Integer;
Begin
A[1]:=7; {Заполняем массив значениями (отдельно каждый компонент)}
A[2]:=32;
A[3]:=-70;
.............. {Трудоемкая задача?}
A[20]:=56;
Writeln(A[1],A[2],A[3],?,A[20])
End.
Как бы ни был примитивен приведенный пример, он все же иллюстрирует возможность непосредственного обращения к каждому элементу массива отдельно. Правда, никакого преимущества массива перед несколькими простыми переменными здесь не видно. Поэтому - другой способ:
Program M2;
Var
A: Array [1..20] Of Integer;
I: Integer;
Begin
For I:=1 To 20 Do {Организуем цикл с параметром I по всем возможным}
Readln(A[I]); {значениям индексов и вводим A[I] с клавиатуры }
For I:=20 Downto 1 Do {Распечатываем массив в обратном порядке}
Write(A[I],'VVV')
End.
Эта программа вводит с клавиатуры 20 целых чисел, а затем распечатывает их в обратном порядке. Теперь попробуйте написать такую же программу, но без использования структуры массива. Во сколько раз она станет длиннее? Кстати, введение язык Паскаль цикла с параметром было обусловлено во многом необходимостью обработки информационных последовательностей, т. е. массивов.
Следующая программа заполняет массив значениям квадратов индексов элементов:
Program M3;
Const
N=50; {Константа N будет содержать количество элементов массива}
Var
A: Array [1..N] Of Integer;
I: Integer;
Begin
For I:=1 To N Do
A[I]:=I*I
For I:=1 To N Do
Write(A[I],'VVV')
End.
В дальнейшем для учебных целей мы будем использовать массивы, заданные с помощью генератора случайных чисел. В языке Паскаль случайные числа формирует функция Random. Числа получаются дробными, равномерно расположенными в интервале от 0 до 1. Выражение, дающее целое случайное число в интервале [-50,50] будет выглядеть так:
Trunc(Random*101)-50
Зададим и распечатаем случайный массив из сорока целых чисел:
Program M4;
Const
N=40; {Константа N будет содержать количество элементов массива}
Var
A: Array [1..N] Of Integer;
I: Integer;
Begin
For I:=1 To N Do
Begin
A[I]:= Trunc(Random*101)-50
Write(A[I],'VVV')
End
End.
С обработкой линейных массивов связано множество задач. Их мы рассмотрим на практических занятиях.
Двумерные и многомерные массивы
Представьте себе таблицу, состоящую из нескольких строк. Каждая строка состоит из нескольких ячеек. Тогда для точного определения положения ячейки нам потребуется знать не одно число (как в случае таблицы линейной), а два: номер строки и номер столбца. Структура данных в языке Паскаль для хранения такой таблицы называется двумерным массивом. Описать такой массив можно двумя способами:
I.
Var
A: Array [1..20] Of Array [1..30] Of Integer;
II.
Var
A: Array [1..20,1..30] Of Integer;
В обоих случаях описан двумерный массив, соответствующий таблице, состоящей из 20 строк и 30 столбцов. Приведенные описания совершенно равноправны.
Отдельный элемент двумерного массива адресуется, естественно, двумя индексами. Например, ячейка, находящаяся в 5-й строке и 6-м столбце будет называться A[5][6] или A[5,6].
Для иллюстрации способов работы с двумерными массивами решим задачу: "Задать и распечатать массив 10X10, состоящий из целых случайных чисел в интервале [1,100]. Найти сумму элементов, лежащих выше главной диагонали."
При отсчете, начиная с левого верхнего угла таблицы, главной будем считать диагональ из левого верхнего угла таблицы в правый нижний. При этом получается, что элементы, лежащие на главной диагонали будут иметь одинаковые индексы, а для элементов выше главной диагонали номер столбца будет всегда превышать номер строки. Договоримся также сначала указывать номер строки, а затем - номер столбца.
Program M5;
Var
A: Array[1..10,1..10] Of Integer;
I, K: Byte;
S: Integer;
Begin
S:=0;
For I:=1 To 10 Do
Begin
For K:=1 To 10 Do
Begin
A[I,K]:=Trunc(Random*100)+1;
Write(A[I,K]:6);
If K>I Then S:=S+A[I,K]
End;
Writeln
End;
Writeln('Сумма элементов выше гл. диагонали равнаV',S)
End.
Если модель данных в какой-либо задаче не может свестись к линейной или плоской таблице, то могут использоваться массивы произвольной размерности. N-мерный массив характеризуется N индексами. Формат описания такого типа данных:
Type
<Имя типа>=Array[<диапазон индекса1>,<диапазон индекса2>,...
<диапазон индекса N>] Of <тип компонент>;
Отдельный элемент именуется так:
<Имя массива>[<Индекс 1>,<Индекс 2>,...,<Индекс N>]
Процедуры и функции
При решении сложных объемных задач часто целесообразно разбивать их на более простые. Метод последовательной детализации позволяет составить алгоритм из действий, которые, не являясь простыми, сами представляют собой достаточно самостоятельные алгоритмы. В этом случае говорят о вспомогательных алгоритмах или подпрограммах. Использование подпрограмм позволяет сделать основную программу более наглядной, понятной, а в случае, когда одна и та же последовательность команд встречается в программе несколько раз, даже более короткой и эффективной.
В языке Паскаль существует два вида подпрограмм: процедуры и функции, определяемые программистом. Процедурой в Паскале называется именованная последовательность инструкций, реализующая некоторое действие. Функция отличается от процедуры тем, что она должна обязательно выработать значение определенного типа.
Процедуры и функции, используемые в программе, должны быть соответствующим образом описаны до первого их упоминания. Вызов процедуры или функции производится по их имени.
Подпрограммы в языке Паскаль могут иметь параметры (значения, передаваемые в процедуру или функцию в качестве аргументов). При описании указываются так называемые формальные параметры (имена, под которыми будут фигурировать передаваемые данные внутри подпрограммы) и их типы. При вызове подпрограммы вместе с ее именем должны быть заданы все необходимые параметры в том порядке, в котором они находятся в описании. Значения, указываемые при вызове подпрограммы, называются фактическими параметрами.
Формат описания процедуры:
Procedure <Имя процедуры> (<Имя форм. параметра 1>:<Тип>;
< Имя форм. параметра 2>:<Тип>?);
<Раздел описаний>
Begin
<Тело процедуры>
End;
Раздел описаний может иметь такие же подразделы, как и раздел описаний основной программы (описание процедур и функций - в том числе). Однако все описанные здесь объекты "видимы" лишь в этой процедуре. Они здесь локальны также, как и имена формальных параметров. Объекты, описанные ранее в разделе описаний основной программы и не переопределенные в процедуре, называются глобальными для этой подпрограммы и доступны для использования.
Легко заметить схожесть структуры программы целиком и любой из ее процедур. Действительно, ведь и процедура и основная программа реализуют некий алгоритм, просто процедура не дает решения всей задачи. Отличие в заголовке и в знаке после End.
Формат описания функции:
Function <Имя функции> (<Имя форм. параметра 1>:<Тип>;
< Имя форм. параметра 2>:<Тип>?): <Тип результата>;
<Раздел описаний>
Begin
<Тело функции>
End;
В теле функции обязательно должна быть хотя бы команда присвоения такого вида: <Имя функции>:=<Выражение>;
Указанное выражение должно приводить к значению того же типа, что и тип результата функции, описанный выше.
Вызов процедуры представляет в программе самостоятельную инструкцию:
<Имя процедуры>(<Фактический параметр 1>, < Фактический параметр 2>?);
Типы фактических параметров должны быть такими же, что и у соответсвующих им формальных.
Вызов функции должен входить в выражение. При вычислении значения такого выражения функция будет вызвана, действия, находящиеся в ее теле, будут выполнены, в выражение будет подставлено значение результата функции.
Приведем простейший пример использования подпрограммы.
Задача: "Найти максимальное из трех введенных чисел". Для решения воспользуемся описанием функции, принимающей значение максимального из двух чисел, которые передаются в нее в виде параметров.
Program Fn;
Var
A,B,C:Real;
Function Max(A,B:Real):Real; {Описываем функцию Max с формальными}
Begin {параметрами A и B, которая принимает }
If A>B Then Max:=A {значение максимального из них }
Else Max:=B {Здесь A и B - локальные переменные }
End;
Begin
Writeln('Введите три числа');
Readln(A,B,C);
Writeln('Максимальным из всех является ', Max(Max(A,B),C))
End.
Обратите внимание на краткость тела основной программы и на прозрачность действий внутри функции. Формальные параметры A и B, используемые в подпрограмме, не имеют никакого отношения переменным A и B, описанным в основной программе.
Существует два способа передачи фактических параметров в подпрограмму: по значению и по ссылке. В первом случае значение переменной-фактического параметра при вызове подпрограммы присваивается локальной переменной, являющейся формальным параметром подпрограммы. Что бы потом ни происходило с локальной переменной, это никак не отразится на соответствующей глобальной. Для одних задач это благо, но иногда требуется произвести в подпрограмме действия над самими переменными, указанными в качестве фактических параметров. На помощь приходит второй способ. Происходит следующее: при обращении к подпрограмме не происходит формирования локальной переменной-формального параметра. Просто на время выполнения подпрограммы имя этой локальной переменной будет указывать на ту же область памяти, что и имя соответствующей глобальной переменной. Если в этом случае изменить локальную переменную, изменятся данные и в глобальной.
Передача параметров по ссылке отличается тем, что при описании подпрограммы перед именем переменной-формального параметра ставится служебное слово Var. Теперь использование в качестве фактических параметров выражений или непосредственных значений уже не допускается - они должны быть именами переменных.
Еще один классический пример. Задача: "Расположить в порядке неубывания три целых числа".
Program Pr;
Var
S1,S2,S3:Integer;
Procedure Swap(Var A,B: Integer);{Процедура Swap с параметрами-переменными}
Var C: Integer; {C - независимая локальная переменная}
Begin
C:=A; A:=B; B:=C {Меняем местами содержимое A и B}
End;
Begin
Writeln('Введите три числа');
Readln(S1,S2,S3);
If S1>S2 Then Swap(S1,S2);
If S2>S3 Then Swap(S2,S3);
If S1>S2 Then Swap(S1,S2);
Writeln('Числа в порядке неубывания:V',S1,S2,S3)
End.
Работа с файлами
Тип-файл представляет собой последовательность компонент одного типа, расположенных на внешнем устройстве (например, на диске). Элементы могут быть любого типа, за исключением самого типа-файла. Число элементов в файле при описании не объявляется. Работа с физическими файлами происходит через так называемые файловые переменные.
Для задания типа-файла следует использовать зарезервированные слова File и Of, после чего указать тип компонент файла.
Пример:
Type
N = File Of Integer; {Тип-файл целых чисел}
C = File Of Char; {Тип-файл символов}
Есть заранее определенный в Паскале тип файла с именем Text. Файлы этого типа называют текстовыми.
Введя файловый тип, можно определить и переменные файлового типа:
Var
F1: N;
F2: C;
F3: Text;
Тип-файл можно описать и непосредственно при введении файловых переменных:
Var
Z: File Of Word;
Файловые переменные имеют специфическое применение. Над ними нельзя выполнять никаких операций (присваивать значение, сравнивать и т.д.). Их можно использовать лишь для выполнения операций с файлами (чтение, запись и т.д.).
Элементы файла считаются расположенными последовательно, то есть так же, как элементы линейного массива. Отличие же состоит в том, что, во-первых, размеры файла могут меняться, во-вторых, способ обращения к элементам совсем другой: невозможно обратиться к произвольному элементу файла; элементы его просматриваются только подряд от начала к концу, при этом в каждый момент времени доступен только один элемент. Можно представить себе, что для каждого файла существует указатель, показывающий в данный момент на определенный компонент файла. После проведения операции чтения или записи указатель автоматически передвигается на следующий компонент.
Перед тем, как осуществлять ввод-вывод, файловая переменная должна быть связана с конкретным внешним файлом при помощи процедуры Assign.
Формат:
Assign (<Имя файловой переменной>,<Имя файла>);
Имя файла задается либо строковой константой, либо через переменную типа Sting. Имя файла должно соответствовать правилам работающей в данный момент операционной системы. Если строка имени пустая, то связь файловой переменной осуществляется со стандартным устройством ввода-вывода (как правило - с консолью).
После этого файл должен быть открыт одной из процедур:
Reset (<Имя файловой переменной>);
Открывается существующий файл для чтения, указатель текущей компоненты файла настраивается на начало файла. Если физического файла, соответствующего файловой переменной не существует, то возникает ситуация ошибки ввода-вывода.
Rewrite (<Имя файловой переменной>);
Открывается новый пустой файл для записи, ему присваивается имя, заданное процедурой Assign. Если файл с таким именем уже существует, то он уничтожается.
После работы с файлом он, как правило, должен быть закрыт процедурой Close.
Close (<Имя файловой переменной>);
Это требование обязательно должно соблюдаться для файла, в который производилась запись.
Теперь рассмотрим непосредственную организацию чтения и записи.
Для ввода информации из файла, открытого для чтения, используется уже знакомый вам оператор Read. Правда, в его формате и использовании вы заметите некоторые изменения:
Read (<Имя файловой переменной>, <Список ввода>);
Происходит считывание данных из файла в переменные, имена которых указаны в списке ввода. Переменные должны быть того же типа, что и компоненты файла.
Вывод информации производит, как можно догадаться оператор Write (<Имя файловой переменной>, <Список вывода>);
Данные из списка вывода заносятся в файл, открытый для записи.
Для текстовых файлов используются также операторы Readln и Writeln с соответствующими дополнениями, относящимися к файловому вводу-выводу. Любопытно, что вывод данных на монитор и ввод с клавиатуры в языке Паскаль тоже являются действиями с файлами. Они даже имеют свои предопределенные файловые переменные текстового типа: Output и Input соответственно. Переменная Output всегда открыта для записи, Input - для чтения. Если не указывать файловые переменные в операторах ввода-вывода (придем к формату, рассмотренному в теме "Операторы ввода-вывода"), то в случае записи по умолчанию выбирается файл Output, в случае чтения - Input.
Как вы знаете, любой файл конечен и продолжать чтение из него информации можно лишь до определенного предела. Как этот предел установить? Проверить, окончен ли файл, можно вызовом стандартной логической функции Eof (<Имя файловой переменной>)
Она вырабатывает значение True, если файл окончен, и False - в противном случае.
Решим следующую задачу: "Написать программу, которая вводит с клавиатуры список фамилий учащихся, а затем распечатывает его, кроме тех учащихся, у которых фамилия начинается с буквы 'Ш'".
Так как заранее количество данных не известно, то для их хранения используем файл. Тип элементов - строковый.
Program L;
Var
I,N: Integer;
F: File Of String;
S: String;
Begin
Assign(F,'Spis.lst'); {Связываем переменную F с файлом Spis.lst}
Writeln('Введите количество учащихся');
Readln(N); {Вводим количество учащихся}
Rewrite(F); {Создаем файл для записи в него данных}
For I:=1 To N Do {Для всех учащихся}
Begin
Writeln('Введите фамилию');
Readln(S);
Write(F,S)
End;
Close(F);
Reset(F);
Writeln; Writeln('Список учащихся:');
While Not(Eof(F)) Do
Begin
Read(F,S);
If S[1]<>'Ш' Then
Writeln(S)
End;
Close(F)
End.
Copied from: http://articles.org.ru/docum/pas.php
|
|
|
