Текст книги "Песни о Паскале (СИ)"
Автор книги: Олег Деревенец
Жанр:
Драматургия
сообщить о нарушении
Текущая страница: 10 (всего у книги 29 страниц)
Поиск номера должен начинаться с начала файла. Оператор Reset внутри функции как раз и возвращает позицию чтения на линию старта. Будьте спокойны – файл от этого не пострадает, открывать его для чтения можно без ограничений!
Теперь взгляните на условие цикла WHILE, – оно чуть сложнее тех, к которым мы привыкли.
while not Eof(aFile) and (N<>aNumber)
Наряду с признаком конца файла проверяется и условие несовпадения искомого номера с номером, прочитанным из файла. Значит, цикл будет продолжаться, пока НЕ достигнут конец файла И НЕ найден искомый номер.
Внутри цикла находим непривычный оператор присваивания.
FindNumber:= (N=aNumber); { true, если номер нашелся }
Левая его часть – это идентификатор функции, а правая (в скобках) – оператор сравнения двух чисел. Оператор сравнения дает булев результат, равный TRUE, если числа совпадают. Скобки в правой части здесь не нужны, но я поставил их для наглядности. Приведенный выше оператор можно было бы заменить таким.
if N=aNumber
then FindNumber:= true
else FindNumber:= false;
Но, согласитесь, первый вариант наглядней и короче.
Итак, прежде чем двинуться дальше, не поленитесь проверить эту программу.
Полицейская база данных, версия 2
Теперь слегка изменим расположение чисел в файле «Police.txt». Вместо одного числа в строке, напечатайте в каждой по нескольку чисел, разделив их одним или несколькими пробелами, например:
123 234 325
223 240
845 431 205
Подобное расположение данных вполне обычно, взгляните хотя бы в классный журнал, где в одной строке проставлен ряд оценок. Мы, программисты, должны извлекать данные даже из таких файлов.
Переключитесь в окно нашей базы данных «Police.txt» и внесите необходимые изменения. Сохранить файл не забыли? Теперь запустите программу и проверьте её на номерах из этого файла. При должном внимании вы обнаружите, что программа правильно находит только числа, начинающие строку, например 123, 223 и 845. Все последующие номера в строке программа не замечает, хотя и аварийных сообщений не выдает. В чем же дело?
Причина – в процедуре Readln. До сих пор мы пользовались ею для чтения строк и горя не знали. Но числа – иное дело. Приглашаю вас мысленно проследить за позицией чтения в ходе просмотра нашей БД (рис. 66). Невидимые признаки конца строки обозначены на рисунке условными символами Eoln (это пара символов с кодами 13 и 10).
Рис.66 – Продвижение позиции чтения процедурой Readln
После того, как Reset установит позицию чтения в начало файла, процедура Readln прочитает первое число. Чтение идет цифра за цифрой, пока не встретится любой символ, отличный от неё, например, пробел или конец строки. Проглотив таким образом первое число, процедура Readln продвинет позицию чтения в начало следующей строки, пропуская при этом все, что расположено до конца текущей. Вот в чем дело! Не зря к названию процедуры прилепился суффикс «LN» (сокращенное от Line – «строка»). Источник проблемы ясен: процедура Readln не подходит для чтения нескольких чисел в строке. Где же выход?
Спокойно, друзья, в Паскале заготовлено все! Познакомьтесь с процедурой Read (без суффикса), которая почти не отличается от своей «сестренки» – принимает те же параметры и читает те же данные. Но при этом самовольно не продвигает позицию чтения в начало следующей строки. А нам того и нужно! Продвижение позиции чтения процедурой Read показано на рис. 67.
Рис.67 – Продвижение позиции чтения процедурой Read
После чтения каждого числа позиция продвигается за это число и остается там. Следующий вызов процедуры прочитает очередное число в этой же строке и так далее, пока не будет достигнут конец строки. А потом? Потом позиция сдвинется в начало следующей строки, и чтение продолжится тем же чередом до конца файла.
Итак, решение найдено, и теперь для правильной работы программы надо лишь удалить суффикс в имени процедуры, то есть заменить вызов
Readln(aFile, N);
на вызов
Read(aFile, N);
Внесите это исправление в программу, сохраните её под именем «P_29_2» и проверьте, работает ли она.
Предвижу законный вопрос: к чему в языке две похожие процедуры, нельзя ли обойтись только Read? Нет, нельзя, – процедура Readln незаменима при построчной обработке файлов, и очень скоро вы в этом убедитесь.
Итоги
• База данных – это организованное хранилище информации, приспособленное для быстрого её поиска. Простейшую базу данных можно создать редактором текста.
• Перед поиском данных в текстовом файле, надо установить позицию чтения в начало файла процедурой Reset.
• Процедура Readln после чтения затребованных данных продвигает позицию чтения в начало следующей строки. При этом все непрочитанные данные в текущей строке пропускаются.
• Процедура Read после чтения затребованных данных продвигает позицию чтения за последний прочитанный элемент. Она подходит для последовательного чтения данных без учета разбивки на строки.
А слабо?
А) Напишите программу для преобразования второго варианта базы данных «Police.txt» (с несколькими числами в строке) в первый вариант (по одному числу в строке). Или слабо?
Б) Можно ли в решении предыдущей задачи назначить одно и то же имя как входному, так и выходному файлам? Испытайте на практике.
Глава 30
Журнальная история
Статистика знает все?
Давно ли вы заглядывали в классный журнал? Хорошо бы делать это раньше своих родителей. Ах, если бы журнал можно было и править!.. Нет, я не подбиваю вас подтирать оценки! Мы всего лишь подвергнем журнал статистической обработке. Статистика – это наука, находящая закономерности в массе данных. Она как тот холм, взобравшись на который, за деревьями видишь лес. Нужен пример? Пожалуйста.
В некой школе некоторого царства-государства для сравнения учеников и классов учредили рейтинги. Что такое рейтинг? – это вроде места в турнирной таблице. Чем выше рейтинг, тем сильнее спортсмен или команда, то есть ученик или класс. Определять рейтинг условились по средней оценке ученика или всего класса. Так, совокупность многих оценок заменялась одним числом – средним баллом. Когда вместо десятков чисел получаешь одно, – это и есть плод статистической обработки.
Вычисление средних оценок возложили на компьютер, заказав для этого программу. Входные данные для нее извлекались из журнала, который велся в виде текстового файла. Вот как выглядел входной файл, то есть классный журнал.
Акулова 3 5 4
Быков 5 5 5 5
Воронов 4 5 5 4
Галкина 3 4 3
Крокодилкин 4 3
А вот что получалось после обработки его упомянутой программой.
Номер Фамилия Количество Сумма Средний
оценок баллов балл
1 Акулова 3 12 4.0
2 Быков 4 20 5.0
3 Волков 4 18 4.5
4 Галкина 3 10 3.3
5 Крокодилкин 2 7 3.5
Стало быть, средний балл вычислялся как частное от деления суммы баллов на количество оценок, а результат записывался с одним знаком после запятой.
И все было хорошо, пока вирусная атака не уничтожила бесценную программу. А где распечатка исходника? Увы, к тому времени её погрызли мыши! Друзья, теперь надежда только на вас, выручайте школу!
Строим планы
С первого взгляда на задачу ясно: входной файл надо обрабатывать построчно, выбирая из каждой строки данные двух типов: строковые – фамилии учеников, и числа – их оценки. Это не так просто, как может показаться, а потому решать задачу будем в два счёта. На первом этапе упростим её, оставив во входном файле лишь оценки учеников, а полное решение отложим до следующей главы. Входной файл без фамилий будет теперь таким.
3 5 4
5 5 5 5
4 5 5 4
3 4 3
4 3
А в результате обработки мы должны получить такой выходной файл.
Номер Количество Сумма Средний
оценок баллов балл
1 3 12 4.0
2 4 20 5.0
3 4 18 4.5
4 3 10 3.3
5 2 7 3.5
Набросаем план предстоящего сражения, то есть блок-схемы алгоритмов. На рис. 68 показан алгоритм главной программы. Он очень похож на тот, что применялся при шифровании текста, и это объяснимо: и там, и здесь выполняется построчная обработка файла.
Рис.68 – Алгоритм главной программы
Рванув со старта, программа открывает входной файл, создает выходной и пишет туда заголовок таблицы – так называемую шапку. По окончании обработки оба файла будут закрыты. В этом алгоритме предусмотрен также и подсчет строк входного файла, необходимый для нумерации учеников в выходном файле.
Разобравшись с главной программой, сосредоточимся на обработке отдельной строки. Здесь заметно сходство со вторым вариантом полицейской базы данных (глава 29). И там, и тут читается ряд чисел, размещенных в одной строке. Но если в полицейской программе нам было безразлично, где кончается строка, то теперь иное дело, – ведь на следующей строке расположены оценки другого ученика! Нужен признак, сообщающий о достижении конца читаемой строки. Где его взять?
Ну, вы же понимаете, – в Паскале предусмотрено все! Познакомьтесь с функцией булевого типа по имени EoLn (от английского End of Line, что значит «конец строки»). Заголовок этой функции выглядит так:
function Eoln(var aFile: text): boolean;
Функция принимает параметр – ссылку на текстовый файл – и возвращает TRUE, если позиция чтения в этом файле достигла конца строки. Она похожа на функцию Eof, проверяющую достижение конца файла. Исследуем функцию следующей программкой.
{– Программа для исследование функции Eoln –}
var F: text; N: integer;
begin
Assign(F, 'Police.txt'); Reset(F);
while not Eof(F) do begin
Read(F, N); { чтение числа }
Writeln(N, ' – ', Eoln(F)); { печать признака конца строки }
end;
Close(F); Readln;
end.
Здесь из файла «Police.txt» читаются все числа, при этом печатаются и сами числа, и признак конца строки. Предположим, файл «Police.txt» содержал такие строки.
1 2 3
10 20 30
100 200 300
Тогда на экране явится вот что.
1 – FALSE
2 – FALSE
3 – TRUE
10 – FALSE
20 – FALSE
30 – TRUE
100 – FALSE
200 – FALSE
300 – TRUE
Как видите, после чтения последнего числа в строке признак её окончания равен TRUE.
Теперь, когда мы нащупали конец строки, соорудим алгоритм обработки одной строчки входного файла (рис. 69).
Рис.69 – Блок-схема обработки одной строки входного файла
Основу алгоритма составляет цикл чтения чисел, в ходе которого наращиваются счетчик оценок и их сумма. На входе в цикл и счетчик, и сумма очищаются, то есть, загружаются нулями. Выход из цикла происходит при достижении конца строки, и тогда в бой вступает условный оператор. Он исследует счетчик оценок, и, если оценок в строке не было, выводит в выходной файл сообщение «ученик не аттестован», а иначе печатает средний балл.
Кстати, годится ли для чтения строки оператор цикла REPEAT-UNTIL? Правильный ответ – нет. Если текущая строка окажется пустой, следующая оценка прочитается уже на следующей строке, а это не то, что нам нужно! Оператор WHILE – единственно правильное решение.
Барабаним по клавишам
Теперь все готово для сочинения задуманной программы «P_30_1», ниже показан её текст. В начале программы объявлены три глобальные переменные: две – для доступа к входному и выходному файлам, и одна – для подсчета читаемых строк. Поскольку эти переменные объявлены перед процедурой обработки строки HandleString, то будут видны и в этой процедуре. Поэтому передавать содержащиеся в них данные через параметры здесь не обязательно (но возможно). Таким образом, мы передаем данные в процедуру через глобальные переменные, – в небольших программах это допустимо. Только не злоупотребляйте этим приемом, иначе в сложных программах запутаетесь.
Заглянем теперь внутрь процедуры HandleString. Кстати, её название составлено из двух слов: Handle – «обработка», и String – «строка». Процедура не принимает параметров, поскольку все необходимые данные получает через глобальные переменные. Обратите внимание на вычисление среднего балла:
Rating:= Sum div Cnt;
Сумма баллов делится на счетчик оценок; в этой операции участвуют целочисленные переменные, а результат деления тоже получится целым. Стало быть, дробную часть рейтинга мы теряем, – к решению этой проблемы вернемся позже.
А что сказать о главной программе? Она работает по ранее рассмотренному алгоритму. По крайней мере, сейчас нам так кажется.
{ P_30_1 – обработка журнала, первый вариант }
{– Глобальные переменные –}
var InFile, OutFile : text; { входной и выходной файлы }
Counter: integer; { счетчик строк входного файла }
{– Процедура обработки одной строки –}
procedure HandleString;
var N : integer; { оценка, прочитанная из файла }
Cnt: integer; { количество оценок }
Sum: integer; { сумма баллов }
Rating: integer; { средний балл }
begin
Sum:=0; Cnt:=0; { очищаем накопитель и счетчик оценок }
while not Eoln(InFile) do begin { пока не конец строки }
Read(InFile, N); { читаем оценку в переменную N }
Sum:= Sum+N; { накапливаем сумму баллов }
Cnt:= Cnt+1; { наращиваем счетчик оценок }
end;
if Cnt>0
then begin { если оценки были }
Rating:= Sum div Cnt;
Writeln(OutFile, Counter, Cnt, Sum, Rating);
end
else { а если оценок не было }
Writeln(OutFile, Counter, ' Ученик не аттестован');
end;
{– Главная программа –}
begin
Counter:= 0; { обнуляем счетчик строк }
{ открываем входной файл }
Assign(InFile,'P_30_1.in'); Reset(InFile);
{ создаем выходной файл }
Assign(OutFile,' P_30_1.out'); Rewrite(OutFile);
{ выводим шапку таблицы }
Writeln(OutFile, 'Номер Количество Сумма Средний');
Writeln(OutFile, 'ученика оценок баллов балл');
{ пока не конец входного файла… }
while not Eof(InFile) do begin
Counter:= Counter+1; { наращиваем счетчик строк }
HandleString; { обрабатываем строку }
end;
{ закрываем оба файла }
Close(InFile); Close(OutFile);
end.
Скомпилировали программу? Тогда подготовьте входной файл с оценками учеников (без фамилий). Назовите его «P_30_1.in» и сохраните, как обычно, в рабочем каталоге. Можно запускать? В общем-то, да. Но будьте настороже, – ошибки караулят нас на каждом шагу! Возьмите за правило первый прогон своих программ выполнять в пошаговом режиме. Поступим так и в этот раз.
Первый блин
Переключитесь в окно программы и для исполнения одного шага нажмите клавишу F7. Продолжайте нажимать её, наблюдая за ходом выполнения операторов. При желании добавьте в окно обзора переменных «Watch» глобальную переменную Counter.
После нескольких шагов вы попадете внутрь процедуры HandleString и благополучно пройдете по ней. На следующем цикле главной программы вновь войдете туда же, но теперь вас ждут «чудеса». Во-первых, цикл
while not Eoln(InFile)
уже не выполняется ни разу, и в выходной файл пишется «Ученик не аттестован». Ещё загадочней другой фокус: не выполняется условие выхода из цикла в главной программе.
while not Eof(InFile)
Обработав несколько строк, программа почему-то продолжает фанатично работать и дальше; она, как говорится, зациклилась. Если бы мы запустили её сразу в непрерывном режиме, то захламили бы выходным файлом весь диск! Пришлось бы аварийно снимать программу диспетчером задач. Ясно, что где-то притаилась ошибка, и надо прервать выполнение программы. Сделать это в пошаговом режиме несложно, – нажмите комбинацию Ctrl+F2.
Теперь сядем на пенёк и поразмыслим, в чем дело? Ведь первый вход в процедуру отработан верно. Вспомните наше исследование функции Eoln: чтение последнего числа в строке устанавливает признак конца строки в TRUE. Значит, при повторном входе в процедуру обработки строки цикл while not Eoln(InFile) не должен выполняться ни разу, – так оно и происходит. Так вот где собака порылась, – мы застряли в конце первой строки!
Этим же объясняется и зацикливание в главной программе, – не проскочив первой строки, нам не достичь конца файла. Виновник найден? – да, и теперь поищем решение проблемы. После обработки строки нам надо всего лишь перескочить с конца текущей строки в начало следующей, ничего при этом не читая. На ум приходит процедура Readln, – ведь она любит это делать. Помните, как подвела она нас во второй версии полицейской базы данных? Зато теперь выручит! Где её вызвать? Сделаем это после выхода из процедуры HandleString, то есть в цикле главной программы. Теперь главный цикл будет выглядеть так:
while not Eof(InFile) do begin
Counter:= Counter+1; { наращиваем счетчик строк }
HandleString; { обрабатываем строку }
Readln(InFile); { переход на следующую строку }
end;
Процедуре Readln передана лишь файловая переменная InFile, поскольку никаких данных ей читать не надо. Стало быть, для исправления программы добавим лишь один оператор. Сделайте это и запустите программу в пошаговом режиме. Если пара строк будет обработана правильно, запустите её далее в непрерывном режиме.
Блин второй
Запуская программу, не ждите результатов на экране, – программа отработает молча. Для просмотра результатов откройте выходной файл «P_30_1.out». Сделайте это, не выходя из IDE: просто нажмите F3 и укажите имя файла. Вам откроется следующая картина.
Номер Количество Сумма Средний
оценок баллов балл
13124
24205
34184
43103
5273
Что это? Вместо ожидаемых четырех колонок чисел мы видим только одну. Да и числа в ней несуразные! Откуда они взялись? Пробуем разгадать эту головоломку: первая цифра совпадает с порядковым номером строки: 1, 2, 3 и так далее. Вторая равна количеству оценок ученика: 3, 4, 4, 3, 2. Ага, значит, результаты правильные, только «слиплись» в одно число, – между числами нет пробелов. Кто виноват? Нет, не мы с вами, а этот оператор.
Writeln(OutFile, Counter, Cnt, Sum, Rating);
Его параметры разделены запятыми, и потому печатаются подряд, без пробелов. Вставить пробелы можно, например, так:
Writeln(OutFile, Counter,’ ’,Cnt,’ ’,Sum,’ ’, Rating);
Тут между числами печатаются три строковые константы, состоящие из пробелов, они и будут разделять числа между собой. Количество пробелов можно рассчитать заранее или подобрать опытным путем. Но есть лучшее решение.
Спецификатор ширины поля
Лучшее решение дают спецификаторы ширины поля. Это числовые выражения, задающие количество позиций для печати параметра. Их указывают за печатаемым параметром, причем параметр и спецификатор разделяются двоеточием, например:
W := 15;
Writeln(OutFile, Cnt : 10, Sum : W);
Здесь значение переменной Cnt будет напечатано на десяти символьных позициях, а значение переменной Sum – на пятнадцати (соответственно значению W).
Спецификаторы – это дополнительные параметры процедуры печати, придающие красоту выводимым результатам. Когда число требует меньше места, чем задано в спецификаторе, лишние позиции заполнятся пробелами, а нам того и надо. К тому же, спецификатор может выравнивать выводимые числа по левому, или правому краю колонки: положительное его значение выравнивает число по правому краю, а отрицательное – по левому. Спецификаторы применяют и к строковым выражениям.
Для нашего случая я подобрал следующие значения спецификаторов.
Writeln(OutFile, Counter:3, Cnt:13, Sum:14, Rating:12);
Исправьте заодно и этот оператор вывода в файл:
Writeln(OutFile, Counter:3, ' Ученик не аттестован');
Снова запустите программу и проверьте результат. Кстати, если вы не закрывали окно с выходным файлом «P_30_1.out», то по завершении программы IDE сообщит о том, что файл на диске был изменен, – это сделала ваша программа. Но в открытом окне все осталось по-прежнему, потому IDE спрашивает разрешение на обновление окна, – дайте положительный ответ кнопкой «Yes» и переключитесь в окно с файлом «P_30_1.out». Теперь вы увидите вот что.
Номер Количество Сумма Средний
оценок баллов балл
1 3 12 4
2 4 20 5
3 4 18 4
4 3 10 3
5 2 7 3
Это почти идеальный результат. Осталась лишь одна шероховатость, – средний балл не содержит дробной части. Займемся этим вопросом.
«Развесные» числа
Обратимся к строке программы, где вычисляется средний балл.
Rating:= Sum div Cnt;
Здесь одно целое число делится на другое, и результат тоже получается целым. Куда же девается дробная часть? Увы, дробная часть отбрасывается. Куда отбрасывается, не знаю, но она теряется. Поэтому при целочисленном делении получаются, например, такие забавные результаты.
7 div 3 = 2
7 div 4 = 1
7 div 5 = 1
Целые числа потому и целые, что не дают «отколоть» от себя ни крошки. Они как штучный товар. Но средний балл – это «развесной товар», – для него нужны другие числа, и они в Паскале есть.
Я говорю о вещественных числах. В Паскале есть несколько типов для представления таких чисел. Один из них – REAL – родной для Паскаля, поскольку существовал в первой версии языка. Другие добавились с появлением в компьютерах математических сопроцессоров. Для хранения среднего балла воспользуемся типом REAL; с этой целью изменим объявление переменной Rating следующим образом:
var Rating: Real;
Но этого недостаточно. Дело в том, что, если мы оставим формулу
Rating:= Sum div Cnt;
без изменений, то и результат не изменится. Все потому, что операция DIV (от Division – «деление») предназначена только для целых чисел, и дробную часть она всё равно отбросит. Для деления вещественных чисел в Паскале есть другая операция, она записывается косой чертой «/». Значит, упомянутый выше оператор мы должны изменить так:
Rating:= Sum / Cnt;
Вот теперь должно заработать! Запустив новый вариант программы и открыв выходной файл, вы найдете вот что.
Номер Количество Сумма Средний
оценок баллов балл
1 3 12 4.00000000000000E+0000
2 4 20 5.00000000000000E+0000
3 4 18 4.50000000000000E+0000
4 3 10 3.33333333333212E+0000
5 2 7 3.50000000000000E+0000
Что бы это значило? Средний балл считается верно, но печатается очень странными уродливыми числами! Не пугайтесь, перед вами научный формат представления вещественного числа, он удобен для изображения очень маленьких и очень больших чисел. Например, известное физикам и химикам число Авогадро (примерно 6,022140 умноженное на 10 в 23-й степени) изображается как 6.022140E+0023. Но нам этот формат не подходит, и мы заменим его, задав спецификатор ширины поля.
Для вещественных чисел спецификатор состоит из двух частей, разделяемых двоеточием. Первая часть задает общую ширину поля печати (так же, как и для целых чисел), а вторая – количество цифр после запятой (после точки). Чтобы напечатать переменную Rating с одним знаком после точки при общей ширине поля в 12 позиций, нам следует применить такой оператор печати.
Writeln(OutFile, Counter:3, Cnt:13, Sum:14, Rating:12:1);
Теперь вновь запустим программу и полюбуемся на результат.
Номер Количество Сумма Средний
оценок баллов балл
1 3 12 4.0
2 4 20 5.0
3 4 18 4.5
4 3 10 3.3
5 2 7 3.5
Прекрасно! Изрядно потрудившись и одолев ряд ошибок, мы достигли цели! Осталось лишь подытожить завоевания этой главы.
Итоги
• Функция Eoln следит за признаком конца текущей строки, применяется совместно с оператором WHILE.
• Для продвижения позиции чтения в начало следующей строки вызывайте процедуру Readln, указывая лишь один параметр – файловую переменную.
• Данные внутрь процедур и функций можно передавать через глобальные переменные; такой прием допустим для несложных программ.
• Целые числа не содержат дробной части. Для действий с дробными числами применяют вещественные типы, например, Real.
• Для получения дробного результата деления пользуйтесь операцией «/» (косая черта). Операция DIV при делении отбрасывает дробную часть.
• Для ровной печати чисел применяйте спецификаторы ширины поля.
А слабо?
А) Функция Trunc выделяет целую часть вещественного числа, например:
Writeln (Trunc( 12.345 )); { 12 }
Исследуйте её и придумайте способ выделения дробной части вещественного числа. Напишите подходящую функцию и программу для её проверки.
Б) Объясните и проверьте, что напечатает следующая программа.
var N: integer;
begin for N:=1 to 20 do Writeln (’ ’:N, N); end.
В) Сформируйте файл «Numbers.txt», поместив в него 100 случайных чисел в диапазоне от 0 до 999 (некоторые числа могут повторяться). Затем найдите в этом файле: 1) максимальное и минимальное число; 2) сумму всех чисел; 3) среднее арифметическое – напечатайте его с двумя знаками после точки.
Г) Сканирование марсианской поверхности дало файл, содержащий высоту отдельных его точек вдоль одного из направлений, – пусть это будет файл «Numbers.txt» из предыдущей задачи. Найдите точки, где вероятней всего обнаружить марсианскую воду. На следующем ниже рисунке они обозначены буквами W. Программа должна напечатать две колонки: порядковый номер точки относительно начала файла (счет от нуля) и высоту точки (такие точки математики называют локальными минимумами).
Рис. 70 – Рельеф марсианской поверхности
Глава 31
Финал журнальной истории
В предыдущей главе мы поклялись восстановить съеденную мышами программу и отчасти сдержали клятву. Нами решена упрощенная задача – обработка журнала без фамилий учеников, то есть, мы исполнили вычислительную часть проекта. Теперь завершим его, добившись обработки настоящего классного журнала. Требуется, казалось бы, пустяк – прочесть фамилии учеников. Но воспользоваться процедурой Readln, как мы поступили в программе шифрования текста, здесь не получится, – она прочитает всю строку целиком, включая и оценки (которые станут как бы частью фамилии!).
Буква за буквой
Славный литературный герой Остап Бендер по поводу желанного миллиона сказал так: «Я бы взял частями, но мне нужно сразу!». Увы! При чтении фамилий надо проявить терпение. Если не получается сразу, возьмем по частям. Ведь строка фамилии состоит из отдельных букв, – так прочитаем фамилию по буквам! Прочитать букву может все та же процедура Read, например:
var sym : char;
...
Read(InFile, sym); { чтение одного символа }
А фамилию S склеим из отдельных букв:
S:= S + sym;
Разумеется, что здесь нужен цикл, условием выхода из которого будет либо достижение первого пробела, либо достижение конца строки. В этом и состоит основная идея алгоритма, показанного на рис. 71.
Рис.71 – Упрощенный алгоритм побуквенного чтения фамилии
Нелишняя предосторожность
Людям свойственно ошибаться, – даже учителям! В строках журнала (а это текстовый файл) могут оказаться лишние пробелы – как между оценками, так и в начале строки, перед фамилией. И что тогда? – проверьте на практике. При чтении чисел процедура Read «не заметит» лишних пробелов, – она достаточно «умна». Другое дело – показанная выше блок-схема: если перед фамилией обнаружится пробел, то чтение слова завершится досрочно. Стало быть, для правильного чтения фамилии надо пропустить стоящие перед нею пробелы (если они есть). Это улучшение слегка усложнит блок-схему (рис. 72).
Рис.72 – Усовершенствованный алгоритм побуквенного чтения фамилии
Достройка программы
В основу новой версии программы «P_31_1» положим программу «P_30_1». Вам следует, прежде всего, открыть её и сохранить под новым именем. Готово? Тогда приступаем к правке.
Начнем с главной программы, где надо изменить имена входных и выходных файлов (чтобы не путать с похожими файлами предыдущей версии).
Assign(InFile,'Journal2.in'); Reset(InFile);
Assign(OutFile,'Journal2.out'); Rewrite(OutFile);
Позаботьтесь о том, чтобы файл «Journal2.in» был похож на настоящий классный журнал с фамилиями, как о нём сказано в начале 30-й главы.
Второе изменение внесем в процедуру обработки строки HandleString. Здесь объявим ещё одну переменную строкового типа, назовем её Fam, она будет вмещать фамилию ученика.
Fam:= ReadFam; { читаем фамилию }
Разумеется, оператор печати строки тоже будет изменен.
Writeln(OutFile, Counter:3, Fam:18, Cnt:8, Sum:14, Rating:11:1);
Осталось выяснить, что такое ReadFam? Это функция чтения фамилии, которую мы напишем по рассмотренному чуть выше алгоритму (рис. 72). Мой вариант функции таков.
function ReadFam: string;
var sym: char; { очередной символ }
S : string; { накопитель строки }
begin
S:=''; { очистка накопителя строки }
{ чтение символов до первой буквы }
repeat Read(InFile, sym); until Ord(sym)>32;
{ чтение последующих символов }
repeat
s:= s+sym;
if Eoln(InFile) then Break;
Read(InFile, sym);
until not ((Ord(sym)>32));
ReadFam:= S; { возвращаемый результат }
end;
Обратите внимание на сравнение введенного символа с пробелом. Это сравнение можно было бы записать так:
sym <> ’ ’
Но пробел в кавычках трудно разглядеть. Лучше сравнивать код символа с кодом пробела (который равен 32), что и сделано внутри функции.
Испытание
Теперь все готово, запустите программу. Что оказалось в выходном файле «Journal2.out»? Наверное, вот это.
Номер Фамилия Количество Сумма Средний
ученика оценок баллов балл
1 Акулова 3 12 4.0
2 Быков 4 20 5.0
3 Волков 4 18 4.5
4 Галкина 3 10 3.3
5 Крокодилкин 2 7 3.5
Если не считать кривых колонок, неплохо. Кривизну даёт разная длина фамилий учеников. Можно выровнять колонки, вычисляя спецификатор ширины в зависимости от длины фамилии. Или поступить иначе, – дополнить фамилии до одинаковой длины пробелами справа, например:
while Length(Fam) < 12 do Fam:= Fam + Char(32);
Этот оператор уместен после чтения фамилии. Окончательный вариант программы со всеми дополнениями и уточнениями представлен ниже.
{ P_31_1 – Обработка классного журнала, второй этап }
var InFile, OutFile : text; { входной и выходной файлы }
Counter: integer; { счетчик строк в файле }
{– Функция чтения фамилии –}
function ReadFam: string;
var sym: char;
S : string;
begin
s:=''; { очистка накопителя строки }
{ чтение символа до первой буквы }
