Название книги в оригинале: Деревенец Олег Виленович. Песни о Паскале

A- A A+ White background Book background Black background

На главную » Деревенец Олег Виленович » Песни о Паскале.





Читать онлайн Песни о Паскале. Деревенец Олег Виленович.

Олег Деревенец

Песни о Паскале

 Сделать закладку на этом месте книги

Редакция 12.10

от 2017-01-10

© Деревенец Олег Виленович, 2010-2017, все права защищены https://oleg.derevenets.com

Условия использования





Произведение «Песни о Паскале» созданное автором по имени Деревенец Олег Виленович, публикуется на условиях лицензии Creative Commons Attribution-NonCommercial-NoDerivs (Атрибуция – Некоммерческое использование – Без производных произведений ) 3.0 Непортированная.

Разрешения, выходящие за рамки данной лицензии, могут быть доступны на странице https://oleg.derevenets.com.

Только для взрослых

 Сделать закладку на этом месте книги

Конечной целью образования должно быть искусство конструктивного мышления.

Никлаус Вирт

Ученик – это не сосуд, который надо наполнить, а факел, который надо зажечь.

Плутарх

Десять лет спустя

«Не верю!» — отмахнулся бы я, если б не видел это своими глазами. Меня можно понять, как и тех, кто, барахтаясь в мутных волнах 90-х, не помышлял о дальних планах. Но оптимисты неистребимы! Они устроили тогда в нашем городе конкурс юных программистов — KidSoft. Зрители тех состязаний терялись в догадках: где «желторотики» нахватались компьютерных премудростей? Сотворенных ими программ не постыдились бы и профессионалы! А ведь найти приличный компьютер тогда было не проще, чем хороший учебник программирования. «Что же будет лет эдак через 10-15, — спрашивал я себя, — когда компьютер войдет в каждый дом?». И мнились мне колонны юных гениев, бодро шагающие на свой конкурс.

Через годы судьба вновь свела меня с «компьютерной» молодежью. Наблюдая участников олимпиад, я невольно поверял свой прогноз. Во многом он оправдался: компьютер стал предметом быта, книжные полки ломятся от компьютерной литературы, а информатикой пичкают едва ли не с детского сада. Но где колонны юных гениев? Я их не вижу! Да, конечно, «кое-кто, кое-где у нас порой…». И все же мне видится, что интерес молодежи к программированию несколько увял. Логика, ау! Где ты? Привыкнув следовать твоим законам, я поклялся раскрыть эту тайну.


Чему нас учат семья и школа?

Интернет и другие источники привели меня к парадоксальному выводу: интерес подростков к программированию угасал с развитием компьютерных технологий! Судите сами: чем мог заняться способный мальчишка в компании с каким-нибудь примитивным «синклером» начала 90-х? Наскучив двумя или тремя простенькими игрушками, он, в конце концов, брался за программирование и лепил ещё одну. А сейчас? Об «игрунах» молчу, поскольку даже творческий человек найдет в компьютере уйму интересного!

А школа, чему она учит? Поспешая за техническим прогрессом, школа пытается втиснуть в детскую голову едва ли не все достижения информационных технологий. Сомневаясь в разумности этой попытки, согласен все же с тем, что компьютерная грамотность стала ныне грамотностью номер два. Но теперь она не связана с программированием: в массе востребованы офисные приложения, электронная почта, Интернет.

Спорить с этим трудно, и я бы не стал. Но как быть юным программистам? Или эта профессия отмирает, и технологии будут развивать без них? Смешной вопрос, но иным не до смеха. Ведь в школе с программистами заниматься некому и некогда, – эстафету передали в ВУЗ. А там, на профильных факультетах, давно уже бьют в набат: познания новобранцев в программировании ничтожны, и обучать их приходится с азов.

Что в сухом остатке моих изысканий? Нужны ли нам хорошие программисты? – разумеется. Есть желающие ими стать? – конечно! Но нет школы, которая их научит. Так пусть вундеркинды учатся сами, почему нет? Вот компьютер, вот полка с учебниками, – полный вперед! Так ли это? Присев на корточки, я вошёл в положение юного нахала, дерзнувшего двинуться этой тропой.


Крошка сын к отцу пришел

Итак, я стал мальчишкой лет двенадцати. В доме есть компьютер, за который изредка садятся и родители. Но, главным образом, – это мой инструмент. Мне многое по плечу: скопировать файлы или напечатать что-то? – запросто! Признаюсь, однако, что игрушки надоели, и хочется освоить программирование. Увы! Родители в этом не разбираются, программистов среди друзей нет, а учителю информатики возиться со мной недосуг. Ладно, попробую сам. Раздобыв пару книжек и ободрившись примером Ломоносова, отважно берусь за дело.

Прикусив от старания язык, я терпеливо «сверлю» страницу за страницей. Вот алфавит языка, идентификаторы, константы, выражения… Кое-что понятно, но… Мамочка! когда же я напишу хоть простенькую программку? Открыв другую книгу, нахожу то же самое – подробное описание языка программирования, или так называемую «теорию». Убойная доза теории свалит с копыт даже крепкую казачью лошадь, – так устоит ли мой нежный организм? Энтузиазм вянет. «Нет, – думаю, – новый Ломоносов подождет, может, в школе когда-нибудь научат». Что будет в школе, вы уже знаете.

Так может, мальчишке попались плохие книги? Не думаю, хорошие учебники встречаются, некоторые написаны основательно. «И все же, все же, все же…». Все же книги эти адресованы другому читателю; по сути это технические руководства, рассчитанные на закаленных, зрелых бойцов. Как же обучать юнцов?


Азбучные истины

Тогда я мысленно приложил типовой учебник программиста к преподаванию грамоты в первом классе. По замыслу такого учебника, прежде, чем нацарапать «мама мыла раму», первоклашка обязан не только выучить все буквы, но и познать премудрости орфографии, синтаксиса, склонения, спряжения и так далее. Абсурд, не так ли? Ведь я отлично помню, что слово «мама» я вывел, постигнув лишь две буквы. Полагаю, что русский язык не проще языка программирования. И если для первого удалось создать азбуку – чудную вещь! – то нельзя ли чем-то подобным снабдить начинающих программистов? Явилась мысль сделать обратную проекцию и создать «букварь» для программиста. На мой взгляд, такой «букварь» должен строиться на следующих принципах.

Постепенность. Излагать материал следует мелкими, легко постигаемыми порциями. Высота одолеваемых учеником «ступенек» не должна вызывать ощущения тупика, – маленький успех окрыляет, вселяя уверенность.

Практичность. Программирование – инженерная наука. Теория и практика здесь неразделимы, «пропитывают» друг друга, – ученик не должен ощущать границ между ними. Букварь программиста должен сочетать в себе учебник и хрестоматию. Примеры программ должны быть либо простыми, либо очень простыми (по крайней мере, на первых порах). Необходимо показать полные решения задач с разъяснениями, – «учились бы, на старших глядя».

Поправка на возраст. Сюжеты задач в букваре должны учитывать психологию подростка, а он склонен учиться играючи. Хорошо, если примеры похожи на настоящие «взрослые» проекты (разумеется, упрощенные). Непоседу не увлечешь задачей в роде «посчитать по формуле такой то» или «найти сумму элементов массива». А вот полицейская база данных или экзаменующая программа – это серьезно! Разжечь аппетит юного инженера – едва ли не главная цель обучения.

Маловажное – за борт! От изложения некоторых второстепенных деталей языка лучше воздержаться. Например, можно «забыть» о записях с вариантами и не вспоминать о типизированных файлах. Не отвлекая внимания на эти детали, сосредоточиться на главном. Усвоив это главное, ученик доберёт остальное из «взрослых» учебников.

Вот, пожалуй, и все. В идеале такой букварь будет и самоучителем для подростка, и конспектом для преподавателя компьютерного кружка.


Что я могу ещё сказать?

Итак, цель поставлена, но достигнута ли? – судить читателям. Вкратце содержание книги таково.

В главах с 1-й по 4-ю после краткой обзорной информации даны практические рекомендации для подготовки рабочего места. Далее все подносимые порции теории немедленно воплощаются на практике.

В главах с 5-й по 31-ю рассматриваются простые типы данных и базовые алгоритмические структуры. Здесь же рассказано о текстовых файлах и даются основные сведения об организации среды программирования.

В главах с 32 по 35 подводится теоретическая черта под пройденным материалом и закладывается фундамент для перехода к сложным типам данных.

Главы с 36 по 58 повествуют о сложных типах данных и связанных с ними алгоритмах. Здесь рассмотрены множества, массивы, записи и динамические структуры.

В главах 59 и 60 раскрыт секрет разработки многофайловых проектов, а глава 61 знакомит с принципами объектно-ориентированного программирования.

Последняя 62-я глава – это попытка заглянуть в будущее и указать читателю дальнейшие цели и пути их достижения.

Полагая, что книга будет, на какое-то время, единственной помощницей новичка, автор счел нелишним включить несколько справочных приложений.

Итак, отойдя от общепринятого порядка изложения теории, я стремился вовлечь читателя в активное осмысление конструкций языка, приглашая его к соавторству с Никлаусом Виртом. «Почему в языке сделано именно так, а не иначе?» – этот вопрос то и дело встает перед учащимся. Решая задачи, он видит, что элементы языка не с потолка свалились, а придуманы для решения типовых проблем. Отсюда следует порядок изложения: 1) проблема, 2) размышление, 3) решение. Сначала ставится задача. Затем обсуждается, как её решить уже известными средствами языка, или почему её нельзя решить этими средствами. После этого даётся надлежащая порция теории, и приводится решение либо с новым применением уже известных конструкций языка, либо с привлечением новой конструкции. Напоследок подводится теоретический итог очередной главы. Так теория с практикой следуют рука об руку.

Несладко быть в шкуре новичка: там и сям натыкаешься на проблемы! Автор снабдил почти все решения полными листингами работающих программ с подробными пояснениями. Кому то они покажутся избыточными, назойливыми. Но согласится ли с этим паренек, корпящий над книгой где-нибудь в глухом поселке? Ведь для него, одинокого бойца, любая «непонятка» порой вырастает в неодолимую преграду!


Благодарности

Я признателен всем, кто высказался о «Песнях» на форумах и в личной переписке, — мы работали над книгой вместе! Особо благодарю форум freepascal.ru и моих читателей Артёма Проскурнёва и Владислава Джавадова, подаривших мне массу полезных советов.

Книга в форматах FB2 и HTML появилась трудами моих добровольных помощников. Один из них – Олег Авилов – подтолкнул нас к этой работе, а также сотворил новую обложку. Но основной вклад внёс пожелавший остаться неизвестным житель таёжного посёлка, затерянного в магаданских просторах! Скрипты уважаемого «navd» – так он назвал себя – сотворили чудеса!

Пишите, мой адрес все тот же: [email protected]

Свежую редакцию книги и сопутствующие файлы можно скачать здесь:

https://oleg.derevenets.com

Детям до 16–ти

 Сделать закладку на этом месте книги

«У меня есть мечта!» – признался один известный человек. А у кого её нет? Вы тоже мечтаете, и я знаю, о чем. В детстве мне хотелось поскорее вырасти, и я завидовал взрослым: никто им не указ, делай, что хочешь! Вы мечтаете о том же? Но как стать большим раньше назначенного природой срока? Наклеить усы и бороду? Пробовал, – не помогает. Или прибегнуть к «сильным» средствам: крепким напиткам и табаку? Даже не пытайтесь, – вы постареете, не повзрослев!

Со временем дошло до меня, что взрослый – это тот, кто владеет профессией и занят полезным делом. Стало быть, став профессионалом, можно повзрослеть? Хороших профессий полно, выбирайте любую. А не стать ли вам программистом? «В моем возрасте? Возможно ли?» – усомнятся некоторые. Так вот вам зеркало, смотрите, кто там? Сметливый человек с цепкой памятью и страстным желанием поскорее созреть! Кому, как не вам, взяться за это дело?

Согласны? Тогда уточним, кто такой программист. Некоторые склонны считать программистом любого, кто работает с компьютером. Питая глубокое уважение ко всем мастерам разных сфер: системным администраторам, дизайнерам сайтов и многим другим, мы не станем величать их программистами. Нет, программист – это волшебник, оживляющий бездыханные железки. Порой их называют хакерами или кодировщиками. Слово «хакер» мне не по душе, поскольку пристало к взломщикам программ и паролей. А кодирование? Это всего лишь часть работы программиста, состоящая в написании программы по готовому алгоритму. Нет, настоящий программист – не презренный «кодировщик», он видит шире и копает глубже.

Итак, я зову вас в программисты-профессионалы, а это значит, что с «чайниками» нам не по пути. Чем довольствуется «чайник»? – верхушками знаний, а мы устремимся к вершинам. И, пускай, эти вершины пока далеки, мы не помчимся за быстрым результатом, прыгая через три ступеньки. Нет, наши шаги будут основательными, а обретенные знания глубокими, – «небоскреб» вашего будущего должен опираться на прочный фундамент!

Со мной вы изучите язык программирования Паскаль – один из самых красивых и полезных. Он и его потомки – Модула, Ада, Оберон – неспроста слывут самыми надежными, – оборонка, космос и авиация предпочитают эти языки. Идеи, из которых они сотканы, благотворно повлияли на новейшее программирование. Прошедшего школу Паскаля отличает ясный, экономный и надежный стиль письма. Манера эта проявляется и тогда, когда программист пишет на иных языках.

Овладев Паскалем, вы откроете себе много дорог. Одна из них – основанная на Паскале мощная визуальная среда программирования Delphi. Другое направление – школьные олимпиады по программированию, где большинство участников тоже пишут на этом языке. В конце концов, Паскаль облегчит вам изучение и других языков. Так, освоение Паскаля станет первым и самым важным шагом к вашей мечте!

Глава 1

Путь далек у нас с тобою…

 Сделать закладку на этом месте книги




Итак, вы из тех смельчаков, что готовы карабкаться со мной на вершину по имени Паскаль? Я помогу вам, с чего начнем? Соберем «рюкзачок» на дорогу, – сложим в него то, без чего не обойтись в этом путешествии.


Компьютер

Без чего нам не обойтись? «Без компьютера!» – никто не сомневался в столь разумном ответе. Программист без компьютера – все равно, что всадник без коня или мушкетер без шпаги! Однако ж, какой компьютер нам сгодится? Ведь мощь этих машин стремительно растет, удваиваясь каждые два года. Каковы наши требования? К счастью, они скромны, – нам подойдет любой IBM–подобный компьютер. Найти «станок», выпущенный в прошлом веке теперь можно разве что на пыльном чердаке. Но даже такой «старичок» нам бы вполне сгодился. Поскольку большинство компьютеров оснащены одной из версий операционной системы Windows, я учту это в ходе дальнейших пояснений.


Компилятор

Хорошо, компьютером обзавелись, что еще? Нужна специальная программа – компилятор, переводящая программу из текстового вида в исполняемый файл. Существуют несколько компиляторов с языка Паскаль, их можно взять в школе, либо скачать в Интернете. В 4-й главе я расскажу о том, как установить и настроить компиляторы в операционной системе Windows.


Личный багаж

Бросив в «рюкзак» компьютер с компилятором, осмотрим теперь ваш «личный багаж», – намекаю на ваши познания, конечно. Ведь компьютер – хитрая штука, насколько вы владеете им? Что вам известно о файловой системе? Умеете ли искать, копировать и переименовывать файлы? А создавать каталоги (папки) и набирать несложный текст вам по силам? Хотя бы в таком простом редакторе как Notepad (блокнот). Другими словами, от вас требуются навыки начинающего пользователя. Я не буду тратить бумагу на разъяснение этих премудростей. Если же вы слабо владеете компьютером, обратитесь к старшим.

Некоторые ставят программистов в один ряд с математиками, подозревая у тех и других математический склад ума. Отчасти это так, и в своей работе программисты нередко используют сведения из математики. А что требуется в этой части от вас? Пока ничего, что выходит за рамки школьной программы, – знаний 3-го класса вполне достаточно. Если же вам знакомы основы алгебры, то есть вы понимаете, что любое число можно обозначить буквой, тогда… тогда считайте себя профессором!

В освоении языка Паскаль вам помог бы другой язык – английский. Нет, он не лучше других. Но так уж вышло, что компьютеры и программирование зародились в англоязычных странах, и с тех пор английский стал языком тех, кто по роду занятий связан с компьютерами. Я допускаю, что вы пока не сильны в английском, или изучаете другой иностранный язык. Тогда следует знать хотя бы буквы латинского алфавита. По ходу изложения я буду переводить попадающиеся там и сям английские слова, и пояснять их. Но и сами не сидите, сложа руки! Положите под руку англо-русский словарь (или установите словарь на компьютере) и переводите все непонятные слова. Тогда через несколько месяцев вам будут доступны статьи на компьютерные темы. Короче – налегайте на английский!

Что еще? Программисту (не кодеру!) необходимо широкое образование, – этого требует специальность. Не пренебрегайте школьными предметами, в жизни все пригодится!


Компьютерная литература

В этой книге достаточно сведений для усвоения азов программирования. Однако, сосредоточившись на разъяснении простых вещей, я сознательно промолчал о некоторых средствах Паскаля. Со временем вас заинтересуют и другие возможности языка, и тогда вы откроете книги для подготовленных читателей. Названия некоторых из них найдете в списке литературы (библиография в конце книги). Среди ресурсов Интернета новичкам я рекомендую эти:

https://freepascal.ru – форум и много полезной информации;

https://ptaskbook.com/ru/tasks/index.php – подборка простых задач для начинающих.

В 62-й главе приведен ещё ряд ссылок для тех, кто заинтересуется олимпиадным программированием и углубленным изучением алгоритмов.


В здоровом теле – здоровый дух

Некоторые фантасты рисовали людей будущего с огромной головой и ниточками вместо рук и ног. Кажется, что компьютерные фанаты, сутками молящиеся на своих «идолов», подтверждают это предсказание. Неужели фантасты правы? Вы согласны стать колобком с висящими ниточками? Нет? Так соблюдайте меру, – свежий воздух и спорт сохранят силу серых клеточек вашего мозга. «В здоровом теле – здоровый дух» – это ещё древние греки знали.


Вместе весело шагать по просторам!

Хорошо заниматься программированием с друзьями! Товарищей можно найти где угодно: в школе, во дворе, в Интернете. А если кому-то из них потребовалась помощь? Неужели откажете? Ведь лучший способ научиться самому – это учить других! Помогайте друзьям, и тогда точно станете взрослыми!


Повторение – мать учения

В сложных вопросах не разобраться сходу, – так уж устроен наш мозг, что требует времени на усвоение нового. Но, порой случается и наоборот: кажется, что все ясно, однако при повторном чтении проявляются новые детали, и знакомые предметы видятся с иной стороны. Не забывайте, что повторение – мать учения!


Соглашения

Некоторые слова этой книги будут выделены особыми шрифтами, вот примеры таких выделений:

Borland – особо выделенный текст, а также названия фирм, программных продуктов и т.п.;
«File Name» – имена файлов и каталогов;
Begin – служебные слова языка программирования (идентификаторы).
F9 – название пунктов меню и горячих клавиш

Место хранения дисковых файлов я буду называть каталогом или папкой. В некоторых книгах встречается термин «директория», который означает то же самое.


Итоги

В конце каждой главы подводятся краткие итоги сказанному. Сейчас подведем первые итоги и двинемся дальше.

• Изучать программирование мы будем на практике, – для этого вам нужен любой персональный компьютер с операционной системой Windows.

• Для формирования программ потребуется компилятор – программа, преобразующая текст в исполняемый файл.

• От вас требуются, по крайней мере, знания и навыки начинающего пользователя компьютера, а также знание букв латинского алфавита.

• По мере профессионального роста вам не обойтись без дополнительной литературы по программированию.

• Крепите свое здоровье и помогайте друзьям!

Глава 2

Вместо теории

 Сделать закладку на этом месте книги




Жаль, что вы не застали компьютеров первых поколений! Тогда они назывались ЭВМ – электронные вычислительные машины, – слово «компьютер» ещё не было в ходу. ЭВМ помещались в залах солидных размеров, – уж машины так машины, было на что посмотреть! Вход в эти дворцы охраняла угрюмая стража, отсекавшая тех, кто не сдал экзамен по так называемой теории. Иначе говоря, чтобы сесть за ЭВМ, надо было сначала изучить язык программирования и сдать экзамен по нему. Это суровое требование объяснялось тем, что на одну машину рвались сотни пользователей. Потому машинное время ценилось на вес золота, – уж если добрался до ЭВМ, так занимайся делом, а не барабань без ума по клавишам!

Теперь не то, и нравы смягчились: вас пускают за компьютер, не экзаменуя по теории. Но значит ли это, что теория не нужна? — нет. Однако изучать теорию приятней и полезней на практике: мы будем создавать работающие программы. Много программ. Вижу, как вы прыгнули за компьютер и в нетерпении потираете ладошки. Ой, как я вас понимаю! Но ради будущих успехов потерпите до следующей главы. Сейчас я приоткрою завесу тайны, о которой так загадочно молчат взрослые. Не осознав некоторых вещей, невозможно двигаться дальше.


Миф о думающих машинах

Миф – это красивая выдумка, сказка. Компьютеры породили миф о думающих машинах. Ну как отказать в интеллекте этим чудесным созданиям? Восхищение не искушенного в компьютерах человека понятно, но порой приводит к недоразумениям. Вот слышу в новостях: в таком то аэропорту остановлены полеты из-за сбоя управляющих компьютеров. Вероятно, сами компьютеры здесь ни при чем, – современные машины очень надежны, а в особо важных применениях дублируются. И, хотя сбой компьютерной «железки» не исключен, неполадки в системе управления скорей всего на совести программистов. Как ни сложен компьютер, программы, которые он выполняет, в тысячи раз сложнее, а значит и возможность ошибок в них выше. Уверяю вас: компьютер – это всего лишь примитивный автомат, выполняющий команды, заложенные в него программистами.

К чему я клоню? Замыслив стать профессионалом, отбросьте миф о думающих машинах. Компьютер ни о чем не думает, не мечтает, и не спотыкается. Не пеняйте на него, когда ваши программы «захромают», – ищите ошибки у себя.


Загадочные коды

Вам известно, конечно, что исполняемые программы – это файлы с расширением EXE. Заглянем внутрь такого файла, как он устроен? С этой целью я воспользовался программой, подобной Total Commander. Выбрав один из исполняемых файлов, я нажал клавишу F3 – просмотр файла – и увидел следующую картину (рис. 1).






Рис.1 – «Внутренность» исполняемого файла

Что бы это значило? Я, к примеру, здесь ничего не понимаю! Мы видим код программы, который понимает только процессор компьютера. Вероятно, наши человеческие представления о здравом смысле очень далеки от компьютерных! Откуда взялся этот код? Надо ли программистам разбираться в этой тарабарщине? К счастью, большинству из них этого не требуется, – на выручку приходят языки программирования.


Языки программирования и компиляторы

Разумеется, вы слышали об этих языках, к настоящему времени их насчитывают тысячи. Зачем так много? Причины разные. С одной стороны, это объясняется разнообразием решаемых задач, а с другой – течением времени. Многие ранние языки устарели и отмирают, им на смену приходят новые. Однако все их объединяет одно – языки создавались, чтобы избавить человека от программирования на «тарабарском» языке процессора.

Кстати, знаете ли вы китайский язык? А японский или арабский? Теперь представьте себя президентом, принимающим послов этих стран, как вы будете с ними общаться? Очевидно, пригласите переводчиков. В таком же положении находится и процессор компьютера, знающий только свой «тарабарский» язык, а все прочие понимающий через переводчиков. Переводчики – это специальные программы – компиляторы. Правда, в отличие от людей, способных переводить в обе стороны, компиляторы переводят лишь с «человеческого» языка программирования на «тарабарский» язык процессора.

Рассмотрим рис. 2, где представлена упрощенная схема «перевода» с трех языков программирования: Паскаля, Си и Фортрана.






Рис.2 – Схема применения компиляторов

Что мы видим? Работу над программой начинают с подготовки текстового файла, где на выбранном языке записывают порядок действий для решения поставленной задачи. В текстовом файле можно напечатать что угодно – стихи, роман, или программу. Сохранив файл на диске, вы можете в любой момент вновь открыть его, полюбоваться, отредактировать и снова сохранить. Это ещё не программа, а лишь её текст, заготовка. Такой файл называют исходным текстом или, на жаргоне программистов, – «исходником», «сырцом» (русское слово «сырьё» отчасти созвучно английскому Source – «источник»). Исходные файлы показаны на рисунке слева. Вот пример небольшой программки на языке Паскаль.


Var a, b : integer;

Begin

      Readln(a,b);

      Writeln(’a*b = ’, a*b);

End.


Конечно, вам она ещё не понятна. Но, согласитесь, в отличие от загадочного машинного кода, здесь чувствуется возможность что-то понять.

Итак, исходный текст иногда понятен автору программы, но неясен процессору. Потому после подготовки текста программист вызывает компилятор, переводящий текст в код процессора. Для каждого языка существуют свои правила и свой компилятор, вот его-то и надо запустить. Полученный в результате компиляции исполняемый EXE-файл далее «живет своей жизнью»: его можно запускать на выполнение, копировать, проверять на вирусы и заражать ими, – с исходным файлом он уже не связан. А если захочется что-то изменить в программе? Тогда без исходника не обойтись. Надо вернуться к нему, исправить редактором текста и вновь вызвать компилятор для перевода на «тарабарский» язык. Поэтому исходные тексты берегут, как зеницу ока, а то и секретят, если программа имеет коммерческое или военное значение.


Следующий шаг – IDE

Итак, для создания программы нужны, по меньшей мере, два инструмента: редактор текста и компилятор. Но на практике их требуется больше, – ведь без отладчика и справочной системы трудно обойтись. Нужда в нескольких инструментах доставляла когда-то программистам массу неудобств. Приходилось многократно «бегать по кругу», запуская эти программы одну за другой, пока результат не приближался к задуманному.

Но с появлением персональных компьютеров все изменилось: была создана интегрированная среда разработки, или сокращенно ИСР. В компьютерной литературе чаще применяют англоязычное сокращение – IDE (Integrated Development Environment), мы тоже примем его.

Так что же такое IDE? Слово «интегрированная» значит «объединяющая». IDE – это мощная программа, объединяющая в себе и редактор, и компилятор, и отладчик, и справочную систему по языку. С появлением IDE программисты будто пересели с дребезжащей телеги в роскошный автомобиль, оплатив покупку быстрой и качественной работой. В скором времени мы «оседлаем» одну из таких IDE к языку Паскаль.


Итоги

• Отбросьте миф о думающих машинах, – действия компьютера оп


убрать рекламу






ределяются только вами, его ошибки – это ошибки программиста.

• Человек и компьютер «говорят» на разных языках. Процессор компьютера «понимает» лишь язык своих кодов, в котором трудно разобраться человеку.

• Для программирования изобретено много языков. На этих языках человек излагает порядок решения задачи в понятной для него форме.

• Для перевода текстового файла с программой в исполняемый EXE–файл используют программы-компиляторы.

• Современная интегрированная среда разработки (IDE) объединяет в одной программе редактор текста, компилятор, отладчик и справочную систему.

Глава 3

Консольный интерфейс

 Сделать закладку на этом месте книги




Пришло время засучить рукава и сесть за компьютер, по которому вы так истосковались! Хотите ли взглянуть одним глазком в столь желанное завтра? – я покажу вам ваши будущие программы. Не удивляйтесь, мы познакомимся с программами, которых ещё нет. Вернее, ознакомимся не с программами, а с их интерфейсом. Что такое интерфейс? Знакомое слово, не так ли?


Что такое интерфейс?

Интерфейс – это механизм слаженного взаимодействия систем. Например, компьютеров в сети, либо человека и компьютера. В ходе этих отношений человек отправляет компьютеру команды или снабжает его данными, а тот возвращает ему результаты своей работы.

Кому не знаком удобный и красивый оконный интерфейс? Здесь к услугам пользователя даны меню, кнопочки и прочие удобные штучки. А чем отвечает компьютер? Да чем угодно! Ответом могут быть и текст, и картинки, и даже подвижные изображения: фильмы, мультики.

Но сейчас, до сотворения наших первых программ, я познакомлю вас с другим интерфейсом – консольным. Что это за интерфейс, откуда он взялся и чем хорош?


Консольный интерфейс

Первые компьютеры появились не сегодня и не вчера. Тогда не было дисплеев, и пользователь общался с компьютером посредством электрической пишущей машинки – консоли. Отсюда и название интерфейса – консольный. Инженер печатал команды и вводил строчки с данными, а компьютер печатал на бумаге результаты вычислений. Бывшие тогда операционные системы поддерживали лишь консольный интерфейс. Давно минули те времена, но консольный интерфейс, как самый простой и надежный, сохранился и в новейших операционных системах. Именно этим интерфейсом будут обладать наши первые программы.

На первый взгляд, в сравнении с привычными для нас окнами, консольный интерфейс кажется примитивным и неудобным. Вместо щелчков мышью здесь надо вводить команды, набирая на клавиатуре загадочные сочетания из английских букв. Но у каждой медали две стороны, и у консольного интерфейса есть свое достоинство. В чем оно? В том же, в чем и недостаток – в примитивности, а точнее – в простоте. Консольные программы требуют меньше ресурсов компьютера, да и пишутся проще.

Впрочем, консольные операционные системы не исключают развитых оконных интерфейсов. Напомню, что оконные «коммандеры» и «навигаторы» появились в консольной MS–DOS. Со временем и вы научитесь создавать оконные программы.


Прикосновение к консольному интерфейсу

Теперь испытаем консольный интерфейс «на ощупь», обратившись к консольному интерфейсу вашей операционной системы. Однако ж, где найти его среди многочисленных окон? Воспользуйтесь пунктом главного меню, который в ранних версиях Windows назывался «Сеанс MS–DOS», а в более поздних – «Командная строка». Итак, для вызова окна консоли обратитесь в главное меню Windows:

Пуск –> Программы –> Стандартные –> Командная строка

или

Пуск –> Программы –> Стандартные –> Сеанс MS-DOS

Щелчок на этом пункте вызовет окно, похожее на это (рис. 3).






Рис.3 – Окно командной строки (консольное окно)

Здесь выведено название текущей папки с угловой скобкой в конце. Эта строка с «уголком» называется строкой приглашения. Курсор, мигающий после угловой скобки, предлагает вам ввести какую либо из команд операционной системы. Таких команд насчитывается несколько десятков, их полное описание можно найти в справке по Windows. Сейчас испытаем три из них: DIR – распечатка каталога, CLS – очистка экрана, и EXIT – выход из окна консоли.

Напечатайте с позиции курсора слово DIR (большими или маленькими буквами – не важно) и нажмите клавишу Enter. Эта команда заставит систему распечатать информацию о файлах текущей папки. На моем компьютере я увидел вот что (рис. 4).






Рис.4 – Распечатка содержимого текущей папки командой DIR

Выполнив команду, операционная система снова выводит «уголок», приглашая напечатать следующую команду. При желании повторите команду DIR ещё пару раз. А теперь введите команду CLS (очистка экрана), – в результате окно консоли очистится, и будет видна лишь строка приглашения. Наконец подача команды EXIT (выход) закроет консольное окно, и на этом сеанс завершится.

В прежних системах консольное окно можно было переключать в полноэкранный режим, и тогда оно занимало весь экран, а рабочий стол Windows исчезал. Это колдовство срабатывало при нажатии комбинации клавиш Alt+Enter, эта же комбинация возвращала экран в привычный оконный вид Windows. Но, в новейших на этот момент системах (Vista, Windows–7) полноэкранный режим уже не предусмотрен.

Командами консольного интерфейса можно выполнить всё то, что мы делаем через окна: создавать, копировать, удалять и переименовывать файлы, создавать каталоги и т.д. Вот ещё несколько команд, испытайте их:

VER – вывод версии операционной системы;

TREE – распечатка дерева каталогов;

HELP – вывод списка всех команд операционной системы.

В случае ввода неверной команды появится сообщение об ошибке. Здесь на время прервём знакомство с консольным интерфейсом, и вернемся к нему в главе 5, где напишем свою первую программу.


А почему не «окна»?

Читатели, наслышанные о таких мощных визуальных средах программирования как Delphi и Lazarus, обязательно спросят: почему бы нам не воспользоваться этими инструментами? Ведь создавать красивые оконные приложения в том же Delphi очень интересно и не так уж сложно!

Да, творить окошки с кнопочками в IDE Delphi на первый взгляд просто. Но эта простота скрывает непостижимые для новичка механизмы событийного и объектного программирования. А мы ведь договорились не прыгать по верхушкам, – оставим это развлечение «чайникам». Это первое.

Открою и второй умысел. Рассмотренный нами консольный интерфейс годен для ввода и вывода данных не только на экран, но и в текстовые файлы. Профессионал обязательно соприкоснётся с такими файлами, а вы ведь будущий профессионал, не так ли? К тому же, с текстовыми файлами имеют дело и участники школьных олимпиад, в которых вы наверняка пожелаете сразиться.


Итоги

• Интерфейс – это механизм слаженного взаимодействия технических систем, например, двух компьютеров, либо человека и компьютера.

• Консольный интерфейс или интерфейс командной строки – это простой и надежный механизм, используемый для общения человека с компьютером. Он применялся в ранних поколениях ЭВМ, и жив по сей день.

Глава 4

Оружие – к бою!

 Сделать закладку на этом месте книги




Скоро вы напишете свою первую программу, и для этого заточим наше оружие, наш рабочий инструмент – интегрированную среду разработки (IDE). Тогда, подобно воину, вы сможете вмиг обнажать меч двойным щелчком мыши.


Оружейный прилавок

Напомню, что IDE – это мощная программа, объединяющая редактор текста, компилятор, отладчик и справочную систему. Для программирования на Паскале создано несколько таких IDE, рассмотрим кратко наиболее известные из них, а именно:

• Borland Pascal 7.0 (7.1);

• Free Pascal;

• Delphi;

• Pascal ABCNet.

Годятся ли эти IDE для обучения новичка? Каковы их особенности? Не нарушаем ли мы авторских прав? И что выбрать? Рассмотрим их в исторической последовательности.

Borland Pascal – первая среда такого рода, разработанная фирмой Borland ещё в эпоху консольной операционной системы MS–DOS. Последним версиям IDE присвоены номера 7.0 и 7.1. Изделие вышло удобным и надежным, и задало фактический стандарт в данной области (признаюсь, и поныне это мой любимый компилятор).

Delphi – новое детище фирмы Borland, сменившее покинутый ею Borland Pascal. Визуальное программирование – вот главная изюминка этого продукта. Даже не слишком умудренный программист соорудит с помощью Delphi вполне приличные оконные программы.

Free Pascal. Как ни хороши изделия фирмы Borland, их применение ограничено в смысле авторских прав. Потому энтузиасты Паскаля создали свободно распространяемую IDE, очень похожую на Borland Pascal. Проект Free Pascal развивается, и во многом он ушел дальше своего предшественника, конкурируя с Delphi. К настоящему времени выпущены версии для нескольких платформ и операционных систем.

Pascal ABCNet – эта остроумная, удобная и бесплатная IDE создана энтузиастами Южного федерального университета на основе технологии «точка Net», продвигаемой фирмой Microsoft. Буквочки «ABC» намекают на «азбучное», то есть образовательное направление проекта.

Подытожим наш краткий обзор и сделаем выбор. Новичкам будет удобно в среде Pascal ABCNet. Однако её основа – технология «.Net» – не отвечает требованиям школьных олимпиад по информатике (а многие захотят поучаствовать в них). Этим требованиям удовлетворяют другие IDE, которая из них лучше? Визуальная среда Delphi избыточна и сложна для начинающих. Borland Pascal подкупает своей надежностью, но эта IDE слегка устарела. К тому же упомянутые продукты фирмы Borland не бесплатны. Что нам остается? Free Pascal? – выберем его своим основным «оружием».

Но и приверженцев других инструментов я не брошу на произвол судьбы. Примеры из этой книги не привязаны к какой-либо версии языка и сработают в любой из рассмотренных IDE (кроме разве что ABCNet, где часть примеров требует переработки). С установкой, настройкой и особенностями работы в этих средах программирования можно ознакомиться в следующих приложениях:

• Приложение А – Borland Pascal;

• Приложение Б – Delphi;

• Приложение В – Pascal ABCNet.


Установка IDE Free Pascal

Приступим к установке и настройке приглянувшейся нам IDE Free Pascal. Прежде всего, раздобудем её дистрибутив. Если вам доступен Интернет, войдите на сайт www.freepascal.org. Переключившись на страницу «Downloads», можно скачать дистрибутивы под любую аппаратно-программную платформу. Установочный файл для компьютеров на базе процессоров Intel с операционной системой Windows доступен по ссылке

www.freepascal.org/down/i386/win32.var

Здесь для закачки предложено несколько равноценных зеркал на случай, если другие окажутся неработающими (не качайте с SourceForge, где содержатся исходные файлы). На момент написания этих строк с зеркал скачивался файл

fpc–2.6.0.i386-win32.exe

Запустив его, и ответив на несколько несложных вопросов установщика, вы получите желаемый результат. Затрудняясь с выбором ответов, оставляйте то, что предложено по умолчанию. Тогда полный комплект IDE установится в папку «C:\FPC\2.6.0» (для версии 2.6.0), а на рабочем столе появится ярлык для запуска IDE. Если ярлык не появится, создайте его вручную на файл

c:\fpc\2.6.0\bin\i386-win32\fp.exe


Настройка ярлыка

Прежде, чем «дергать» за ярлык, настроим его, указав рабочую папку и параметры шрифта. Что такое рабочая папка? Это папка, где мы будем хранить свои программы, а их будет немало. Негоже сорить файлами по всему диску: ведь найти их будет трудно, а удалить по неосторожности – легко. Создайте для своих программ папку в подходящем месте. Я, к примеру, создал её со следующим путем:

C:\User\Pascal

Теперь в ярлыке, запускающем IDE, укажем путь к этой рабочей папке. Щелкните по ярлыку правой кнопкой мыши и в контекстном меню выберите пункт «Свойства». В открывшемся окне свойств щелкните на вкладке «Ярлык», и в поле «Рабочая папка» вместо пути, указанного по умолчанию, впечатайте путь к своей рабочей папке (рис. 5 слева).






Рис.5 – Окно свойств ярлыка

Затем переключитесь на вкладку «Шрифт» (рис. 5 справа) и задайте достаточно крупный размер шрифта, – пощадите свои глаза! В завершение нажмите кнопку OK.


Первый запуск и настройка IDE Free Pascal

Теперь смело «дергайте» за ярлык. При каждом своем запуске IDE ищет в рабочей папке файл с текущей конфигурацией. Поскольку при первом запуске такого файла ещё нет, вам будет задан вопрос о его создании (рис. 6).






Рис.6 – Вопрос с предложением создать новый конфигурационный файл

Дайте утвердительный ответ Yes, после чего IDE создаст в вашей рабочей папке файл «FP.CFG». В дальнейшем, когда вы будете менять настройки IDE, они будут автоматически сохраняться в этом файле.

Сейчас, например, мы укажем размеры окна IDE, выбрав один из предлагаемых вариантов. В окне IDE, обратитесь к пункту меню Options –> Environment –> Preferences (рис. 7)






Рис.7 – Пункт меню для настройки предпочтений

Появится окно для настройки предпочтений пользователя (рис. 8). Здесь в поле «Video mode» предлагается один из трех видеорежимов. Так, режим «80x25 color» соответствует стандартному дисплею в текстовом режиме, но для работы удобней будет задать 30 строк или более. Остальные опции оставьте такими, как показано на рис. 8. После нажатия кнопки OK ваши предпочтения будут сохранены в конфигурационном файле.






Рис.8 – Окно для указания предпочтений пользователя

Пустое окно IDE Free Pascal примет вид, показанный на рис. 9. Буквы «FPC» на заставке означают «Free Pascal Compiler» – свободный компилятор с языка Паскаль.






Рис. 9 – Пустое окно IDE Free Pascal

На этом установка IDE завершена, и можно приступать к первой программе. Правда, для полного счастья не хватает справочной системы. Впрочем, на первых порах она не нужна, а когда вас одолеет желание поупражняться в чтении английских статей, вернитесь к установке справочной системы.


Установка справочной системы

Справочная система скачивается отдельно от установщика, на момент написания этих строк работают следующие ссылки:

https://freepascal.org/docs.var — файл в формате PDF;

https://freepascal.org/down/docs/docs.var — файлы в форматах HTML и CHM.

Примечание.  Со временем эти ссылки могут устареть, в таком случае начинайте поиск документации с корневой ссылки https://freepascal.org.

Скачав файл «doc-html.zip», распакуйте его в любое удобное место. Рекомендую создать для этого папку с именем «HELP» в той директории, где установлена IDE Free Pascal, – распакуйте zip–архив туда. Стартовый файл для открытия справки называется «fpctoc.html», он открывается любым браузером Интернета.

Эту же справочную систему можно встроить и внутрь IDE Free Pascal, выполнив следующие шаги.

Запустите IDE и активизируйте пункт меню Help –> Files… (рис. 10).






Рис.10 – Пункт меню для настройки справочной системы

Появится окно для добавления файла справочной системы (рис. 11).






Рис.11 – Окно для вставки файла справочной системы

Щелкните по кнопке New и откройте файл «fpctoc.html», – здесь IDE запросит подтверждение на создание индексного файла. Дайте положительный ответ и подождите несколько минут, пока буден создан индексный файл «fpctoc.htx». Если же файл «fpctoc.htx» уже был создан ранее, откройте сразу его (рис. 12).






Рис.12 – Указание файла справочной системы

Так или иначе, справочный файл появится в списке установленных, и вам останется лишь нажать кнопку OK. С этого момента вы сможете открывать справочную систему как отдельно (посредством файла «fpctoc.html»), так и внутри IDE Free Pascal клавишами F1 и Ctrl+F1.


Обновление версий Free Pascal

В случае скачки и установки очередной версии Free Pascal вам придётся заново настроить ярлык, а также удалить из рабочей директории старые версии файлов «fp.cfg» и «fp.dsk».


Итоги

• Существует несколько сред разработки (IDE), пригодных как для обучения, так и для профессионального программирования на Паскале.

• С учетом ряда соображений, основной средой программирования мы выбрали IDE Free Pascal. Однако примеры из данной книги годятся почти для любой из упомянутых IDE.

• Для установки IDE Free Pascal нужен установочный файл (дистрибутив) и архив справочной системы.

• Создаваемые программы разумно хранить в отдельной рабочей папке, которую надо указать в свойствах ярлыка, запускающего IDE Free Pascal.

Глава 5

Программа номер один

 Сделать закладку на этом месте книги





Постановка задачи

Отныне мы будем повелевать компьютером, а он – исполнять наши капризы. Чем бы таким озадачить его? Ответ на подобный вопрос программисты называют постановкой задачи. Никто из них и пальцем не шевельнет, не прояснив суть предстоящей работы. Пусть наша первая программа выведет на экран слово «Привет!», – славно, когда тебя приветствует собственный компьютер!


Создание файла

Запустите IDE Free Pascal, – воспользуйтесь для этого ярлычком, который мы настроили в предыдущей главе. Затем создайте новый файл, выбрав пункт меню File –> New (рис. 13). В области редактора появится пустое окно с заголовком «NONAME00.PAS», – это так называемый безымянный файл; две цифры в конце имени (00, 01, 02 и т.д.) помогают различать такие файлы.






Рис.13 – Пункт меню для создания нового файла

Сохраните пока ещё пустой файл в своей рабочей папке, у меня это папка «C:\User\Pascal». При сохранении файлу надо придумать подходящее имя. Здесь ваша фантазия ограничена лишь требованиями к именам файлов. Пока вы учитесь, придерживайтесь правил, принятых в MS–DOS: имя файла должно содержать не более восьми символов, не считая расширения имени PAS. В имени используйте только латинские буквы, цифры и знак подчеркивания (пробелы и русские буквы я запрещаю!).

Из этих «кирпичиков» можно составить миллионы имен, – и запутаться в них! Но мы избежим хаоса, применив некоторую систему. Пусть в имени файла содержится номер главы, где была создана программа. Тогда по имени файла вы найдете надлежащую главу, а по номеру главы – файл.

Итак, имя файла начнем с латинской буквы «P» (от слова «Pascal»), далее последуют две цифры с номером главы и одна цифра – с порядковым номером программы в этой главе. Элементы имени разделим знаками подчеркивания, и тогда для 1-й программы 5-й главы файл получит имя «P_05_1.PAS».

Сохраним его под этим именем. Нажмите клавишу F2, – на экране появится диалоговое окно (рис. 14). В верхней строке напечатайте имя файла, а расширение PAS можете не печатать, – оно будет добавлено автоматически. После нажатия клавиши Enter или кнопки OK файл будет сохранен в рабочей папке, и в заголовке окна появится его новое имя «P_05_1.PAS».






Рис.14 – Диалог сохранения файла

Наполнение файла

Теперь обратимся к содержимому файла, ведь он пока чист, как белый снег. Нацарапайте на этом снегу парочку английских слов, что показаны ниже.

begin

end.

Возможно, вам известен их перевод: BEGIN – «начало», а END – «конец». Зачем они тут? При переводе программы с «человеческого» языка на язык процессора компилятор должен видеть границы программы. Слова BEGIN и END для того и предназначены, их называют ключевыми. Паскаль содержит десятки ключевых слов, они перечислены мною в приложении Г. Ключевые слова служат поводырями для компилятора, помогая ему разбираться в программе. Эти слова запрещено использовать по иному назначению!

Итак, слова BEGIN и END указывают компилятору начало и конец программы. Пару BEGIN–END применяют и в иных случаях, как скобки в математике. То есть, после слова BEGIN где-то далее в программе обязательно следует слово END. Но слово END используют и для завершения некоторых других конструкций языка, о которых вы узнаете позже.

Ключевые слова можно печатать и маленькими (строчными) и большими (заглавными) буквами, например: Begin, BEGIN, begiN, – это дело вкуса. То же относится к другим «волшебным» словам языка, о которых вы узнаете позже. Важно помнить, что в этих словах разрешены только латинские буквы. Будьте внимательны: некоторые латинские буквы по начертанию совпадают с русскими («А», «Е», «О»), но для компилятора эти буквы разные, и он обязательно заметит подмену!

Теперь взгляните на точку после слова END, – она отмечает конец программы. Без нее нельзя, иначе компилятор попытается читать текст после слова END, и, не найдя ничего, сообщит об ошибке.

Итак, напечатав эти две строки с точкой в конце, нажмите ещё раз клавишу F2 для сохранения файла. Поскольку ранее мы уже дали имя файлу, IDE сохранит его под этим именем, не докучая лишними вопросами.

Примечание.  В начале программы иногда пишут необязательное ключевое слово PROGRAM, после которого указывают имя программы. Это имя должно совпадать с именем файла без расширения, например:

program P_05_1;

begin

end.

В наших примерах я не буду вставлять это необязательное ключевое слово.

Теперь поздравьте себя, – вы написали первую программу! И пусть она ещё ни на что не годна, зато синтаксически правильна, – так полагает компилятор. А это важно, – ведь теперь можно создать исполняемый файл, надо лишь откомпилировать этот текст! Раз так, дадим слово компилятору.


Компиляция

А где тут компилятор? Куда спрятался? Не ищите, для создания исполняемого EXE–файла просто нажмите клавишу F9. Если две строчки программы были напечатаны верно, появится сообщение об успешной компиляции (рис. 15).






Рис.15 – Сообщение об успешной компиляции

Закройте окно нажатием любой клавиши, или щелчком по иконке в верхнем левом углу. Заглянув теперь в свою рабочую папку, вы обнаружите там наряду с файлом «P_05_1.PAS» ещё и файл «P_05_1.EXE».

Запустите на выполнение новорожденный EXE–файл и поделитесь своим наблюдением. Зоркий охотник заметит лишь мелькнувшее консольное окно. Чем это объяснить? Запуская консольную программу (именно такую мы сейчас сотворили), Windows создаёт для нее консольное окно, а по завершении программы закрывает его. Поскольку наша программа пока ещё пуста и завершается, ничегошеньки не сделав, консольное окно вмиг исчезает.


Процедура вывода (печати)

Вернемся в IDE и продолжим наполнять нашу программу с тем, чтобы напечатать на экране приветствие. Вообще-то печатать можно только на бумаге, а на экране – высвечивать. Но, со времен пишущих машинок – консолей – слово «печатать» настолько укоренилось, что вывод на экран или файл я иногда буду называть «печатью».

Итак, для вывода приветствия добавим между ключевыми словами BEGIN и END ещё одну строчку, вот она.


Writeln(’Привет!’)


Разберем строку «по косточкам». Прежде всего, мы видим слово Writeln. Это сокращение из двух слов: Write – «записывать», и Line – «линия, строка», что вместе значит «написать строку». Слово Writeln в Паскале не ключевое – это имя процедуры. В отличие от ключевых слов – поводырей для компилятора, – процедуры определяют выполняемые программой действия. На пути к вершинам Паскаля мы встретим немало ключевых слов и процедур, и всякий раз я буду объяснять, где что.

Вернемся к процедуре Writeln, которая дает указание напечатать что-либо на экране. Но, что именно? Ответ находится внутри круглых скобок, где содержатся параметры процедуры. В этих скобках мы видим слово «Привет!», заключенное в апострофы (иногда их называют одинарными кавычками). В Паскале строку, заключенную в апострофы, называют строковой константой. Вот несколько примеров строковых констант.

’Привет, Мартышка!’

’--- Free Pascal ---’

’Я понял, что такое строковая константа!’

Как видите, любой текст обращается в строковую константу, если заключить его в апострофы. Внутри такой константы компилятор не различает ни ключевых слов, ни процедур, а воспринимает строку «как есть». Длина применяемых нами строк будет ограничена 255 знаками, включая пробелы. А вот примеры «незаконных», ошибочных строковых констант:

Нет первого апострофа’

’Нет последнего апострофа

’Апостроф ’ внутри строки’

Совсем без апострофов

А когда надо вставить апостроф внутрь строки? Тогда ставят два апострофа подряд, например:

’Один апостроф ’’ внутри строки’

И, хотя в середине строки поставлены два апострофа, компилятор учтет только один из них, – такая вот хитрость!

Теперь, с оператором печати, наша программа выглядит следующим образом:

begin

Writeln(’Привет!’)

end.

Постарайтесь ввести её без ошибок, ведь вы пока не умеете бороться с ними. Готово? Тогда сохраните файл нажатием F2 и скомпилируйте нажатием F9. Если все нормально, появится знакомое окно успешной компиляции. В противном случае найдите ошибку, исправьте её и повторите компиляцию.


Запуск программы

Теперь мы создали новую версию файла «P_05_1.EXE», запустите его, пожалуйста. Что увидели? Опять мелькнувшее окно? Причина все та же: операционная система быстренько закрыла консольное окно, поскольку программа завершилась сразу после вывода сообщения, – вы просто не успели его разглядеть! Скоро мы найдем способ притормозить программу, но ждать нам недосуг, – не терпится посмотреть результат! И я покажу, как его увидеть.

Готовую программу мы запустим, не покидая IDE, – нажатием сочетания клавиш Ctrl+F9. Нажали? И что, опять ничего?! Спокойно, сейчас разберемся. Дело в том, что IDE закрывает собою всю площадь консольного окна, пряча то, что вывела в это окно наша программа. Чтобы увидеть результат, надо временно убрать IDE нажатием комбинации клавиш Alt+F5. Сделайте так, и тогда вам явится долгожданная картинка (рис. 16).






Рис. 16 – Вид консольного окна после скрытия IDE

Первые строки содержат служебное сообщение о запуске IDE Free Pascal, – не смотрите туда. Нам важна последняя строка, где мы видим долгожданный «Привет!». Полюбовавшись на него, вернитесь в IDE, для чего нажмите любую клавишу. Хотите повторить удовольствие? Так запустите программу ещё пару раз (Ctrl+F9) и полюбуйтесь на результат (Alt+F5).


Итоги

• Создание программы начинается с подготовки текстового файла.

• Программа на Паскале содержит, по меньшей мере, одну пару ключевых слов Begin – End с точкой в конце. Между этими ключевыми словами помещают операторы, выполняющие нужные действия.

• Вывод информации на экран выполняется процедурой Writeln с параметрами внутри круглых скобок; таким параметром может быть строковая константа.

• Строковая константа – это последовательность символов, заключенная


убрать рекламу






в апострофы. Наши строки будут содержать не более 255 символов.

• Для создания исполняемого EXE-файла вызывают компилятор, это делается нажатием клавиши F9. Если программа не содержит синтаксических ошибок, компилятор создаст исполняемый файл и сообщит об успешной компиляции, а иначе доложит об ошибке.

• Запустить исполняемый файл можно непосредственно в IDE. Для этого следует нажать сочетание клавиш Ctrl+F9.

• Для просмотра выводимых на экран результатов (временного скрытия IDE) нажимают комбинацию клавиш Alt+F5, а для восстановления IDE – любую клавишу.


А слабо?

Начиная с этой главы и далее, я буду предлагать вам каверзные вопросы и задачки. Некоторые из них решаются в уме, другие – на компьютере. Если вы справитесь с большинством задач, спите спокойно – ваша совесть чиста, а голова не пуста. Вот вам первые задания.

А) Найдите ошибки в следующей программе.

begn

Writeln(ПрЫветик!)

end

Сначала проделайте это в уме, а затем на компьютере. Объясните, почему компилятор не нашел ошибки в слове «ПрЫветик». Или слабо?

Б) Будет ли работать следующая программа?

begin Writeln(’Begin End.’) end.

В) Попытайтесь написать программу, выводящую на экран не одну, а две строки, например:

Без труда

Не выловишь калошу из пруда

Здесь нужны две процедуры печати, следующие друг за другом. Подсказка: между процедурами требуется специальный разделитель – точка с запятой (;).

Глава 6

Подготовка к следующему штурму

 Сделать закладку на этом месте книги




Перед штурмом следующей крепости подтянем «тылы» и укрепимся на завоеванной позиции.


Ещё об исходных файлах

Работая над первой программой, мы создали и сохранили исходный файл с расширением PAS. Если вам потребуется вновь обратиться к нему, достаточно будет нажать клавишу F3, и тогда появится окно открытия файла (рис. 17).






Рис. 17 – Окно открытия файла

В верхней части расположено поле для ввода имени открываемого файла. В центре – список файлов текущей папки (файлов с расширением PAS), а путь к этой папке виден в нижней части окна. Щелкнув мышкой по имени файла, вы переместите его в поле ввода. Теперь достаточно щелкнуть на кнопке Open, или нажать клавишу Enter, и файл откроется в окне редактора. Так последовательно можно открыть несколько файлов.

Открытие файла – дело нехитрое, но лучше, если в следующий раз вам не придется вспоминать о файлах, с которыми вы работали в предыдущем сеансе. Для этого при выходе из IDE не закрывайте окна, и тогда при повторном запуске IDE автоматически откроет эти файлы.


Управление окном редактора

Тем, кто привык управляться с окнами Windows, обращаться с окнами IDE Free Pascal понравится ничуть не меньше. Взгляните на рис. 18, где представлены средства управления окном.






Рис. 18 – Средства управления окном редактора











Рис.19 – Запрос на сохранение файла

Ответ Yes приведет к закрытию окна с сохранением последних изменений, ответ No – без сохранения. При нажатии кнопки Cancel окно не закроется, и вы сможете продолжить редактирование файла.

Повозитесь немного с окном, – это добавит вам уверенности.


Борьба с ошибками

Ошибки, ошибки… – их никому не миновать! Мы тоже не ангелы и будем ошибаться. Но в компьютере все поправимо. Не страшитесь ошибок, – вы всегда сможете найти и поправить их, и в этом IDE Free Pascal вам поможет.

Ошибки ошибкам рознь. В разговоре и письме мы допускаем ошибки разного рода: грамматические, синтаксические и смысловые. Вот школьная тетрадь, что там нацарапано? «МАлАко»? – ужас! – это грамматическая ошибка, такого слова нет. А если видим: «змея даёт зеленое молоко», – это смысловая ошибка, хоть с грамматикой тут все в порядке.

Вернемся к Паскалю. Превращая вашу программу в исполняемый файл, компилятор, подобно учителю, читает её слева направо и сверху вниз, зорко изучая вашу писанину. Обнаружив синтаксическую ошибку, он сообщит об этом и остановится. Исполняемый EXE–файл будет создан только при отсутствии синтаксических ошибок. К чему такая строгость? Мы склонны прощать друг другу мелкие огрехи, если понимаем смысл сказанного. Но компьютер не так умен, чтобы додумывать наши человеческие мысли, – вот почему так строг компилятор.

Обратимся к практике. Откройте файл с нашей первой программой и внесите ошибку в первой строке. Например, уберите первую букву в слове BEGIN.

egin

Writeln(’Привет!’)

end.

Запустите компиляцию этой программы – нажмите F9, – и что же? В окне сообщений вы увидите: «BEGIN expected…». Это значит, что компилятор не нашел обязательного в начале программы ключевого слова BEGIN. Компилятор может обнаружить много разных ошибок, вы найдете их перечень в справке по IDE (Appendix C, Compiler messages), а также в приложении Д.

Исправим эту ошибку и сделаем другую, – уберем закрывающую кавычку в тестовой константе (после восклицательного знака).

begin

Writeln(’Привет!)

end.

Попытавшись скомпилировать, получим сообщение: «String exceeds line». Это значит, что строковая константа превышает допустимый размер. Стало быть, компилятор не всегда точно определяет место ошибки, и тогда не худо самим «шевельнуть извилинами», – здесь полезна тренировка. Поупражняйтесь в поиске ошибок, внося их в программу сознательно. Запускайте компиляцию, и наблюдайте результат. Так накопите бесценный опыт исправления ошибок, и «ужасные» сообщения уже не запугают вас.

А найдет ли компилятор ошибку внутри апострофов? Как он воспримет слова «прЫвет» и «мАлАко»? Ничего не заметил? Это и понятно, ведь слова внутри апострофов компилятор не проверяет. Не его это дело, – он вообще не знает русского языка! В строковых константах он проверяет, как мы уже убедились, только парность апострофов.


Итоги

• В редакторе IDE можно одновременно открывать несколько исходных файлов с программами.

• При запуске IDE Free Pascal автоматически открывает файлы, открытые в предыдущем сеансе (точнее, окна, не закрытые при выходе из сеанса).

• Элементы управления окном редактора изменяют его размеры, перемещают по экрану, распахивают, сворачивают и закрывают окно.

• Компилятор Pascal проверяет текст программы при каждой компиляции. Обнаружив синтаксическую ошибку, он не создает исполняемый файл, а выводит краткое описание ошибки.

Глава 7

Развиваем успех

 Сделать закладку на этом месте книги




Теперь усложним задачу, пусть компьютер обратится к вам вот с таким пышным приветствием:

------------------------

Мой повелитель!

Поздравляю тебя с первой программой!

Твой верный слуга Паскаль

------------------------

Здесь в первой и последней строках для красоты печатается горизонтальный прочерк.


Операторы и разделители

Создадим новый файл и сохраним его под именем «P_07_1.PAS». Напомню, что новый файл создается через пункт меню File –> New, а сохраняется нажатием клавиши F2. Покончив с этим, приступим к сочинению программы. Поразмыслив немного, вы наверняка напишите следующие строки.


begin

Writeln(’------------------------’)

Writeln(’Мой повелитель!’)

Writeln(’Поздравляю тебя с первой программой!’)

Writeln(’Твой верный слуга Паскаль’)

Writeln(’------------------------’)

end.


Ход вашей мысли ясен: уж если компилятор читает программу слева направо и сверху вниз, то и компьютер будет выполнять её в том же порядке. Вы угадали, так оно и есть! Ну что ж, пробуем скомпилировать свое детище, жмем F9 и что? Опять видим сообщение об ошибке (рис. 20)!






Рис.20 – Сообщение о синтаксической ошибке

В чем дело? Компилятор утверждает, что где-то пропущена точка с запятой. В скобках указано место ошибки: третья строка, первый символ. Значит, точку с запятой надо ставить здесь? И зачем она нужна?

Познакомьтесь с важным понятием языка – оператором. Оператор – это наименьший смысловой «кусочек» программы. Он заключает в себе либо небольшое действие – шаг программы, либо описание каких-то данных. В Паскале есть много разных операторов, процедура печати – один из них. В целом программа – это последовательность операторов и ключевых слов. Читая программу, компилятор должен уяснить, где кончается один оператор и начинается следующий. И здесь он нуждается в вашей помощи! Ему нужна подсказка – разделитель операторов, которым служит точка с запятой (;).

Вернемся к нашей программе. Хотя процедуры печати расположены в разных строках, этого мало, чтобы компилятор воспринял их как отдельные операторы. Порой длинный оператор не помещается в одной строке и пишется на нескольких. А бывает наоборот – в одной строке пишут несколько операторов. Вот почему нужен разделитель.

Итак, между операторами надо поставить точку с запятой, программисты обычно ставят разделитель после оператора. Теперь наша программа станет такой.


begin

Writeln(’------------------------’);

Writeln(’Мой повелитель!’);

Writeln(’Поздравляю тебя с первой программой!’);

Writeln(’Твой верный слуга Паскаль’);

Writeln(’------------------------’)

end.


А где разделитель за последним оператором, то есть перед словом END? Здесь он не нужен, поскольку END – не оператор, а ключевое слово. Но, если вы поставите лишнюю точку с запятой или даже несколько подряд, в этом не будет ошибки. Теперь можно запустить программу нажатием Ctrl+F9 и полюбоваться на результат её работы, нажав Alt+F5.


Программа, стой!

Как хотите, а мне надоело всякий раз нажимать сочетание Alt+F5 для того лишь, чтобы увидеть результат. Пора избавиться от этого неудобства.

Познакомьтесь с новой процедурой, она называется ReadLn. Это слово, как и слово Writeln, тоже состоит из двух: Read – «чтение», Line – «линия, строка», что значит «чтение строки». Действует процедура ReadLn очень просто: дойдя до её исполнения, компьютер остановится в ожидании, пока вы не нажмете клавишу Enter. Вот и все. И пока он ждет, вы спокойно разглядываете консольное окно. Ясно? Тогда подскажите, где поместить эту процедуру? Ну, очевидно же – самым последним оператором! В результате получим новый вариант программы.


begin

Writeln(’------------------------’);

Writeln(’Мой повелитель!’);

Writeln(’Поздравляю тебя с написанием первой программы!’);

Writeln(’Твой верный слуга Паскаль’);

Writeln(’------------------------’);

Readln

end.


Про точку с запятой не забыли? Отлично! Запускаем программу и убеждаемся, что Паскаль нас снова не подвел (не забудьте нажать Enter!).


Алгоритмы

Взгляните на программу ещё разок: печатая строки, компьютер выполняет отдельные действия – шаги программы. Такую последовательность шагов называют алгоритмом. Вам следует привыкнуть к этому слову, ведь алгоритм – основное понятие в программировании. Вот слегка упрощенное определение алгоритма, запишите: «Алгоритм – это точное предписание исполнителю совершить определенную последовательность действий для достижения поставленной цели за конечное число шагов». Под исполнителем мы понимаем компьютер.

В этом определении угадывается что-то знакомое, не так ли? Ещё бы! То и дело мы получаем указания: сделай то, да сделай это. За что ни возьмись, надо выполнять некий алгоритм. Так, например, одеваясь на улицу, вы соображаете, что и за чем следует напялить на себя: сначала белье, затем рубашку, брюки, носки и ботинки. Даже при ходьбе выполняем простейший алгоритм: левой, правой, левой, правой…

Разбивая сложное действие на ряд простых шагов, вы создаете алгоритм. Алгоритм нашей программы состоит из шагов, выполняемых друг за другом, последовательно. Линейная последовательность – это одна из трех базовых управляющих структур, на которых строится вся гигантски сложная архитектура современных программ (о двух других базовых управляющих структурах я расскажу позднее).


Блок-схемы

Как видите, с алгоритмами связан любой из нас, а не только программисты. Создание напичканных компьютерами сложных систем – заводов, электростанций и тому подобного – требует согласованных усилий специалистов разных профессий. Они объясняют программистам требования к создаваемым системам. Иными словами, эти специалисты заказывают алгоритмы. Увы, не все они владеют программированием. Как быть?

Кто-то догадался изображать алгоритмы графическими схемами, картинками. Этот прием оказался наглядным и понятным даже людям, далеким от программирования. Блок-схемы – так называют эти картинки – стали средством общения между специалистами разных профессий с одной стороны, и программистами с другой.

Впрочем, программисты и между собой общаются посредством блок-схем. Эти схемы помогают обнаружить ошибки в программах. В чем отличие блок-схемы программы от её текста? Текст показывает то, что фактически делает программа, а блок-схема – то, что она должна делать. Сравнивая одно с другим, можно найти ошибки в программном воплощении алгоритма.

Перед вами блок-схемы трех созданных нами программ (рис. 21).






Рис.21 – Блок-схемы программ

Скругленные прямоугольники означают начало и конец алгоритма, – они соответствуют ключевым словам BEGIN и END. Исполняемые операторы – это прямоугольники с пояснениями внутри, а стрелки показывают порядок выполнения операторов. Все просто! Скоро мы изучим другие базовые управляющие структуры, и вы увидите их блок-схемы.


Итоги

• Наименьшая смысловая часть программы называется оператором. Процедура печати Writeln и процедура ввода Readln – это операторы.

• Программа – это последовательность ключевых слов и операторов.

• Для разделения операторов используют точку с запятой.

• Точное предписание порядка выполняемых действий называется алгоритмом.

• Линейная последовательность – это один из трех базовых алгоритмов.

• Алгоритм может быть представлен словесным описанием, рисунком (блок-схемой), или текстом программы.


А слабо?

А) В нашей программе остался маленький изъян. Со временем вы забудете о том, что для завершения программы надо нажать клавишу Enter. Пусть программа сама напомнит об этом, печатая после приветствия напоминание:


Для завершения программы нажмите Enter


Внесите это изменение в программу. Или слабо?

Б) Измените программу так, чтобы в каждой строке разместилось по два оператора. Откомпилируйте и проверьте программу в действии. Изменилось ли что-то в её поведении?

В) Нарисуйте две блок-схемы, поясняющие, как вы обычно проводите свой будний и выходной день.

Глава 8

Постоянные и переменные

 Сделать закладку на этом месте книги




Знаком ли вам Эдсон Арантес ду Насименту? Неужто не слышали о великом Пеле? Ведь оба имени принадлежат одному человеку! В Бразилии полно отменных футболистов, и у всех – пышные имена. Но от футбольных комментаторов вы их не услышите. Бразильцы – а все они фанаты – дали своим любимцам короткие клички. Так на весь мир прославились Пеле, Зико, Ривалдо…


Константы

Придумка бразильских фанатов напомнила решение сходной проблемы программистами. В разных частях программы нередко попадаются одни и те же данные – строчки текста или числа. Взять хотя бы предыдущую программу, где в начале и в конце приветствия печатаются две горизонтальные черты. Если в этих операторах задать линии разной длины, то красота слегка пострадает. Пустяки? Конечно. Но в иных случаях ошибочка обойдется втридорога, например, в программе управления ракетой.

Предположим, что в расчете полета ракеты учитывается масса её полезной нагрузки, и это число разбросано по всем частям программы. Вы должны указать его везде одинаково, без ошибки, иначе ракета улетит «за бугор». А если переделка ракеты повлечет изменение этого числа? Тогда доведется тщательно «прочесать» программу в поисках всех исправляемых операторов.

Проблема очевидна, но Паскаль даёт средство её решения – это символические константы. «Константа» в переводе на русский означает «постоянный», «неизменный». Константа подобна кличке бразильского футболиста: любому элементу данных – числу или строке – вы можете назначить удобное имя, а затем подставлять это имя вместо самих данных. Покажем это на примере нашей программы.

Прежде, чем применить символическую константу, её надо объявить, то есть дать ей имя и значение. Для объявления используют ключевое слово CONST, за которым следует нечто, похожее на простую формулу.


      const Имя_константы = Значение_константы;


Слева от знака равенства указывают имя константы, а справа – её значение. Предположим, что длинный прочерк я обозначил словом Line – «линия». Тогда объявление константы для линии будет таким.


      const Line = ’---------------------------’;


Обратите внимание, что объявление константы – это оператор, и после него следует точка с запятой! Теперь в любом месте программы я могу напечатать прочерк, пользуясь именем этой константы.


      Writeln(Line);


Параметром процедуры печати Writeln здесь по-прежнему является всё та же строковая константа, только теперь она обозначена через свое имя Line.

Слово CONST открывает секцию объявления констант, внутри которой надо объявить хотя бы одну константу, – секция не терпит пустоты! Вот объявление двух констант, где для наглядности слово CONST записано в отдельной строке.


Const

      C1 = ’Мой повелитель!’;

      Pele = ’Эдсон Арантес ду Насименту’;


Секцию констант располагают до слова BEGIN перед началом выполняемых операторов. Следовательно, новый вариант нашей программы будет таким.


const

      Line = ’---------------------------’;

begin

Writeln(Line );

Writeln(’Мой повелитель!’);

Writeln(’Поздравляю тебя с написанием первой программы!’);

Writeln(’Твой верный слуга Паскаль’);

Writeln(Line );

Readln

end.


Программа будет работать точь-в-точь, как и раньше. Но теперь мы уверены, что линии будут одинаковыми. А если потребуется изменить линию и составить её из звездочек? Тогда исправим лишь объявление константы:


const       Line = ’***************************’;


и после повторной компиляции программа заработает по-новому.

Константы облегчают жизнь программиста и повышают надежность программ. Но, повторяю, после изменения константы вы должны повторно откомпилировать программу!


Идентификаторы

Для констант придумывают подходящие имена. Впрочем, это касается и других объектов программы, о которых вы скоро узнаете. Выдуманные программистом имена называют идентификаторами (IDENTIFIER). Запомните это словцо, оно ещё «намозолит» вам глаза. Изобретатель идентификаторов ограничен следующими рамками.

• В идентификаторах допустимы лишь латинские буквы, знак подчеркивания и цифры.

• Идентификатор начинают либо с буквы, либо с подчеркивания (но только не с цифры!).

• Идентификатор может содержать до 127 символов, (в Borland Pascal учитываются только первые 63 из них).

• Не допускается совпадение идентификатора с ключевым словом.

Русские буквы и знаки препинания в именах запрещены. Большие и маленькие латинские буквы равнозначны (регистр букв не учитывается), поэтому идентификаторы Pascal и PASCAL считаются одинаковыми.

Вот примеры правильных идентификаторов:


A, b, C       - однобуквенные имена

R1, U28, _13_       - имена с цифрами и подчеркиванием

Cosmos, ABBA       - однословные имена

NextStep, Next_Step – имена, составленные из двух слов


А это ошибочные имена:


7Up – начинается с цифры

End – совпадает с ключевым словом


Изобретая имена, мы будем придерживаться некоторой системы с тем, чтобы меньше путаться в своих придумках. Так, имена констант условимся начинать с латинской буквы «C» (например, CLine).


Переменные

Согласитесь, наш последний шедевр – программа P_07_1 – пока не слишком умна, при каждом запуске она тупо твердит одно и то же. Сотворим нечто поумней: пусть наша следующая программа сначала спросит имя пользователя, а затем обратится к нему по этому имени. На экране это будет выглядеть так:


Как тебя зовут?

Антон 

Здравствуй, Антон

Нажми Enter


Здесь выделенное курсивом слово «Антон» во второй строке ввёл пользователь. Такие программы называют диалоговыми.

Ясно, что неизвестное имя собеседника в программу заранее не вставишь. Константа тут бесполезна, – ведь она вбивается в программу заранее и не меняется после компиляции. Если данные вводятся пользователем в ходе выполнения программы, им нужно нечто иное, – этим данным надо отвести место для хранения их в памяти. И тогда мы сможем как-то работать с этими сохраненными данными (например, печатать).

Где хранят предметы? В ящиках, карманах, кошельках. Для хранения данных в памяти используют переменные (VARIABLE). Переменная – это своего рода «карман» с именем, данным ему программистом. В ходе работы программа может «укладывать» в переменную данные, и затем обращаться с ними по своему усмотрению. Этот «карман» действует по принципу: что положил, то и взял. Иначе говоря, в переменной хранится то, что было положено последним. Но, в отличие от кошелька, единожды положенное в переменную можно извлекать многократно, – этот «карман» никогда не опустеет!

Прежде, чем пользоваться переменной, её, как и константу, надо объявить. Для этого служит секция объявления переменных, которую открывают ключевым словом VAR (сокращение от VARIABLE), секцию помещают до исполняемых операторов – перед словом BEGIN. Внутри секции объявляют одну или несколько переменных. Каждое такое объявление содержит два элемента: имя переменной и её тип, разделяемые двоеточием:


var Имя_переменной : Тип_переменной;


Ну, с именем все ясно – это обычный идентификатор, который вы изобретаете сами. А что такое тип, и в чем его смысл? В этой обширной теме мы со временем разберемся основательно, а сейчас затронем лишь слегка.

Укладывая предметы, вы учитываете их размеры, вес и назначение. Пылесосу удобно в своей коробке, а монете – в кошельке. «Каждый сверчок – знай свой шесток». Встретив в программе объявление переменной, компилятор отводит ей место в оперативной памяти с тем, чтобы хранимые данные поместились там. То есть, кроит «карман» подходящего размера. Это первое.

А ещё компилятору надо знать набор допустимых действий с теми данными, что «лежат» в переменной: можно ли их складывать и умножать? Или это строка текста, предназначенная для вывода на экран? Ответ на эти вопросы заключен в типе переменной. По нему компилятор определяет и размер переменной, и набор допустимых операций с нею.

Паскаль содержит ряд встроенных типов данных, со временем вы познакомитесь с ними, но сейчас нам позарез нужен только один из них. Это тип STRING, что в переводе значит «строка» – это ключевое слово языка. Переменная этого типа может хранить в себе строчку какого-нибудь текста.

Объявим переменную для хранения в ней имени пользователя. Как назовем её? Да так и назовем – Name, что переводится как «имя». Итак, объявление переменной Name строкового типа STRING выглядит так:


var Name : string;


Напомню, что имя и тип переменной разделяются двоеточием, а завершается оператор точкой с запятой.


Ввод и вывод данных

Теперь, когда мы объявили переменную, попробуем ввести в неё данные, а затем вывести данные на экран.

Ввод данных в переменную выполняется знакомой вам процедурой Readln. Мы уже пользовались ею, чтобы заставить компьютер ждать нажатия Enter. Но процедура придумана в основном не для этого, а для ввода разнообразных данных, в том числе строк. С этой целью процедуре передают параметры – переменные, куда вводятся данные. В нашем случае оператор ввода имени будет таким:


      Readln(Name);


Выполняя этот оператор, компьютер тоже остановится в ожидании нажатия Enter. Но символы, которые пользователь напечатает до этого нажатия, попадут в переменную Name и сохранятся там. Так в строковую переменную можно ввести слово, и даже целое предложение, завершив ввод нажатием Enter.

А как напечатать содержимое переменной? Справится ли с этим процедура Writeln? Без сомнения! Ведь нечто подобное мы уже проделывали с константой. Вот оператор печати для этого случая:


      Writeln(Name);


Все хорошо, да вот незадача! Этот оператор напечатает имя в отдельной строке, а нам хочется объединить его со словом «Привет» в одной строчке. Как это сделать? Очень просто! Ведь в процедуре печати можно указать несколько параметров, разделяя их запятыми, и тогда все они напечатаются в одной строке. В нашем случае через запятую укажем два параметра:


Writeln(’Здравствуй, ’, Name);


Здесь первый параметр – строковая константа «Здравствуй,» (с пробелом в конце), а второй – переменная Name.

Теперь все готово для рождения новой программы. Создайте пустой файл с именем «P_08_1.PAS», а затем введите в него плод наших размышлений.


var Name : string;

begin

Writeln(’Как тебя зовут?’);

Readln(Name);

Writeln(’Здравствуй, ’, Name);

Writeln(’Нажми Enter’); Readln;

end.


Откомпилируйте программу и проверьте, работает ли она.


Итоги

• Константы полезны для именования неизменяемых данных. Они облегчают работу и повышают надежность программ. Но константы не могут изменяться в ходе выполнения программы.

• Переменные предназначены для хранения в оперативной памяти компьютера изменяемых данных. Переменные могут изменяться в ходе выполнения программы.

• Каждая переменная относится к некоторому типу данных, который определяет и объём занимаемой ею памяти и правила действия с переменной.

• Ввод данных в переменные выполняется оператором Readln, а вывод – оператором Writeln.

• Процедура Writeln может напечатать в одной строке несколько параметров – констант и переменных, разделенных запятыми.

• Имена констант и переменных – это идентификаторы. Программист составляет их по своему усмотрению из латинских букв, цифр и знака подчеркивания.


А слабо?

А) Что напечатает следующая программа, если ваша любимая команда – «Спартак»?


const

      Champ = ’ – чемпион!';

var

      Team : string;

begin

Writeln(’Ваша любимая команда?’);

Readln(Team);

Writeln(Team, Champ);

Readln

end.


Б) Найдите (и исправьте, если можно) ошибки в следующих программах.


begin

const Pele = ’Эдсон Арантес ду Насименту’;

Writeln(’Лучший футболист мира – ’, Pele);

Readln

end.<


убрать рекламу






/code>

begin

Writeln(’Как тебя зовут?’);

var Name : string;

Readln(Name);

Writeln(’Здравствуй, ’, Name);

Writeln(’Нажми Enter’); Readln;

end.

const Pele = ’Эдсон Арантес ду Насименту’;

begin

Writeln(’Лучший футболист мира’);

Readln(Pele);

Writeln(Pele);

Readln

end.

Глава 9

Переменные: продолжение знакомства

 Сделать закладку на этом месте книги




Теперь, после знакомства с переменными, вы умеете объявлять их, вводить в переменные данные и печатать. Отныне мы не расстанемся с ними.


Представьтесь, пожалуйста!

Наша следующая программа «P_09_1» спросит у пользователя имя и фамилию, после чего обратится к нему уважительно, как следует. Вот пример такой «беседы» (выделенное курсивом печатал пользователь).


Фамилия?

Скотинин 

Имя?

Тарас 

Здравствуй, Тарас Скотинин!

Нажми Enter


Примечание. Тарас Скотинин — персонаж комедии Д.И. Фонвизина «Недоросль».

Очевидно, что для хранения имени и фамилии одной переменной мало, нужны две. Памятуя о том, что секция объявления переменных допускает несколько операторов, объявим там парочку переменных.


var N : string;

      S : string;


Здесь переменные N и S названы мною по первым буквам слов Name (имя) и Surname (фамилия). Объявить несколько переменных одного типа можно и в одной строке, перечислив их через запятую.


var N, S : string;


Тут две переменные объявлены одним оператором, – этот способ ничуть не хуже.

Далее, после ввода данных, надо напечатать в одной строке несколько параметров: приветствие, имя, фамилию, и восклицательный знак в конце, чтобы обратиться к Тарасу Скотинину так:


      Здравствуй, Тарас Скотинин!


Достаточно ли здесь одного оператора печати? Конечно! Вот он.


Writeln(’Здравствуй, ’, N, ’ ’, S, ’!’);


Тут мы втиснули в процедуру Writeln аж пять параметров! Обратите внимание: в конце добавлен восклицательный знак, а между именем и фамилией печатается пробел, иначе эти слова слипнутся на экране.

После всех пояснений следующая программа должна быть вполне ясной.


var N, S : string;

begin

Writeln(’Фамилия?’); Readln(S);

Writeln(’Имя?’); Readln(N);

Writeln(’Здравствуй, ’, N, ’ ’, S,’!’);

Writeln(’Нажми Enter’); Readln;

end.


Обязательно скомпилируйте её и проверьте в действии.


Из пустого в порожнее

Итак, нам удалось скроить уже два «кармана» для хранения данных. Действительно, переменные сродни карманам, здесь можно и хранить данные, и копировать из одного «кармана» в другой. Для копирования данных в Паскале применяют оператор присваивания, вот примеры копирования данных.


A := 'Привет, Мартышка!'; <– копирование строковой константы

B := A;       <– копирование из переменной A в переменную B


Пара символов «:=» – «двоеточие» и «равно» – означают операцию присваивания. Слева от знака операции указывают переменную, в которую будут помещены данные, а справа можно указать переменную или константу. Что, по вашему мнению, напечатает следующая программа?


var A, B : string;

begin

A:= 'Первая строка';

B:= 'Вторая строка';

Writeln(A);       Writeln(B);

B:= A; 

Writeln(B);       Readln

end.


Очевидно, что на экране появятся следующие строки.


Первая строка

Вторая строка

Первая строка


Первые два оператора заносят в переменные A и B две строковые константы, которые затем печатаются. Третий оператор присваивания B:=A скопирует в переменную B значение переменной A, где уже содержится «Первая строка», – она и будет напечатана последней.

Но, к чему здесь было копировать данные из одной переменной в другую? Сейчас это не имело смысла, согласен. Но последнее слово ещё не сказано!


Сцепление строк

Спросите у любого: для чего нужны компьютеры? Для вычислений, для чего ж еще? – ответят некоторые. Другие скажут, что для обработки данных. В самом деле, обработка данных – нечто более общее, чем вычисление. Не пора ли и нам приступить к обработке данных? Познакомимся с простейшей операцией обработки строк, которую называют сцеплением или конкатенацией.

Не пугайтесь этого заумного слова, сцепление строк – простейшее дело! Руками это делается так: берете несколько полос бумаги и пишите что-либо, – это ваши строки, – а затем склеиваете полоски. Это и есть конкатенация строк.






Рис.22 – «Склеивание» отдельных строк оператором сцепления «+»

На рис. 22 представлено строковое выражение. Знаки «+» здесь обозначают операцию сцепления строк, – точно так же она обозначается и в Паскале. Показанный ниже оператор присваивания занесет в переменную R строку, «склеенную» из пяти других строк (здесь N и S – это переменные, содержащие имя и фамилию человека).


R:= ’Здравствуй, ’ + N + ’ ’ + S + ’!’;


Стало быть, справа от операции присваивания «:=» может быть не только константа или переменная, но и строковое выражение.

Испытайте теперь второй вариант приветствующей программы с тремя строковыми переменными.


var N, S, R : string;

begin

Writeln(’Фамилия?’); Readln(S);

Writeln(’Имя?’); Readln(N);

R := ’Здравствуй, ’ + N + ’ ’ + S +’!’;

Writeln(R);

Writeln(’Нажми Enter’); Readln;

end.



Инициализация переменных

Если найдете силы, испытайте и эту программку (в ней есть ошибка!).


var S : string;

begin

Writeln(S);

S:= ’Спартак’;

Writeln(S);

S:= S + ’ – чемпион!’;

Writeln(S);

Writeln(’Нажми Enter’); Readln;

end.


Здесь переменная S будет напечатана трижды. Но что, по вашему мнению, выведет первый оператор Writeln(S)? Ни за что не угадаете! Этого даже я не знаю. Все потому, что при старте программы содержимое всех её переменных не определено, – в этих «карманчиках» может валяться что угодно. Обычно там остаются следы от деятельности предыдущих программ – так называемый мусор. Не пытайтесь напечатать такие переменные или извлечь из них данные, – порой это может вызвать даже аварию программы.

Запомните: прежде, чем взять из «карманчика», туда следует что-либо положить! Надо, как говорят программисты, инициализировать переменную. Это можно сделать двояко: либо вводом данных процедурой Readln, либо оператором присваивания.

В последующих операторах этого примера переменная S инициализируется, и здесь результат вывода на экран очевиден. А в операторе


S:= S + ’ – чемпион!’;


предыдущее значение переменной S взято для формирования её нового значения. Теперь там окажется строка «Спартак минус чемпион!». Не обижайтесь, спартаковцы, – пошутил. Обязательно проверьте эту программу!


Типизированные константы

Всем данным в программе свойственен какой-либо тип. Это может быть строка, число или другой тип данных, с которыми вы скоро познакомитесь. То же касается и констант, например:


const Pele = ’Эдсон Арантес ду Насименту’; <– это строка (string)

      Number = 12;             <– это число


Здесь тип сам собой определяется тем значением, что дано константе.

Но существует и другая разновидность констант – типизированные константы, которые объявляются с явным указанием типа:


const Pele : string = ’Эдсон Арантес ду Насименту’; <– это строка (string)

      Number : integer = 12;       <– это число (integer)


В действительности это тоже переменные, и они могут изменяться в ходе выполнения программы. Но этим переменным изначально присвоены нужные значения, поэтому при запуске программы инициализация их через присваивание уже не требуется.

В Delphi разрешено инициализировать переменные при объявлении:


var Pele : string = ’Эдсон Арантес ду Насименту’;


Но этот способ не совместим с Borland Pascal, и в данной книге не применяется.


Итоги

• В одном операторе можно объявить несколько переменных одного типа.

• Процедура Writeln способна напечатать в одной строке несколько параметров. Параметры в списке разделяются запятыми.

• Операция присваивания «:=» помещает в переменную данные, представленные константой, переменной, или их комбинацией – выражением.

• Конкатенация – это объединение нескольких строк в одну.

• Для инициализации переменной необходимо либо ввести в неё данные процедурой Readln, либо заполнить оператором присваивания.

• Извлечение данных из переменных, которые не были инициализированы, бессмысленно и нередко вызывает крушение программы.


А слабо?

А) Что напечатает следующая программа?


const Pele = ’Эдсон Арантес ду Насименту’;

begin

Writeln(’Pele = ’ + Pele); Readln;

end.


Б) А эта программа что напечатает?


var A, B : string;

begin

A:=’123’; B:=’456’;

Writeln(’A+B= ’ + A + B); Readln;

end.


В) Является ли следующий оператор оператором присваивания?


const Pele = ’Эдсон Арантес ду Насименту’;


Г) Пусть ваша программа запросит у пользователя его адрес, а именно: город, улицу, номер дома и номер квартиры. А затем напечатает адрес одной строкой в таком виде:


Город: ГГГ  Улица: УУУ  Дом: ДДД  Квартира: ККК 


Сделайте два варианта программы: один – с печатью нескольких параметров оператором Writeln, другой – с объединением строк.

Д) Какие из следующих операторов забракует компилятор?


const

      Pele = ’Эдсон Арантес ду Насименту’;

      ABBA : string = ’Музыкальный шедевр из Швеции’;

var

      Moscow : string;

begin

      Pele := ’Лучший футболист мира’;

      ABBA := ’Распевают частушки’;

      Moscow:= ’Столица олимпиады’;

end.

Глава 10

Условный оператор

 Сделать закладку на этом месте книги




Согласитесь, наши последние программы слегка поумнели, догнав по интеллекту попугая. Но негоже на лаврах почивать, – научим компьютер принимать осмысленные решения.


Стой! Кто идет?

Вот секретное учреждение, вход в него строго ограничен. А вы – часовой, и пропускаете лишь тех, кто назовет пароль – слово «pascal». Наскучив на посту, вы задумали приспособить вместо себя компьютер. Ваша новая программа «P_10_1» должна запросить у пользователя пароль и решить, пропускать ли этого человека.


Вопрос ребром

Что проще должности часового? Пускать или не пускать? Подобные вопросы решаются поминутно: свернуть направо или налево? орел или решка? быть или не быть? От полученного ответа зависят дальнейшие действия.

Обычно мы рассуждаем так: ЕСЛИ некоторое утверждение верно, ТО делаем одно, а ИНАЧЕ делаем другое. Например, ЕСЛИ на улице жарко, ТО наденем футболку, а ИНАЧЕ – свитер. Выделенные мною слова – ключевые в этом рассуждении. Переведя их на английский, получим условный оператор языка Паскаль.

Существуют два варианта условного оператора – полный и неполный. Полный оператор выражается тремя ключевыми словами: IF – «если», THEN – «то» и ELSE – «иначе», и записывается он так:

IF <условие> THEN <Оператор_1> ELSE <Оператор_2>

Первый оператор выполняется, если условие верно, а второй – если ложно. Стало быть, условный оператор – это сложная конструкция, которая включает в себя другие операторы.

Теперь обратимся к условию, что это такое? Если я скажу, что это логическое выражение, вы ничего не поймете. С логическими выражениями мы скоро разберемся досконально, а здесь ограничимся лишь примером. Воспользуемся простейшим логическим выражением, которое заключается в сравнении двух строк. Предположим, что переменная S содержит введенный пользователем пароль, тогда условный оператор проверки пароля будет таким.


      if S = ’pascal’  then Writeln(’Проходите!’) else Writeln (’Стойте!’)


Здесь логическое выражение выделено курсивом. То же самое можно записать чуть иначе.


if ’pascal’ = S 

      then Writeln(’Проходите!’)

      else Writeln (’Стойте!’)


Теперь переменная S и константа «pascal» поменялись местами, и это никак не сказалось на условном операторе, поскольку знак равенства в логических выражениях означает сравнение (а не присваивание!).

Части условного оператора THEN и ELSE называют ветвями (положительной и отрицательной соответственно). Стало быть, и условие, и ветви оператора можно размещать в нескольких строках – это удобно как для чтения, так и для отладки программ.

В главе 7 мы познакомились с графическим изображением алгоритмов. Существуют лишь три базовые управляющие конструкции, из которых вяжется хитроумная паутина современных программ: 1) линейная последовательность, 2) условный переход и 3) цикл. Условный оператор Паскаля – это и есть один из вариантов условного перехода. На блок-схемах его изображают так (рис. 23).






Рис.23 – Блок схема полного условного оператора

Внутри ромбика или рядом с ним обычно показывают проверяемое условие, а положительную и отрицательную ветви располагают слева и справа от него.


Пост номер один

Вам понятен условный оператор? Тогда обратимся к программе-часовому. Вероятно, вы написали её раньше меня, и нам осталось лишь сверить варианты.


var S : string;

begin

Writeln(’Пароль?’); Readln(S);

if S = ’pascal’

      then Writeln(’Проходите!’)

      else Writeln(’Стойте!’);

Writeln(’Нажмите Enter’); Readln;

end.


Почему после оператора Writeln(’Проходите!’) не видно разделителя – точки с запятой? Потому, что внутри условного оператора разделители не ставят! Другое дело – оператор Writeln(’Стойте!’). Здесь заканчивается условный оператор IF, и точка с запятой уместна – она разделяет операторы. Попробуйте нарушить эту запись и узнать мнение компилятора.


Неполный условный оператор

Что за окном? нет ли дождя? ЕСЛИ дождь идет, ТО прихватите зонтик. В этом кратком рассуждении нет отрицательной ветви, поскольку в ней никаких действий не предусмотрено. В таких случаях отрицательную ветвь отбрасывают и получают неполный условный оператор.

IF <условие> THEN <Оператор>

Блок-схема такого оператора показана на рис. 24.






Рис.24 – Блок-схема неполного условного оператора

Пост номер два

Применим неполный условный оператор ко второй версии электронного часового – программе «P_10_2».


var S, R : string;

begin

Writeln(’Пароль?’); Readln(S);

R:= ’Стойте!’;

if S = ’pascal’

      then R:= ’Проходите!’;

Writeln(R);

Writeln(’Нажмите Enter’); Readln;

end.


Здесь для хранения решения введена переменная R, в которую изначально помещается суровое «Стойте!». После успешной проверки пароля значение переменной меняется на благосклонное «Проходите!», а затем решение выводится на экран.

Откомпилируйте и проверьте оба варианта часового. «Поиграйте» с ошибками компиляции. Если компиляция прошла гладко, внесите ошибки сознательно и исследуйте реакцию компилятора.

Теперь вы познакомились с двумя вариантами условного оператора. Ни один серьезный алгоритм не обходится без них. Скоро вам доведется изобретать весьма хитрые алгоритмы и рисовать блок-схемы для них. Значит, надо привыкать к блок-схемам; на рис. 25 представлены схемы наших программ.






Рис.25 – Блок-схемы программ с полным и неполным условными операторами

Итоги

• Условный оператор изменяет порядок действий в зависимости от некоторого условия; оператор может быть полным или неполным.

• Полный условный оператор состоит из условия IF и двух ветвей: положительной – THEN, и отрицательной – ELSE. В каждую из ветвей можно поместить по одному вложенному оператору.

• Неполный условный оператор состоит из условия IF и положительной ветви THEN.


А слабо?

А) В программах для часового укажите начало и конец условного оператора (то есть, первый и последний его символ, включая вложенные операторы).

Б) Напишите программу, которая спрашивает, идет ли дождь, и на ответ «да» выводит сообщение «А зонта-то у тебя нет!». Воспользуйтесь неполным условным оператором.

Глава 11

Операторный блок

 Сделать закладку на этом месте книги




Электронный часовой из 10-й главы пропускает только знающих пароль. Расширим круг его обязанностей. Пусть часовой, приняв верный пароль, отдаст ещё несколько команд, как то: «Распахнуть ворота! Оркестр, музыку!». А для нарушителей команды будут такими: «Тревога! Задержать его!». Разумеется, что команды будут выводиться на экран, причем каждая – в отдельной строке. Усеченная блок-схема программы показана на рис. 26.






Рис.26 – Блок схема часового, подающего дополнительные команды

Операторные скобки

На первый взгляд все ясно, как белый день: если пароль верный, то отдаем команды, что показаны на блок-схеме слева, а иначе те, что справа. Каждую команду выводим отдельным оператором, – так они окажутся в отдельных строках.


if S = ’pascal’

      then Writeln(’Распахнуть ворота!’);

      Writeln(’Оркестр, музыку!’);

      Writeln(’Проходите!’);

      else Writeln(’Тревога!’);

      Writeln(’Задержать его!’);


Добавьте в программу часового все это и откомпилируйте. Что, не вышло? Тут обнажилась проблема с подряд идущими операторами печати. По правилам языка, они разделяются точками с запятой, не так ли? Но разделители «порежут» на части и условный оператор IF-THEN-ELSE, а это недопустимо! Наткнувшись на показанную выше конструкцию, компилятор заявит вам прямо в глаза о синтаксической ошибке. Ведь в каждой ветви условного оператора допускается лишь по одному вложенному оператору, где выход?

«Вероятно, в Паскале что-то предусмотрено на сей счет» – заподозрите вы. Конечно! Здесь выручит операторный блок, который превращает группу операторов в один, скрывая внутри себя разделители – точки с запятой. Блок организуют знакомой вам парой ключевых слов BEGIN и END. В нашей программе эти слова надо втиснуть в ветви условного оператора так:


if S = ’pascal’

      then begin 

      Writeln(’Распахнуть ворота!’);

      Writeln(’Оркестр, музыку!’);

      Writeln(’Проходите!’)

      end 

      else begin 

      Writeln(’Тревога!’);

      Writeln(’Задержать его!’)

      end ;


Как видите, внутри блока BEGIN-END разделители ставят как обычно – для разграничения операторов.

А сколько операторов вместится в блок BEGIN-END? Да сколько угодно! Блок может быть и пустым, – иногда это оправдано. Предположим, вы ещё точно не решили, что будет внутри ветви: один оператор или больше. Тогда вставьте здесь пустой блок BEGIN-END, а затем думайте дальше. Вставка лишних блоков не влияет на программу, но может уберечь от синтаксических и логических ошибок.

И последний вопрос: почему после END нет точки? Ведь мы ставим её в конце программы! Да, но окончание программы – это единственный случай, когда после END ставится точка.


Красиво жить не запретишь

Вероятно, вы заметили, что ветви THEN и ELSE условного оператора расположены с отступом вправо. Что это, требование языка? Ничуть. Вы вправе написать программу даже в одну строку, и компилятор «проглотит» её. Но каково будет разбираться в такой программе вам или вашему приятелю?

Отступы в программе сделаны для удобства чтения. Строгих правил по этой части нет; оформление – дело вкуса. Но сложились традиции, следование которым облегчит жизнь и вам, и тем, кто будет читать ваши программы. Главная идея оформления программ состоит в выделении логических уровней. Что это такое? В данном примере это ветви THEN и ELSE, – они должны быть хорошо видны в тексте. Полезно, также, выделять блоки операторов. Для этого можно поместить слова BEGIN и END друг под другом, а содержимое блока сдвинуть относительно них вправо.

Разбирая примеры, вы со временем научитесь разумно оформлять свои программы, – лучше раз увидеть, чем стократ услышать. Вот, в частности, другой вариант оформления программы «P_11_1», где обе ветви условного оператора прекрасно видны, хотя скобки begin-end и не расположены друг под другом.


var S : string;

begin

      Writeln(’Пароль?’); Readln(S);

      if S = ’pascal’ then begin 

      Writeln(’Распахнуть ворота!’);

      Writeln(’Оркестр, музыку!’);

      Writeln(’Проходите!’)

      end  else begin 

      Writeln(’Тревога!’);

      Writeln(’Задержать его!’)

      end ;

      Writeln(’Нажмите Enter’); Readln;

end.



Комментарии

Раз уж мы коснулись оформления, рассмотрим ещё одно средство Паскаля – комментарии, которые служат для пояснения программ. Комментарий – это произвольный текст, заключенный в фигурные скобки {…}, или в круглые скобки со звездочкой (*…*). Вот примеры комментариев.


{ Комментарий в одной строке }

{ Многострочный

комментарий

}

(* Комментарий в скобках со звездочками *)


А как воспринимает их компилятор? Да никак. Найдя начало комментария, компилятор ищет его окончание, а все, что оказалось внутри ограничителей, «пропускает мимо ушей». Поэтому комментарии не оказывают влияния на программу. Есть только одно исключение, о котором я скажу в своё время, повествуя о директивах компилятора. Последующие программы я буду сопровождать комментариями.

Программисты нередко используют комментарии как «шапку-невидимку». О чем я? Иногда – при поиске ошибок – требуется временно исключить часть операторов из программы. Вместо того чтобы удалять, а затем печатать их заново, лучше закомментировать эту часть текста. То есть, заключить ненужные операторы в фигурные скобки, превратив в комментарий. Такой кусок программы легко восстановить, удалив фигурные скобки.

Примечание.  В современных версиях Паскаля и в других языках применяют ещё и однострочный комментарий, который отделяется двумя косыми черточками только с левой стороны.


      A:= B;       // Копирование переменой – это однострочный комментарий



Итоги

• Операторные скобки BEGIN-END объединяют несколько операторов в один операторный блок. Операторный блок воспринимается как один оператор.

• Форматирование программы – это оформление её с помощью логических отступов. Форматирование не влияет на программу, но облегчает её чтение.

• Комментарии предназначены для включения в программу пояснений. Комментарии пропускаются компилятором и не влияют на программу.

• Комментарии удобны для временного исключения частей программы.


А слабо?

А) Сколько операторов можно поместить в операторном блоке?

Б) Найдите ошибку в этом кусочке программы, проверьте свое решение на компьютере.


      Writeln(’Что дождь? Все ещё идет?’); Readln(S);

      if S = ’ага’ then

      begin

      Writeln(’А зонтик ты так и не купил!’);

      Writeln(’Сколько раз напоминать?’);

      end;

      else begin

      Writeln(’На этот раз тебе повезло!’);

      end;

Глава 12

Цикл с проверкой в конце

 Сделать закладку на этом месте книги





Подтянем дисциплину

Продолжим воспитывать нашего часового, он ещё нуждается в этом. Проверяя каждого встречного-поперечного, мы принуждены вновь и вновь запускать свою программу. А все потому, что часовой покидает свой пост без команды, самовольно. Пусть программа проверяет посетителей одного за другим до тех пор, пока мы не скомандуем «отставить!».

Для этого заставим программу «бегать по кругу» так, чтобы она возвращалась к операторам, исполнявшимся ранее. Повторение одних и тех же действий называют циклом. Иногда цикл называют переходом назад. Блок-схема предстоящей программы показана на рис. 27.






Рис.27 – Блок-схема циклического часового

Схема содержит два условных перехода, причем второй из них должен, как говорят программисты, передать управление назад, к началу программы. Сейчас нам предстоит, во-первых, найти способ отдать часовому команду покинуть пост и, во-вторых, осуществить переход назад.

Для освобождения часового можно ввести специальную фразу. Например, вместо пароля напечатать фразу «отставить!» или «марш на кухню!». Ещё проще сделать это пустой строкой, которая попадет в переменную S, если в ответ на запрос пароля пользователь, ничего не печатая, нажмет клавишу Enter. Тогда условие завершения программы будет таким.


      if S = ’’ then …


Здесь справа от знака равенства стоят два апострофа, – это пустая строка (между апострофами нет пробела!).

Мы ответили на первый вопрос, но как перейти к началу программы? Не надейтесь на условный оператор, он тут не поможет! Обе его ветви следуют после проверки условия IF, поэтому условный оператор передает управление только вперед.


Нанимаем репетитора

Итак, условный оператор тут не помощник, но Паскаль не оставит вас в беде. Для организации циклов в нём предусмотрены три оператора, с одним из которых мы ознакомимся немедля. Программистам он известен как цикл с проверкой в конце, и записывается двумя ключевыми словами: REPEAT – «повторять» и UNTIL – «вплоть до».

Отчасти


убрать рекламу






«репетитор» похож на операторный блок BEGIN-END, рассмотренный нами в предыдущей главе. Вам надо повторять выполнение ряда операторов? Тогда поставьте слово REPEAT перед первым из них, а проверку условия UNTIL – за последним, и получите следующую конструкцию.


REPEAT

<Оператор 1>;

<Оператор 2>;

...

<Оператор N>

UNTIL условие


По-русски действие оператора можно изъяснить так: ПОВТОРЯТЬ следующие далее операторы, ПОКА условие НЕ соблюдается. На рис. 28 показана блок-схема такой циклической конструкции; здесь операторы 1 и 2 будут исполняться до тех пор, пока НЕ соблюдается условие в конце цикла. При соблюдении условия цикл прекратится, и выполнится оператор 3.

Примечание.  Сходство оператора цикла с блоком BEGIN-END состоит в том, что REPEAT-UNTIL тоже скрывает внутри себя разделители операторов – точки с запятой. Стало быть, он тоже формирует единый блок.






Рис.28 – Блок-схема оператора цикла с проверкой в конце

Воспользуемся циклом для очередной версии «киберчасового». За основу возьмем простейшую из предыдущих версий – программу «P_10_1». Поместив внутрь цикла REPEAT-UNTIL все исполняемые там операторы, получим желаемое – программу «P_12_1».


{ P_12_1 – программа-часовой с циклом }

var S : string;

begin

      repeat 

      Writeln(’Пароль?’); Readln(S);

      if S = ’pascal’

      then Writeln(’Проходите!’)

      else Writeln(’Стойте!’);

      until S=’’ ; { окончание цикла, если строка S пуста }

end.


Проверьте наше новое творение. Обратите внимание на комментарии внутри фигурных скобок, – я буду снабжать ими все последующие программы.


Вежливый часовой

Программа работает? Прекрасно! Но одна шероховатость меня удручает. Покидая пост, часовой почему-то поднимает лишний шум: «Стойте!» – кричит он. Кому он это кричит? своему командиру? Безобразие! Пусть при оставлении поста часовой не проверяет пароль. С этой целью добавим ещё один условный оператор, как показано на рис. 29.






Рис.29 – Блок-схема часового с корректным завершением

На этой блок-схеме оператор проверки пароля обведен пунктиром; получив команду о завершении работы, программа должна обойти его. Этому служит ещё один условный оператор, проверяющий, не пуста ли строка S.


      if S <> ’’ then …


Пара знаков «меньше»–«больше» в Паскале означает неравенство. Здесь положительная ветвь THEN будет выполнена, если строка S не будет пустой. Стало быть, это условие по смыслу противоположно условию IF S=’’.

А напоследок программа должна вежливо попрощаться, для чего добавим ещё пару операторов печати. Итак, создайте файл «P_12_2», скопируйте в него предыдущую версию программы и попытайтесь сами внести необходимые изменения, – нет ничего полезней самостоятельной работы! Справившись с задачей, взгляните на мой вариант, он показан ниже. А если не совладаете, тоже посмотрите.


{ P_12_2 – вежливый часовой }

var S : string;

begin

      repeat

      Writeln(’Пароль?’); Readln(S);

      { если строка не пуста, проверяем пароль }

      if S<>’’ then 

      if S = ’pascal’

      then Writeln(’Проходите!’)

      else Writeln(’Стойте!’);

      until S=’’;

      Writeln(’До встречи! Нажмите Enter’); Readln;

end.


Я расположил операторы с надлежащими отступами, выделяющими структуру программы. Проверьте, работает ли она?


Досрочный выход из цикла

С какой бы стороны придраться к нашему часовому? Ведь программа делает все, что положено. Но рассмотрим ещё один её вариант. Дело в том, что условные операторы внутри цикла порой загромождают и запутывают его. Это не относится к нашей теперешней программе, но мы ведь только в начале пути… Ждать ли, пока гром грянет? Или подготовиться к нему заранее? Познакомьтесь с процедурой по имени BREAK – «прервать» (боксерам знакомо это слово).

Условие завершения цикла, как вам известно, проверяется в точке UNTIL. Но порой это условие удобней проверить где-то в середине цикла, и тогда цикл лучше прервать досрочно, вызвав процедуру BREAK следующим образом:


      if условие_выхода_из_цикла then Break;


Внимание:  вызов процедуры BREAK допустим только внутри циклов!

Посмотрите, как изменится блок-схема с оператором BREAK (рис. 30), здесь оператор принятия решения я заменил пунктирным прямоугольником.






Рис.30 – Блок-схема циклической программы с оператором Break

Согласно схеме, оператор BREAK передаст управление в точку, следующую за UNTIL. Применительно к нашей программе условие досрочного выхода из цикла будет таким.


      if S=’’ then break;


Слегка изменив предыдущую версию программы, я получил вариант, показанный ниже.


{ P_12_3 – часовой с досрочным выходом из цикла }

var S : string;

begin

      repeat

      Writeln(’Пароль?’); Readln(S);

      { если строка пуста, то выход из цикла }

      if S=’’ then break ;

      if S = ’pascal’

      then Writeln(’Проходите!’)

      else Writeln(’Стойте!’)

      until S=’’;

      Writeln(’До встречи! Нажмите Enter’); Readln;

end.


Досрочный выход из цикла упрощает программу, но пользоваться им надо аккуратно, с умом. Не забывайте, что после BREAK программа переходит к оператору, следующему за UNTIL.


Итоги

• Оператор цикла REPEAT-UNTIL организует многократное повторение операторов, вставленных между этими ключевыми словами.

• Условие выхода из цикла следует за ключевым словом UNTIL, цикл повторяется до тех пор, пока условие НЕ соблюдается.

• Оператор BREAK выполняет досрочный выход из цикла с обходом условия в UNTIL.


А слабо?

А) Сколько операторов можно вставить между REPEAT и UNTIL?

Б) Будет ли проверяться условие в UNTIL при досрочном выходе из цикла?

В) Возьмите за основу программу «P_11_1» и переделайте ее в циклический вариант. Или слабо?

Г) Напишите программу для угадывания слова. Она должна запрашивать от пользователя строки, пока тот не введет слово, предусмотренное в программе.

Глава 13

Правда и кривда

 Сделать закладку на этом месте книги




Что приятней, получать подарки или дарить их? Сейчас узнаем: вот вам автомобиль – дарю! Будете в школу на нём гонять. Впрочем, мой подарок не бескорыстен, и взамен я жду вашей помощи.

«Автомобиль – не роскошь, а средство передвижения» – утверждал персонаж книги Ильфа и Петрова. Что бы сказал он сегодня, томясь в унылых пробках? Теперь и вы за рулем, значит, дорожные пробки – наша общая напасть. Так будем бороть её вместе! Ведь все для этого есть, – в каком веке то живем! Что ни автомобиль – то бортовой компьютер, а космос ломится от спутников! Создадим программу для бортового компьютера автомобиля. Компьютер будет принимать сигналы от спутников системы ГЛОНА́СС (это ГЛОба́льная НАвигацио́нная Спу́тниковая Систе́ма) и сообщать о дорожных пробках. К деталям этого проекта обратимся позже, а начнем, как водится, издалека – из космоса.


Есть ли жизнь на Марсе?

Об этом все ещё спорят ученые, не находя ответа. «Спросите что попроще, – скажете, – например, мой возраст». Но если бы здесь отвечал компьютер, то вопрос о Марсе он счел бы простым, а вопрос о возрасте – сложным. Почему?

А потому, что о марсианской жизни можно ответить односложно: «да» или «нет». А сообщая возраст, надо указать какое-то число или дату рождения. Ещё сложнее растолковать компьютеру, как выглядит, к примеру, цветок или бабочка, тут не отделаться одним числом, а тем паче ответом «да» или «нет». Такие вопросы требуют сложного ответа, несущего много информации. Стоп! Я упомянул информацию? Вот о ней – об информации – потолкуем подробней.


Информация и её мерило

Компьютер обрабатывает информацию, – это все знают. Только почему, соорудив столько программ, мы все ещё не знаем, что такое информация? Её трактуют по-разному, одно из определений таково: «информация – это то, что устраняет неопределенность». В самом деле, задавшись неким вопросом, мы испытываем неопределенность, а получив ответ, избавляемся от неё, и на душе становится легче.

Получить ответ – это значит получить информацию. А сколько мы при этом её получаем, чем измерить это количество? Математики догадались, что меньше всего информации заключено в односложном ответе: «да» или «нет». Это количество взято за мерило и названо битом (по-английски «BIT»). Крупные единицы информации содержат много битов: байт – восемь битов, 1 Кбайт (читается «кибибайт») – 1024 байта и так далее, – об этом можно прочитать в школьных учебниках. Стало быть, ответ на вопрос «быть или не быть?» содержит всего один бит информации, – компьютер считает такие вопросы простыми. Ответы на сложные вопросы (например, как выглядит то, или это) могут содержать миллионы байтов. В этом легко убедиться по размеру файла с какой-нибудь фотографией или фильмом.

Но вернемся к биту. Природная склонность компьютера к «простым» вопросам и односложным ответам объясняется устройством его электронной памяти, состоящей из битовых ячеек – триггеров. Не вдаваясь в технические детали, скажу лишь, что такая ячейка может находиться в одном из двух устойчивых состояний, которые часто обозначают цифрами «0» и «1». С тем же успехом их можно обозначить иначе, например: «да» и «нет». Или так: «истина» и «ложь», «правда» и «кривда», «крестик» и «нолик». Короче говоря, название – дело вкуса, важно лишь то, что триггер хранит один бит информации. Эта особенность компьютеров отразилась во многих языках программирования, в том числе в Паскале.


Булевы переменные

Итак, элемент памяти компьютера – триггер – хранит наименьшую порцию информации – один бит. А в Паскале есть надлежащий тип данных для хранения и обработки битов, он называется булевым (ударение на первом слоге) – по имени английского математика Буля. Другое название этого типа данных – логический. Булевы переменные объявляют так:


      var A, B, C : Boolean;


Здесь объявлены три переменных булевого типа.

Булевы переменные, подобно триггеру, могут содержать лишь одно из двух значений: TRUE – «истина» или FALSE – «ложь». Это зарезервированные слова Паскаля, и попытка присвоить логическим переменным другие значения будет пресечена компилятором. Вот примеры правильного обращения с булевыми переменными:


      A:= true;

      B:= false;

      C:= B;


А вот грубые ошибки:


      A:= ’true’;

      B:= ’false’;

      C:= ’B’;


Повторяю: TRUE и FALSE – это зарезервированные слова, а не строковые константы, они пишутся без апострофов.


Ввод и вывод булевых данных

Ввод и вывод – это первое и последнее звено в цепочке обработки данных. Прежде, чем обрабатывать данные, надо освоить их ввод и вывод. Рассмотрим, как это делается с булевыми данными.

С выводом проблем нет, поскольку процедура Writeln напечатает их словами «TRUE» и «FALSE». Вот небольшая программа, испытайте её.


var B : Boolean;

begin

      B:= false;       Writeln(B);

      B:= true;       Writeln(B);

end.


Вводить булевы данные чуть сложнее, поскольку процедура Readln, к сожалению, не умеет этого делать. Как быть? «Нормальные герои всегда идут в обход», – поется в песне. Осуществим хитрый манёвр: для ввода булевых значений воспользуемся переменной другого типа, например, строковой, а затем преобразуем введенную строку в булев тип.

Условимся, что значению TRUE будет соответствовать ввод в строковую переменную символа «1», а FALSE – любой другой строки. Тогда булево значение в переменную B можно ввести следующим манером.


var S : String;

      B : Boolean;

begin

      Writeln(’Введите “1” для TRUE и прочее – для FALSE’);

      Readln(S);

      if S=’1’ then B:= true else B:= false;

      Writeln(B); Readln

end.


Просто? Но можно сделать ещё проще, прибегнув к логическому выражению.


Логические выражения

Данные логического типа можно получать в результате не совсем обычных вычислений. В этих вычислениях порой не увидишь ни чисел, ни арифметических действий, – речь идет о логических выражениях. Например, сравнивая две строки, вы задаетесь вопросом, равны ли они? Ответом может быть либо «да», либо «нет», или, выражаясь на языке Паскаль, TRUE или FALSE. Следовательно, сравнение строк, которое мы применяли в условных и циклических операторах, – это логическое выражение. А раз так, то результат сравнения можно присвоить булевой переменной. В приведенном выше примере вместо условного оператора можно записать выражение:


      B := S=’1’;       { равносильно if S=’1’ then B:= true else B:= false }


Здесь справа от знака присваивания стоит логическое выражение S=’1’, и в переменную B попадет TRUE, если S будет содержать строку «1» и FALSE – в любом другом случае.

Булевы переменные и выражения применяют везде, где требуется проверка условия, например, в условном и циклическом операторах:


if B

      then... { выполняется, если B=true }

      else... { выполняется, если B=false }

repeat

      { цикл выполняется, пока B=false }

until B


Замечу здесь, что «if B then…» равносильно «if B=TRUE then…».

К чему ещё годны булевы данные? С ними производят логические операции, но к операциям обратимся чуть позже, – пора вернуться к нашей автомобильной задаче.


С высоты птичьего полета

Напомню, что мы работаем над программой для навигатора автомобиля, принимающего сигналы от спутников системы ГЛОНАСС. Из космоса прекрасно видны все улицы и пробки города. Пусть все возможные маршруты от дома до школы известны заранее, а спутник сообщает лишь о том, открыта ли для движения та или иная улица. Если улица открыта, спутник сообщает об этом значением TRUE, а иначе – значением FALSE. Увы, к настоящему спутнику мы пока не подключены, и вводить данные о пробках придется вручную. Результатом работы нашей программы будет сообщение о том, можно ли проехать в школу (TRUE), или нет (FALSE).

Вот первый маршрут. Предположим, путь от дома до школы пролегает по двум улицам так, как показано на рис. 31.






Рис.31 – – Схема первого маршрута

Очевидно, что отразить состояние двух улиц можно двумя булевыми переменными, назовем их A и B. Объявим переменные и введем данные в них.


var A, B : Boolean; S: string;

begin

      Write(’Улица A открыта? ’); Readln(S); A:= S=’1’;

      Write(’Улица B открыта? ’); Readln(S); B:= S=’1’;


Здесь, как мы условились раньше, значение TRUE вводится цифрой «1».

Обратите внимание на новую для вас процедуру Write, – это «младшая сестра» процедуры Writeln. В отличие от «старшей сестры», после вывода сообщения она не переводит курсор на следующую строчку, – это удобно при запросе данных.

Ну-с, данные со спутника введены, и можно заняться их обработкой. Ясно, что для проезда в школу обе улицы должны быть открыты. Условными операторами это нехитрое рассуждение можно выразить так:


      S:=’Топай пешком’;

      if A then

      if B then S:=’Поезжай на машине!’;


Исходное значение – «Топай пешком» – заносим в переменную S заранее. Оно изменится тогда, когда обе булевы переменные станут равны TRUE. Согласитесь, это решение из двух условных операторов оказалось несложным. Но до поры до времени. Что, если маршрутов станет много, и каждый будет пролегать через несколько улиц? Программа превратится в нагромождение условных операторов, больше похожее на хаос землетрясения! Страшно? Тогда рассмотрим другой подход. Суть его в том, чтобы выразить решение на обычном человеческом языке, а затем превратить это высказывание в логическое выражение.

Решение нашей задачи можно высказать так: «проехать можно, если открыта улица A И открыта улица B». Обратите внимание на выделенный курсивом союз «И». Чтобы превратить это рассуждение в логическое выражение и записать на Паскале, надо лишь перевести союз «И» на английский язык – это будет «AND», а названия улиц заменить логическими переменными A и B. И вот результат такого перевода.


      if A and B

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;


Вместо двух условных операторов остался один. Готовая программа будет такой.


{ P_13_1 – первый маршрут проезда }

var A, B : Boolean; S: string;

begin

      { ввод данных со «спутника» }

      Write(’Улица A:’); Readln(S); A:= S=’1’;

      Write(’Улица B:’); Readln(S); B:= S=’1’;

      { решение }

      if A and B 

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;

      Writeln(S); Readln

end.


Испытайте программу при разных сочетаниях входных данных и проверьте, не врёт ли она?

Теперь рассмотрим другой маршрут, здесь попасть в школу можно по любой из двух улиц (рис. 32).






Рис.32 – Схема проезда, второй вариант

Обычным языком молвим так: «проезд возможен, если открыта улица A ИЛИ  открыта улица B». Союз «ИЛИ » тоже припасен в Паскале, по-английски он пишется «OR». В этом случае решение будет таким.


      if A or B 

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;


А вот маршрут на рис. 33 более замысловат.






Рис.33 – Схема проезда, третий вариант

Слабо ли вам выразить решение для этого случая? Сказать на обычном языке легко: «проехать можно, если открыта A И открыта B ИЛИ  открыта C И открыта D ИЛИ  открыта E». Слово «улица» я пропустил. Все, решение готово! Осталось лишь перевести его на язык Паскаль.


      if A and B or C and D or E 

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;


Как просто! Здесь опять выделено курсивом логическое выражение. Только теперь оно составлено из булевых переменных и булевых операций AND (И) и OR (ИЛИ). Иногда эти операции называют логическим умножением и логическим сложением. Сходство с арифметикой здесь в том, что каждая логическая операция обладает в выражении своим старшинством: умножение AND выполняется раньше сложения OR. Когда эту последовательность надо изменить, применяют скобки. Пример такого рода показан на рис. 34 (перекресток).






Рис.34 – Схема проезда, четвертый вариант

Сначала скажем словами: «проехать можно, если открыта A ИЛИ  открыта B И открыта C ИЛИ  открыта D». Переведя на Паскаль буквально, без скобок, получим:


      if A or B and C or D 

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;


Поскольку логическое умножение выполняется раньше сложения, Паскаль поймет это так: A or (B and C) or D.  Но это не то, что мы хотели! Правильно будет записать наше решение со скобками:


      if (A or B) and (C or D) 

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;


Наконец, рассмотрим маршрут на рис. 35, где путь преграждает шлагбаум. Договоримся, что закрытому шлагбауму соответствует значение TRUE (то есть, в сравнении с улицами тут все наоборот).






Рис.35 – Схема проезда, пятый вариант

Рассуждая как обычно, скажем так: «проезд возможен, если НЕ  закрыт шлагбаум». Здесь применено логическое отрицание НЕ , что по английски значит «NOT». Решение на Паскале будет таким.


      if not A 

      then S:=’Поезжай на машине!’

      else S:=’Топай пешком!’;


В отличие от двух предыдущих операций, логическое отрицание – одноместная операция, ей нужен лишь один операнд. Логическое отрицание имеет наивысший приоритет, и выполняется раньше логического умножения и сложения.


Парад логических операций

Итак, посредством логических операций мы переводим рассуждения с человеческого языка на формальный язык программирования, получая при этом логические (булевы) выражения. Логические данные в Паскале можно сравнивать и выполнять с ними четыре логические операции, три из которых вам уже знакомы. Рассмотрим свойства этих операций.

Логическое отрицание  NOT («НЕ») . Имеет наивысший приоритет, то есть, при отсутствии скобок выполняется в первую очередь. Это одноместная операция, поскольку требует лишь одного операнда. По своему действию она напоминает знак «минус» для чисел, поскольку изменяет значение операнда на противоположное. Правила для этой операции таковы.


NOT FALSE = TRUE

NOT TRUE = FALSE


Логическое умножение  AND («И»).  Приоритет ниже, чем у NOT, но выше, чем у логического сложения OR. Требует двух операндов, и в результате дает TRUE, если оба операнда равны TRUE.


FALSE AND FALSE = FALSE

FALSE AND TRUE = FALSE

TRUE AND FALSE = FALSE

TRUE AND TRUE = TRUE


Логическое сложение  OR («ИЛИ»).  Приоритет самый низкий, – выполняется в последнюю очередь. Требует двух операндов и в результате дает TRUE, если хотя бы один из операндов равен TRUE.


FALSE OR FALSE = FALSE

FALSE OR TRUE = TRUE

TRUE OR FALSE = TRUE

TRUE OR TRUE = TRUE



Итоги

• Информация – это то, что устраняет неопределенность.

• Получая ответ на вопрос, мы получаем информацию. Количество информации можно измерить.

• Наименьшая порция информации – бит – содержится в ответе на простой вопрос («да» или «нет»). Это количество принято за единицу измерения информации.

• Память компьютера состоит из элементарных ячеек – триггеров, каждый из которых хранит один бит информации. Восемь битов составляют один байт.

• Подобие триггеров в Паскале – булевы (логические) переменные. Они принимают только одно из двух значений: TRUE (истина) или FALSE (ложь).

• Булевы переменные в сочетании с логическими операциями OR, AND, NOT и скобками образуют булево выражение. Скобки нужны для изменения естественного порядка выполнения операций.

• Булевы выражения используют в условных и циклических операторах.


А слабо?

А) Что будет напечатано в результате выполнения следующего фрагмента?


      S:=’123’;

      Writeln (’123’=S);


Б) Переведите на русский язык это выражение.


      if (S=’’) and (A or B) then …


В) Напишите программу к бортовому компьютеру для маршрута на рис. 36.






Рис.36 – Схема проезда к задаче «В»

Г) В переменные M1, M2 и M3 вводится итог подбрасывания трех монет так, что TRUE соответствует «орел», а FALSE – «решка». Надо составить пять выражений таких, чтобы они выдавали TRUE для следующих случаев:

• у всех монет выпал «орел»;

• у всех монет выпала «решка»;

• все монеты упали одинаково;

• у первой – «решка», у прочих – «орел»;

• у первой – «орел», а две остальные упали одинаково.

Подсказка: логические данные можно сравнивать; сравнение обладает самым низким приоритетом, и потому внутри выражений заключается в скобки, например: M1 and (M2=M3).

Глава 14

Дважды два – четыре

 Сделать закладку на этом месте книги




Первые компьютеры назывались электронными вычислительными машинами (ЭВМ). Хотите – верьте, хотите – нет, но тогда на них не документы печатали и не фильмы смотрели, а вычисляли. С тех пор компьютеры научились многому и даже обыгрывают в шахматы чемпионов мира, однако, их способность к счету по-прежнему в цене.


Поможем братьям нашим меньшим

Пора и нам обратиться к вычислительным талантам компьютера. Не будем тратить попусту время, и по ходу дела соорудим полезную программу. Вы сможете испытать её на живом человеке, если найдёте первоклашку, зубрящего таблицу умножения. Уверен, что он с удовольствием подвергнет себя такому испытанию. Итак, наша очередная программа – экзаменатор. Суть её проста: компьютер предлагает ученику два числа и ждет от него ответа – произведения этих чисел. За правильный ответ ученика поощряют, а иначе его ждет «нахлобучка».


Числа и действия с ними

Скажу честно: знакомых нам типов данных – STRING и BOOLEAN – не хватит для решения поставленной задачи. Для вычислений в Паскале припасены другие типы данных, один из которых называется INTEGER, что переводится как целое. Из названия следует, что переменные такого типа могут хранить целые числа (положительные и отрицательные), например 10, 25, -14. Переменные целого типа объявляют следующим образом:


var N, M : integer;


Таким переменным можно присваивать выражения целого типа, состоящие из чисел, арифметических операций, скобок и других переменных, например:


      N := 19; M :=-25;

      M := 20 + 3*N;


К арифметическим операциям относятся:

• сложение (+) и вычитание (–);

• умножение (*) и деление (DIV);

• нахождение остатка от деления (MOD).

Здесь DIV и MOD – это ключевые слова языка. Примеры деления и нахождения остатка показаны ниже (в комментариях указаны результаты).


      N := 10 div 2; { =5 }       M := 10 mod 2; { =0 }

      N := 10 div 3; { =3 }       M := 10 mod 3; { =1 }

      N := 10 div 4; { =2 }       M := 10 mod 4; { =2 }

      N := 10 div 5; { =2 }       M := 10 mod 5; { =0 }

      N := 10 div 6; { =1 }       M := 10 mod 6; { =4 }


Как видите, операции с целыми числами дают целый результат даже при делении, поскольку дробная часть отбрасывается.

Числовые переменные и выражения можно сравнивать между собой на равенство (=), неравенство (<>), больше (>), меньше (<), больше или равно (>=), меньше или равно (<=). При сравнении получается, как всегда, булев результат, например:


var X, Y: integer;

      B: Boolean;

begin

      X:=5;       Y:=10;

      B:= X=Y; { B = FA


убрать рекламу






LSE }

      B:= X<Y; { B = TRUE }

      B:= X=Y-5; { B = TRUE }

end.


А как быть с вводом и выводом числовых данных, нет ли тут сложностей? К счастью, нет. Так же как и строки, числовые данные вводятся процедурой Readln, а печатаются процедурами Write и Writeln, например:


      Readln(X);

      Writeln(X);

      Writeln(’Y=’, X+10);


В последнем операторе на экран выводится строковая константа ’Y=’ и результат сложения X+10.

Теперь вы снабжены всем необходимым для написания экзаменатора.


Алгоритм экзаменатора

Прежде всего, уточним алгоритм создаваемой программы. Живой экзаменатор сам придумывает примеры для умножения. Но нам это пока не под силу – маловато знаний – отложим этот вариант до следующей главы. А пока экзаменуемый будет сам «создавать себе проблемы», то есть будет вводить сомножители по запросу программы вручную. Пример диалога может выглядеть, например, так:


Первый сомножитель A = 7 

Второй сомножитель B = 7 

Произведение A*B = 47 

Ошибка, повтори таблицу умножения!


И так далее. Здесь выделенные курсивом числа 7, 7 и 47 пользователь ввел сам. Разумеется, что задания надо решать многократно, в цикле. Для выхода из цикла нужен какой-то признак, сигнал. Пусть таким сигналом будет ввод нуля в качестве ответа. Тогда блок-схема программы получается такой (рис. 37).






Рис.37 – Блок-схема программы проверки таблицы умножения

Обратите внимание на условие в операторе цикла REPEAT-UNTIL, – оно равно FALSE. Такой цикл будет продолжаться бесконечно, и выйти из него можно лишь процедурой BREAK, как показано на блок-схеме.


Экзаменатор, первый вариант

Вот теперь все готово для написания следующей программы.


{ P_14_1 – экзаменатор таблицы умножения, первый вариант }

var A, B, C : integer; { сомножители и произведение }

      R: Boolean; { результат сравнения }

      S: string;       { сообщение для вывода на экран }

begin

      repeat

      { ввод сомножителей и произведения }

      Write(’Первый сомножитель A = ’); Readln(A);

      Write(’Второй сомножитель B = ’); Readln(B);

      Write(’Произведение A*B = ’); Readln(C);

      if C=0 then break; { завершение цикла, если C=0 }

      { проверяем правильность вычисления }

      R:= A*B=C; { R=true, если верно }

      if R

      then S:= ’Молодец, правильно!’

      else S:= ’Ошибка, повтори таблицу умножения!’;

      Writeln(S);

      until false; { бесконечный цикл }

end.


Запустите программу и проверьте её работу. В следующий раз мы научим её придумывать сомножители, – так будет честнее. А пока подведем итоги.


Итоги

• Для вычислений в Паскале предусмотрены данные числового типа (INTEGER).

• К данным целого типа могут применяться четыре арифметических операции, а также операция нахождения остатка от деления.

• В результате сравнения численных данных получается булев результат, который может быть применен везде, где проверяется условие.

• Числовые данные вводятся оператором Readln и выводятся операторами Write и Writeln;

• Числовым переменным нельзя присваивать строковые значения и наоборот: строковым переменным нельзя присваивать числовые значения.


А слабо?

А) Найдите ошибки в следующей программе и объясните их.


var N, M : integer;

      S : string;

begin

      N:= ’10’;

      S:= N + 5;

      M:= S – 1;

      if S=N then;

end.


Проверьте свои догадки, призвав на помощь компилятор.

Б) Перепишите программу «P_14_1», не прибегая к процедуре Break. В чем, по-вашему, слабость этого второго варианта? Можно ли обойтись в программе «P_14_1» без булевой переменной R и строковой S? Напишите такой вариант программы. Или слабо?

В) Пусть программа запросит три числа: A, B и C, а затем напечатает большее из них. Подсказка: примените булевы выражения вкупе с операциями сравнения, которые в булевых выражениях надо заключать в скобки, например:


      if (A>=B) and (A>=C) then...


Примечание.  Скобки ставят по той причине, что булевы операции можно выполнять и с числами, и такие операции приоритетней операций сравнения. О применении логических операций к числам сказано в главе 48.

Г) В стене прорублено прямоугольное сквозное отверстие со сторонами A и B. Пусть ваши программы разберутся, пройдет ли в него кирпич с ребрами X, Y, Z. Сделайте две программы для таких случаев:

• Известно, что A<B и X<Y<Z.

• Соотношение между сторонами неизвестно, и программе самой надо выяснить высоту и ширину, как отверстия, так и кирпича.

Д) Площадь земельного участка вычисляется умножением его сторон A и B. В программу вводятся стороны двух участков (A1, B1 и A2, B2), пусть она напечатает ширину и длину того участка, что больше по площади. Ширина должна быть не больше длины.

Глава 15

Айда в Монте-Карло!

 Сделать закладку на этом месте книги




Монте-Карло – весёлый пригород в княжестве Монако, славный своими игорными заведениями. Там, по словам Поэта, жертвуют необходимым в надежде приобрести излишнее. Но к чему нам игорный бизнес, – спросите, – когда мы заняты программой-экзаменатором? Не забывайте, однако, что наш первоклашка пока ещё сам придумывает себе примеры, а это неразумно. Избавим его от ввода сомножителей, – пусть программа сама «изобретает» их. Потому и обращаемся к азартным играм.


Куда ни глянь – то процедура, то функция!

Современные программы очень сложны. И, как любое крупное изделие, заключают в себе труд десятков и сотен специалистов. Трудно поверить, но большинство программистов, работающих над крупным проектом, не видят его в целом, что не мешает им выполнять свою часть работы. Как такое возможно?

Чтобы понять это, оглянитесь вокруг. Обойдутся ли жители города или страны друг без друга? Кем бы ты ни был – врачом, водителем или сапожником – не проживешь без услуг иных граждан, – все мы зависим друг от друга! Но спросите, к примеру, сталевара, куда пойдет выплавляемая им сталь? Он только плечами пожмет!

Работа программистов организована по тем же законам – законам специализации и кооперации. Специализация – это углубление в некоторую узкую область, специальность. Скажем, одни программисты наловчились писать драйверы, другие – базы данных, а третьи – графический интерфейс. Кооперация – это слаженное соединение усилий разных специалистов, – за это отвечает руководящая «верхушка» программного проекта (подобно тому, как правительство руководит страной).

Конечно, «руками водить», распределяя работу, может каждый (некоторые так и думают). Но толку будет чуть, если согласованную работу программистов не поддержать техническими средствами. Современные языки программирования, в том числе Паскаль, такие средства дают. Одно из них – механизм процедур и функций. Процедуры и функции – это готовые «кусочки» программ, выполняющие некоторые оговоренные действия. Иногда их называют общим именем – подпрограммы. Такие «кусочки» могут создаваться разными программистами и сохраняться в специальных файлах – библиотеках. Есть библиотеки и в Паскале.

Для применения библиотечной процедуры или функции достаточно знать её имя и список передаваемых ей параметров. А вот думать о том, как устроена эта процедура внутри, не обязательно. Хочешь выполнить какое-то действие из библиотеки? Тогда помести в нужном месте программы вызов подходящей процедуры и укажи параметры. Кстати, мы с вами уже делаем это, вызывая процедуры Readln и Writeln. В библиотеках Паскаля припасены процедуры и функции на многие случаи жизни, со временем вы узнаете о них больше.

Чем же отличаются функции от процедур? Функции обладают теми же возможностями, что и процедуры, но вдобавок возвращают значение некоторого типа (числовое, логическое или иное). Поэтому вызов функции можно вставлять внутрь выражения, что очень удобно. Как это работает, вы увидите сей же час.


Госпожа удача

Вернемся к нашему экзаменатору, где надо придумать способ формирования случайных чисел в пределах от 1 до 10. Будь под рукой игральный кубик из Монте-Карло, я бы не связывался с компьютером! Впрочем, в библиотеке Паскаля есть такой «кубик» – это функция по имени Random, что переводится как «случайный, беспорядочный». Этой функции необходимо задать один параметр – число N, определяющее предел для случайного числа. В ответ функция возвращает некоторое случайное число в диапазоне от нуля до N-1. Например, в следующем операторе в переменную X попадет некоторое число в диапазоне от 0 до 9.


      X:= Random(10);


Говорят, что функция Random генерирует случайные числа. Чтобы лучше понять, как это работает, введите и запустите следующую программу.


{ P_15_1 – пятикратный вызов функции Random(100) }

begin

      Writeln( Random(100) );

      Writeln( Random(100) );

      Writeln( Random(100) );

      Writeln( Random(100) );

      Writeln( Random(100) );

      Readln;

end.


Здесь печатаются целые числа, возвращаемые функцией Random. И хотя параметр функции во всех вызовах одинаков (100), результаты получатся разными. При этом все они лежат в диапазоне от 0 до 99. Таким образом, параметр функции Random управляет диапазоном генерируемых чисел.

Запустите эту программу ещё пару раз и сравните результаты. Вы заметили, что они повторяются? Так и должно быть! Все потому, что функция Random создает псевдослучайную последовательность чисел. «Псевдо» – значит «не совсем случайную». Эта особенность функции полезна при отладке программ. Но в экзаменующей программе надо получать разные последовательности чисел, иначе смышленые школяры приноровятся к экзаменатору!

Этого можно добиться применением ещё одной процедуры. Она называется Randomize (что значит «уравнять шансы» или «перемешать») и не требует параметров. Вызвав эту процедуру единожды в начале программы, мы смешаем карты и заставим функцию Random при повторных запусках программы генерировать разные последовательности чисел. Итак, вставьте вызов процедуры Randomize в начало программы и повторите опыты, запустив программу несколько раз подряд.


{ P_15_2 – пятикратный вызов функции Random(100) после Randomize }

Begin

      Randomize ;

      Writeln( Random(100) );

      Writeln( Random(100) );

      Writeln( Random(100) );

      Writeln( Random(100) );

      Writeln( Random(100) );

      Readln;

end.


Теперь от успешного финиша проекта нас отделяет один шаг: придумаем способ генерировать числа от 1 до 10 (а не от 0 до 9). Очевидно, что простое арифметическое выражение решает эту проблему.


      X:= 1+ Random(10);       { генерация чисел от 1 до 10 }


Сейчас вы готовы написать второй вариант экзаменатора, вот каким он может быть (новые операторы, как обычно, выделены курсивом).


{ P_15_3 – программа-экзаменатор, версия 2 }

var A, B, C : integer; { сомножители и произведение }

begin

      Randomize ; { смешиваем «карты» }

      repeat

      A:= 1+ Random(10);        B:= 1+ Random(10); 

      Write(’Сколько будет ’, A,’ x ’,B, ’ ? ’); 

      Readln(C);

      if C=0 then break; { завершение цикла, если C=0 }

      { проверяем правильность вычисления }

      if A*B=C

      then Writeln(’Молодец, правильно!’)

      else Writeln(’Ошибка, повтори таблицу умножения!’);

      until false; { бесконечный цикл! }

end.


Обратите внимание на вывод задания для умножения.


      Write(’Сколько будет ’, A,’ x ’,B, ’ ? ’);


Здесь процедура Write содержит уже пять параметров: две числовые переменные и три строковые константы. Так, при A=3 и B=7 на экране появится вопрос: «Сколько будет 3 x 7 ?». Остальные операторы программы обойдутся без моих пояснений.


Итоги

• В языках программирования предусмотрены средства для согласованной работы программистов, одно из них – библиотеки процедур и функций.

• Отличие процедур от функций состоит в том, что процедура лишь выполняет оговоренные действия, а функция вдобавок возвращает данные некоторого типа.

• Для генерации случайных последовательностей чисел применяют функцию Random и процедуру Randomize.

• Функция Random(N) возвращает псевдослучайное число, лежащее в пределах от 0 до N-1. При повторных запусках программы эта серия чисел повторяется, если заранее не вызвана процедура Randomize.

• Вызов процедуры Randomize в начале программы приводит к генерации функцией Random разных серий псевдослучайных чисел.


А слабо?

А) В каких пределах будут генерироваться числа следующими выражениями:

10+Random(10);

Random(20);

Random(10) + Random(10);

Random(5) + Random(5) + Random(5) + Random(5);

Проверьте себя на компьютере!

Б) Сколько чисел будет напечатано следующей программой? Испытайте на практике.


var x : integer;

begin

      repeat

      x := Random(20);

      Writeln(x);

      until x=1;

end.


В) А если в начало предыдущей программы вставить Randomize? Можно ли предсказать результат? Или слабо?

Г) Найдите способ сформировать ряд случайных булевых значений (False, True), напечатайте 20 из них. Подсказка: булевы значения получаются сравнением двух случайных целых чисел.

Д) Сгенерируйте два случайных числа (в диапазоне от 1 до 10) так, чтобы они не совпадали. Сделайте то же самое для трех чисел.

Глава 16

Делу время, а потехе час

 Сделать закладку на этом месте книги




Наши программы – и часовой, и экзаменатор – такие любопытные! Все спрашивают что-то: то пароль им подавай, то таблицу умножения! Не поменяться ли с компьютером местами? Теперь мы будем спрашивать, а он – отвечать.

Вот веселая и глупая игра: «вопрос-ответ», суть которой такова. Две колоды карточек – одну с вопросами, а другую с ответами – тасуют и кладут рубашками вверх. Кто-то из сидящей вокруг стола компании берет наугад карточку из «вопросительной» колоды и читает вопрос своему соседу. Тот вынимает наугад карточку из колоды с ответами и оглашает его. К примеру, на вопрос «Как пройти в библиотеку?» можно получить ответ: «Волк, коза и капуста».

Создадим нечто похожее для игры на компьютере, он будет отвечать на вопросы, вводимые пользователем с клавиатуры. Разумеется, что ответы заготовим в программе заранее, а выбирать их будем случайно.


Потемкинская лестница

В первую минуту эта задачка представится вам легкой забавой, – я попробую угадать ход ваших мыслей. Во-первых, не будем обращать внимание на вопрос пользователя, – для подготовки ответа он не важен. После ввода вопроса сгенерируем случайное число и выберем один из заранее подготовленных ответов, согласуясь с этим числом. А как организовать выход из программы? Вот тут вопрос пользователя будет кстати, – приняв пустой вопрос, мы завершим программу. Этим мыслям отвечает блок-схема на рис. 38.






Рис.38 – Блок-схема выбора из четырех вариантов

Рассмотрим условный оператор, выбирающий один из четырех ответов на основе случайного содержимого переменной R.


if R=1 

      then S:=’Ответ 1’

else if R=2 

      then S:=’ Ответ 2’

else if R=3 

      then S:=’ Ответ 3’

else S:=’ Ответ 4’;


Вложенные друг в друга условные операторы образуют «лесенку», – такое расположение удобно для чтения программы. А если заготовить больше ответов? Тогда «лесенка» дорастет до потемкинской лестницы, что в чудном городе Одессе!

Эта проблема – типичный случай в программировании. На сей случай в Паскале запасен оператор выбора CASE (что так и переводится – «случай»). В отличие от оператора IF, содержащего лишь две ветви, в операторе CASE их много – на все случаи жизни. Оператор записывают следующим образом:


case X of

      n1: Оператор_1;

      n2: Оператор_2;

      ...

      else  Оператор_n

end;


Конструкция построена на четырех ключевых словах CASE-OF-ELSE-END. Выражение целого типа X служит условием, по которому выбирается одна из числовых меток: n1, n2 и так далее (метки – это целые числа). Работает оператор так. Если выражение X = n1, то выполняется оператор_1, если X = n2, то выполняется оператор_2 и так далее. Если X не соответствует ни одной метке, сработает оператор, указанный после ELSE. А если ветвь ELSE отсутствует? Тогда ничего не выполняется.

Вот пример. Если в результате вычисления выражения Random(20)+1 будет получено число от 1 до 3, то переменной S будет присвоено соответствующее слово, а иначе она станет пустой.


case Random(20)+1 of

      1: S:= ’Первый’;

      2: S:= ’Второй’;

      3: S:= ’Третий’;

      else S:= ’’;

end;


Если оператор CASE применить к нашей шуточной (или нешуточной) программе, то получится вот что.


{ P_16_1 – игра «вопрос – ответ» }

var S: string;

begin

      Randomize; { чтобы случайный ряд не повторялся }

      repeat

      Write(’Ваш вопрос: ’); Readln(S);

      if S=’’ then break; { завершение цикла, если строка пуста }

      case  Random(5) of 

      0: S:=’Когда рак на горе свиснет’;

      1: S:=’После дождика в четверг’;

      2: S:=’За углом налево’;

      3: S:=’Это элементарно, Ватсон!’;

      else  S:=’Не знаю, я не местный’;

      end ;

      Writeln(S); { печать ответа }

      until false; { бесконечный цикл }

end.


Добавьте несколько смешных ответов, увеличив соответственно параметр функции Random, а затем испытайте программу на своих приятелях.


Итоги

• Для условных переходов со многими ветвями в Паскале предусмотрен оператор выбора CASE-OF-ELSE-END.

• Каждая ветвь оператора CASE начинается с числовой метки, за которой следует выполняемый оператор.

• Метки могут следовать в любом порядке (не только по возрастанию).

• Ветвь оператора CASE выбирается в зависимости от числового выражения в условии. Если ни одна метка не соответствует условию выбора, выполняется оператор, указанный после ELSE. Если ветвь ELSE не указана, то ничего не выполняется.

• Для исполнения внутри ветви нескольких операторов их объединяют в блок BEGIN-END.


А слабо?

А) Какой ответ будет выпадать чаще других, если условием в операторе CASE нашей программы поставить выражение Random(100)?

Б) Напишите программу, которая бы запрашивала номер дня недели, и в ответ печатала бы название этого дня («понедельник», «вторник» и так далее).

В) Пусть пользователь введет число – свой возраст в годах. Ваша программа должна напечатать фразу: «Вам столько-то лет» с правильным окончанием, например: «Вам 20 лет », или «Вам 34 года », или «Вам 41 год ». Подсказка: надо определить последнюю цифру года операцией MOD 10. Некоторые числа выпадают из общего правила, их надо проверить особо (например, 11, 12, 13, 14).

Г) Пользователь вводит число – номер месяца от 1 до 12, а программа должна сообщить соответствующее ему время года: зима, весна, лето, осень. Подсказка: в одной ветви можно применить несколько меток, например:


case N of

      1, 2, 12 : Writeln(‘Зима’);


Д) Танк в компьютерной игре может двигаться в одном из четырех направлений, обозначим их числами: 1 – север, 2 – восток, 3 – юг, 4 – запад. Направление движения изменяется тремя командами: 1 – поворот направо, 2 – поворот налево, 3 – поворот кругом. Пользователь вводит начальное направление движения, а затем ряд команд. Программа должна определять и печатать всякий раз новое направление. Выход из цикла – команда 0.

Е) Исходные позиции шахматных фигур известны всякому (если вы – исключение из правила, ознакомьтесь с основами шахмат). Пользователь в цикле вводит число, по которому программа печатает название фигуры, стоящей на соответствующей вертикали шахматной доски (от 1 до 8). Ноль служит для выхода из цикла, а на все прочие числа программа сообщает об ошибке.

Ж) Программа запрашивает в цикле два числа: вертикаль и горизонталь шахматной доски (числа от 1 до 8), а затем печатает цвет клетки на их пересечении. Если хотя бы одно из чисел равно нулю, цикл завершается. Если числа выходят за указанные пределы, сообщает об ошибке и повторяет запрос чисел.

Подсказка: на пересечении 1-й строки и 1-го столбца находится чёрная клетка.

Глава 17

И вновь за парту

 Сделать закладку на этом месте книги




Натешившись глупой игрушкой, сотворенной нами в предыдущей главе, с новыми силами набросимся на экзаменатора, ведь он ещё не совсем настоящий. Настоящий экзаменатор выставляет оценку, не так ли? Пусть наша программа оценивает ученика по количеству допущенных ошибок. Ответив, к примеру, на 15 вопросов, ученик получит:

• «отлично» – за ноль ошибок;

• «хорошо» – за 1-2 ошибки;

• «удовлетворительно» – за 3-5 ошибок;

• «неуд» – за 6 ошибок и более.


Цикл со счетчиком

Очевидно, что новая версия экзаменатора будет циклической (рис. 39), только условие выхода из цикла будет теперь другим.






Рис. 39 – Блок-схема экзаменатора, выставляющего оценку

Основное отличие этой версии от предыдущих состоит в применении счетчиков. Один из них подсчитывает количество заданных вопросов (то есть проходов цикла), а другой – количество ошибок. Что такое счетчик? Это числовая переменная, наращиваемая по ходу выполнения программы. Сначала рассмотрим тонкости, связанные с подсчетом вопросов.

Зададимся простой задачей: распечатать на экране числа от 1 до 10. Вот как это делается оператором REPEAT-UNTIL.


var N : integer;       { счетчик }

begin

      N:=1 ;

      repeat

      Writeln(N);

      N:= N+1 ;

      until N>10

end.


Первый из выделенных операторов устанавливает счетчик цикла в единицу, – программисты называют это инициализацией цикла. Другой выделенный оператор наращивает счетчик. Эта пара операторов, как принято говорить, организует цикл. Слабость такой организации в том, что действуют операторы порознь, а это таит две неприятности.

Человеку свойственно ошибаться, и программисты забывают порой вставить в программу ту или иную строчку. Что случится, если пропустить инициализацию? Значение счетчика N останется неопределенным, и цикл выполнится непонятно сколько раз. А если проворонить второй оператор? Счетчик наращиваться не будет, и цикл станет повторяться вечно, – программа, как говорят, зациклится! Во избежание таких ошибок в Паскале предусмотрен цикл со счетчиком.

Цикл со счетчиком объединяет в одной конструкции три действия: инициализацию счетчика, его приращение и проверку условия завершения цикла. Если б написать его по-русски, то оператор выглядел бы так:

ДЛЯ  N:= начальное_значение ДО  конечное_значение ВЫПОЛНИТЬ  оператор

Но русским Паскаль не владеет, а потому переведем это на английский:

FOR  N:= начальное_значение TO  конечное_значение DO  оператор

Как видите, конструкция построена на трех ключевых словах: FOR-TO-DO. После слова FOR следует оператор присваивания начального значения счетчику цикла. За словом TO указывают конечное значение счетчика, а после DO – выполняемый внутри цикла оператор. Но где наращивается счетчик? А нигде, это происходит автоматически! Теперь задача распечатки чисел может быть решена одним составным оператором.


var N : integer;       { счетчик }

begin

      for N:=1 to 10 do Writeln(N);

end.


Испытайте эту программку. Согласитесь, что ошибиться здесь труднее, чем в варианте с REPEAT. Как только вы написали FOR, то обязаны тут же указать начальное и конечное значения счетчика, а наращивать его Паскаль будет и без вас. В качестве начального и конечного значений вы вправе указать не только числа, но и выражения, – они будут вычислены один раз в начале цикла. Если начальное значение счетчика окажется равным конечному, цикл выполнится единожды. А если конечное значение окажется меньше начального, то ни разу!

Осталось ответить лишь на один вопрос: что, если внутри цикла надо выполнить несколько операторов? Ведь после слова DO предусмотрен лишь один. Впрочем, те, кто помнит об операторных скобках BEGIN-END, знают ответ. Напомню, что эти скобки превращают группу операторов в единый блок, этим мы и воспользуемся в новой версии экзаменатора.


{ P_17_1 – экзаменатор, выставляющий оценку }

var A, B, C : integer; { сомножители и произведение }

      Q, E : integer; { счетчик вопросов и счетчик ошибок }

      S: string;

begin

      Randomize;

      E:= 0; { обнуляем счетчики ошибок }

      for  Q:= 1 to  15 do begin  { 15 вопросов }

      A:= 1+ Random(10);       B:= 1+ Random(10);

      Write(Q,’) Сколько будет ’, A,’ x ’,B, ’ ? ’);

      Readln(C);

      { Если ответ неверный, увеличиваем счетчик ошибок }

      if A*B <> C then E:= E+1;

      end ; { цикл и блок завершаются здесь}

      case E of { выставляем оценку }

      0: S:=’Отлично!’;

      1,2 : S:=’Хорошо’;

      3..5 : S:=’Удовлетворительно’;

      else S:=’Ну оччччень плохо!’;

      end;

      Writeln(S, ’ Нажмите Enter’); Readln;

end.


Рассмотрим изюминки этой программы. В операторе


      Write(Q,’) Сколько будет ’, A,’ x ’,B, ’ ? ’);


вместе с вопросом печатается его порядковый номер Q.

Но самое интересное – это метки в операторе CASE. Напротив оценки «хорошо» стоит метка из двух разделенных запятой чисел (1, 2), – эта ветвь оператора CASE выполнится для этих двух значений. Такие объединенные метки могут содержать несколько чисел. А если числа следуют подр


убрать рекламу






яд, их заменяют числовым диапазоном – это два числа, разделенные двумя точками («многоточием»), причем первое число должно быть меньше второго. Такой диапазон (3..5) служит меткой для ветви «Удовлетворительно».


Итоги

• Цикл со счетчиком FOR-TO-DO удобен при известном количестве повторений, которое вычисляется при входе в цикл.

• Счетчик цикла внутри оператора наращивается автоматически, цикл завершается, когда счетчик превысит указанное максимальное значение.

• Оператор выбора CASE-OF-ELSE-END допускает метки из нескольких чисел, и даже диапазоны целых чисел.


А слабо?

А) Позвольте ученику отказаться от сдачи экзамена. Признаком отказа будет ввод нуля в качестве ответа. В этом случае надо досрочно выйти из цикла и обойти выставляющий оценку оператор (вспомните о процедуре Break).

Б) Напишите программу, которая по введенному числу дает заключение о том, какому дню недели оно соответствует – рабочему (1-5) или выходному (6,7), например:


День = 2

Рабочий

День = 7

Выходной

День = 20 

Ошибка!


Здесь выделенные числа напечатаны пользователем.

В) Напишите программу, которая, запросив число N, печатала бы числа от 1 до N в обратном порядке, например:


N = 3

3

2

1


Г) Существует вариант цикла FOR, где счетчик цикла не наращивается, а уменьшается, этот оператор выглядит так:

FOR N:= начальное_значение DOWNTO конечное_значение DO оператор

Ключевое слово DOWNTO задает счет в обратном порядке (DOWN – «вниз»); при этом начальное значение счетчика должно быть больше или равно конечному, иначе цикл не выполнится ни разу. Воспользуйтесь этим оператором для решения предыдущей задачи (задание В).

Д) Пусть программа запросит два числа N и M, а затем вычислит их произведение без использования операции умножения (*). Подсказка: организуйте цикл суммирования N раз числа M.

Е) Напишите программу, вычисляющую сумму чисел от 1 до N, где N – число, вводимое пользователем.

Ж) Напишите программу, вычисляющую сумму только тех чисел от 1 до N, которые делятся либо на три, либо на пять.

Задачи на темы предыдущих глав

И) Платный участок трассы протянулся с километра P1 до километра P2 (P1<P2). А пост ГАИ размещен на километре M. Попадает ли этот пост на платный участок трассы? Пусть ваша программа разберется с этим.

К) Дорожная служба запланировала ремонт трассы на участке с R1 по R2 (R1<R2). В сочетании с условием предыдущей задачи ваша программа должна определить:

• Будут ли ремонтировать весь платный участок P1–P2 ?

• Будут ли ремонтировать хотя бы часть платного участка P1–P2 ? Если да, то определить длину ремонтируемой платной части.

• Будут ли ремонтировать хотя бы часть бесплатного участка? Если да, то определить длину ремонтируемой бесплатной части.

Глава 18

Аз, Буки

 Сделать закладку на этом месте книги




Вот вам новая задача: побуквенная распечатка строки. Программа должна запросить строку и напечатать ее по буквам, например:


Введите строку: PASCAL 

P

A

S

C

A

L


Да будь я хоть семи пядей во лбу, спасовал бы перед этой задачей, если бы… если бы не знал внутреннего устройства строки.


Символьный тип данных

Строковые данные, которыми мы так запросто орудуем, не так уж просты, и нам следует разобраться в этом. Вспомните первый класс, с чего все началось? С освоения букв. Строки тоже складываются из букв, точнее из символов. Символы – это не только буквы, но и цифры, знаки препинания, и даже пробел. Существуют и невидимые, так называемые управляющие символы, но о них мы поговорим в другой раз. Рассмотрим следующую строковую константу:


      ’Привет, Мартышка!’


Сколько символов в этой строке? Здесь 14 букв, к ним надо прибавить запятую, восклицательный знак и пробел, и тогда получится 17.

Для представления отдельных символов в Паскале имеется тип данных CHAR – от английского CHARACTER, что значит «символ». Так же, как и строковые, символьные данные могут быть константами и переменными. Переменные символьного типа объявляют так:


var c1, c2, c3 : char;


Тут объявлены три переменные, которым можно присваивать значения символьных констант или других символьных переменных, например:


      c1:= ’A’; c2:= ’B’; c3:= c1;


Символьные константы, как и строковые, заключают в апострофы. Но, в отличие от строк, они могут содержать ровно один символ, – не больше и не меньше! Для острастки я покажу ошибочные операторы, компилятор их обязательно забракует.


      c1:=’ABBA’;       { нельзя присвоить более одного символа }

      c2:=’’;       { и менее одного тоже! }


Но строковым переменным разрешено присваивать значения символьных данных, например:


var c1 : char; S: string;

...

      S:= c1;


Это и понятно, ведь строка может вмещать много символов! Строковые и символьные данные можно «склеивать» операцией сложения, результат получится строковым, например:


      c1:= ’A’; c2:= ’B’; c3:= ’A’;

      S:= c1 + c2 + ’B’ + c3;       { результат равен ’ABBA’ }

      S:= ’pascal’+ c1 + S;       { «склеивание» символов и строк }


Подобно строкам, отдельные символы вводятся процедурой Readln, и печатаются процедурами Write и Writeln, например:


      Readln(c1);

      Writeln(c1);



Индексация

Ясно, что «склеить» символы в строку немудрено, но ведь для решения поставленной задачи требуется обратное – разобрать строку на отдельные символы. Взглянем на строку с иной стороны – как на стройный ряд символов. Каждый символ в этом строю, подобно солдатам, занимает свою позицию. Позиции нумеруются слева направо, начиная с единицы. Например, в слове «PASCAL» символ «P» занимает первую позицию, а «L» – шестую.

Оказывается, что по этим номерам можно обращаться к отдельным символам строки, применяя операцию индексации. Она записывается с помощью пары квадратных скобок, расположенных за символьной переменной или константой. Внутрь скобок помещают числовое выражение, указывающее позицию символа в строке. Например, для извлечения 3-го символа строки можно написать


      c1:= S[3];


Выражение, что внутри квадратных скобок, называется индексом. Повторяю, индексом может быть не только число, но и числовое выражение, например:


      c1:= S[2*N+1];


Если N равно двум, то в символьную переменную c1 будет помещен пятый символ строки S.


Длина строки

Разумеется, что значение индекса не должно превышать количество символов в строке. Но как избежать таких ошибок? Если строка перед глазами, вы посчитаете символы, тыча в строку пальчиком. А если это строковая переменная?

В Паскале есть функция, определяющая количество символов в строке, или, иначе говоря, длину строки. Эта функция так и называется – Length – «длина». Вызвать её можно, например, так:


      K:= Length(S);


Здесь переменной K целого типа присваивается значение длины строковой переменной S. Вот ещё примеры (в комментариях указаны результаты).


      S:= ’’; K:= Length(S);       { К=0 }

      S:= ’PAS’ K:= Length(S);       { К=3 }

      K:= Length(S+’CAL’);       { К=6 }

      K:= Length(’Привет, Мартышка!’);       { К=17 }



Распечатка строки

Теперь мы достаточно подкованы, чтобы решить поставленную задачу – разбить строку на отдельные символы. Вот как выглядит один из вариантов решения.


{ P_18_1 – распечатка отдельных символов строки }

var S: string;

      C: char;

      k, L : integer;

begin

      repeat

      Write(’Введите строку: ’); Readln(S);

      L:= Length(S) ; { определяем длину строки }

      for k:=1 to L do begin

      C:= S[k] ; { выбираем очередной символ }

      Writeln(C); { и печатаем его в отдельной строке }

      end;

      until L=0 ;       { L=0, если строка пуста }

end.


После ввода запрошенной строки определяем её длину, а затем, пробегая по строке, выбираем и печатаем символы. Программа работает, пока пользователь не введет пустую строку; тогда длина строки L станет равной нулю, и цикл завершится.

В этом варианте программы я сознательно допустил некоторые излишества, дабы наглядней показать механизм доступа к символам строки. То же самое можно записать короче, а именно:


{ P_18_2 – распечатка отдельных символов строки, краткий вариант }

var S: string; k : integer;

begin

      repeat

      Write(’Введите строку: ’); Readln(S);

      for k:=1 to Length(S) do Writeln( S[k]);

      until Length(S)=0 ;

end.


Здесь функция Length вставлена в оператор FOR, а параметром процедуры Writeln является текущий символ строки S[k]. В цикле FOR выполняется теперь лишь один оператор, поэтому отпала нужда в блоке BEGIN-END. Обратите внимание на условие завершения цикла UNTIL, – оно записано с применением функции Length.

На этом прервем изучение символов и строк. Однако тема не исчерпана, и к ней мы ещё вернемся.


Итоги

• Строки – это цепочки символов. Для работы с отдельными символами в Паскале предусмотрен тип данных CHAR.

• Данные типа CHAR можно «склеивать» друг с другом и со строковыми данными, в результате получаются строки.

• Доступ к отдельным символам строки возможен путем индексации. Эта операция обозначается парой квадратных скобок, следующих за строкой; внутрь скобок помещают числовое выражение – индекс.

• Доступ по индексу применяется как для чтения символов строки, так и для их изменения.

• Для обработки строки необходимо знать её длину. С этой целью в Паскале применяется функция Length.

• Для последовательной обработки символов строки обычно используют цикл со счетчиком FOR-TO-DO.


А слабо?

A) Напишите программу для подсчета букв «А» во введенной пользователем строке. Или слабо?

Б) Напишите программу, меняющую символы «А» строки на символы «Б». Подсказка: изменение символа строки делается оператором присваивания вида S[i]:=…

В) Что делают со строкой S следующие операторы?


      for i:=1 to Length(S) do S:= S + S[i];

      for i:=Length(S) downto 1 do S:= S + S[i];


Проверьте свои предположения на практике.

Г) Записи телефонных номеров обычно содержат дополнительные символы: скобки, черточки, пробелы, например: 8(123)45-67-89. Предположим, что пользователь их так и вводит. Пусть ваша программа удалит из такой строки все символы, кроме цифр. Например, после ввода указанного выше номера она должна напечатать: 8123456789.

Д) Пусть ваша программа напечатает введенную пользователем строку вразрядку, добавляя подчёркивание либо пробел после каждого символа, например: 'Pascal' преобразует в 'P_a_s_c_a_l'.

Глава 19

Процедуры и функции: разделяй и властвуй

 Сделать закладку на этом месте книги





Снежный ком

Чем дальше в лес, тем больше дров, – наши программы становятся все замысловатей! Чем измеряют сложность программ? – усилиями, что потребны на их осмысление. С ростом размера программы её сложность растет снежным комом: так программа в десять страниц стократ сложней одностраничной! Почему?

Три базовые структуры: линейная последовательность, условный переход и цикл – это строительные блоки наших изделий. В ходе постройки программы эти структуры причудливым образом внедряются друг в друга: условные – внутрь циклов, циклы – внутрь условных операторов и так далее. План «постройки» определяется решаемой задачей – алгоритмом – и тут ничего не упростить. С ростом программы не только запутывается её текст, но и плодятся полчища переменных. «Расползаясь» по телу программы, они затрудняют контроль над собой. Поверьте, продолжая «строительство» в прежнем стиле, вы скоро свихнетесь, – ведь серьезные программы насчитывают тысячи страниц!

В 15-й главе я поведал о соединении усилий программистов в работе над одним проектом, – им на выручку приходят процедуры и функции. Мы уже пользовались ими, извлекая готовенькими откуда-то из «недр» Паскаля (такими, как Writeln, Readln, Length, Random). Заботит ли вас устройство и сложность этих процедур? Нет? То-то же! Подобно усердным слугам, они лишь исполняют наши капризы. Но, то – чужие «слуги», созданные другими программистами, не пора ли обзавестись своими? Разбив сложную программу на «кусочки», мы значительно упростим её. Как говорят, разделяй и властвуй!


Описание процедур

Для постройки нашей первой процедуры возьмем знакомый пример. Вот как организована пауза с ожиданием нажатия клавиши Enter в одной из наших первых программ.


      Write(’Нажмите Enter…’); Readln;


Пустяшный кусочек, – всего два оператора. Но их можно заменить одним, если создать процедуру, выполняющую те же самые действия.

Создать процедуру, – это значит дать ей имя и описание. Делается это с применением ключевого слова PROCEDURE, после которого указывается имя процедуры и её тело, содержащее операторы. Процедуре назначают имя по тем же правилам, что для констант и переменных. Сейчас мы заменим пару упомянутых выше операторов процедурой по имени Pause (пауза), вот как будет выглядеть её описание (рис. 40).






Рис.40 – Описание процедуры Pause

После заголовка процедуры ставится точка с запятой. Далее следует тело, заключенное в блок BEGIN-END. Завершается описание процедуры ещё одной точкой с запятой. В блоке BEGIN-END размещают любое количество исполняемых операторов по тем же правилам, что применялись нами ранее. Обратите внимание: блок BEGIN-END в теле процедуры обязателен! Даже если внутри блока будет всего один оператор, или не будет вовсе!

Теперь решим, где расположить это хозяйство? На рис. 41 показана знакомая вам структура простой программы. После объявления констант и переменных следует главная программа, где исполняемые операторы заключены между BEGIN и END.






Рис.41 – Структура простой программы

По правилам языка любой объект программы – константа, переменная, процедура – должен объявляться до своего использования. Стало быть, описание процедуры надо поместить до того, как будет сделан её вызов. Поскольку процедура Pause вызывается из главной программы, её описание должно быть помещено перед нею.


{ P_19_1 – Пример применения процедуры }

var Man : string;


procedure Pause; {--- описание процедуры ---}

begin

      Write(’Нажмите Enter…’);

      Readln;

end;


begin       {--- главная программа ---}

      Writeln(’Как тебя зовут?’); Readln(Man);

      Writeln(’Здравствуй, ’, Man);

      Pause;        { вызов процедуры }

end.


Но в каком порядке будут выполняться операторы этой программы? Мы знаем, что компьютер исполняет программу, как бы читая её слева направо и сверху вниз. Стало быть, операторы в теле процедуры выполняются первыми?

А вот и нет! Главная программа на то и главная, чтобы исполняться первой. Все начнётся с запроса имени пользователя и так далее. Когда же дело дойдет до вызова процедуры Pause, вступят в бой операторы в теле этой процедуры. Последовательность исполнения показана на рис. 42 (обратите внимание на нумерацию строк). Вызов процедуры Pause приведет, как говорят программисты, к передаче управления внутрь тела процедуры. После исполнения расположенных там операторов, управление возвращается в главную программу к оператору, следующему за вызовом.






Рис.42 – Последовательность выполнения операторов

Итак, хотя процедура размещается в тексте выше главной программы, её операторы выполняются позже – после вызова процедуры.

При необходимости вызов процедуры можно повторить. Например, чтобы подразнить пользователя и заставить его трижды нажать клавишу Enter, сделаем так:


begin       {--- главная программа ---}

      Writeln(’Как тебя зовут?’); Readln(Man);

      Writeln(’Здравствуй, ’, Man);

      Pause;

      Pause;

      Pause;

end.



Процедуры с параметрами

Вам ясна техника объявления и вызова процедур? Тогда рассмотрим ещё один случай: пусть выводимое процедурой сообщение меняется по нашему желанию. Для этого процедуру снабжают параметром. Вы знаете, что параметр указывается в скобках за именем процедуры, например:


      Pause (’Будьте любезны нажать Enter!’);


Попробуйте вызвать процедуру этим способом, что вам скажет компилятор? Ничего хорошего не скажет и будет прав. Откуда процедуре знать о вашем желании вывести именно это сообщение? Но если добавить в заголовок процедуры объявление параметра, дело пойдет на лад. Объявление параметра тоже помещают в скобки; оно похоже на объявление переменной. В нашем случае заголовок процедуры с параметром может выглядеть, например, так:


procedure Pause (msg : string) ;


Здесь имя параметра msg назначено нами произвольно (это сокращение от слова message – «сообщение»). Параметр, объявленный в заголовке, называют формальным, он доступен только внутри процедуры, где можно обращаться с ним, как с обычной переменной. Например, вывести на экран, как в нашем случае.


procedure Pause (msg : string) ; { объявление процедуры с параметром }

begin

      Write(msg ); Readln;

end;


Что касается вызывающей программы, то имя формального параметра ей неизвестно.

Как действует такая процедура? В момент вызова в главной программе формальному параметру msg автоматически присваивается указанное в вызове фактическое значение, – оно и будет напечатано. Повторяю: присвоение формальному параметру фактического значения происходит автоматически, без участия программиста. Теперь наша программа станет такой.


{ P_19_2 – применение процедуры с параметром }


var Man : string;

{--- объявление процедуры с параметром msg ---}

procedure Pause (msg : string);

begin

      Write(msg); Readln;

end;


begin       {--- главная программа ---}

      Writeln(’Как тебя зовут?’); Readln(Man);

      Writeln(’Здравствуй, ’, Man);

      Pause(’Нажмите Enter…’);

      Pause(’Еще раз…’);

      Pause(’И ещё разок!’);

end.


Здесь процедура Pause вызвана трижды с тремя разными фактическими параметрами, испытайте эту программу.


Итоги

• С ростом размера программы стремительно растет её сложность. Для упрощения программ их разбивают на процедуры и функции.

• Чтобы создать процедуру или функцию, необходимо поместить в программе её описание, состоящее из заголовка и тела.

• Внутрь процедуры или функции можно передать один или несколько параметров. Для этого в заголовке процедуры объявляют формальные параметры, а при вызове указывают фактические.

• Тип фактического параметра должен совпадать с типом формального параметра, объявленного в процедуре.


А слабо?

А) Напишите ещё одну версию процедуры Pause, выводящую сообщение либо на русском, либо на английском языке. Параметр этой процедуры должен быть булевым и работать она должна так:


      Pause(true);       { печатается «Нажмите Enter…» }

      Pause(false); { печатается «Press Enter…» }


Б) Напишите и испытайте процедуру (назовем её Line – «линия»), печатающую строку заданной длины, составленную из звездочек, например:


      Line(3); { печатает «***» }

      Line(7); { печатает «*******» }


Подсказка: внутри процедуры надо организовать цикл.

В) Напишите процедуру для очистки экрана, она может пригодиться вам в будущем. Подсказка: можно напечатать несколько десятков пустых строк (не менее 25, что зависит от настройки размера консольного окна).

Г) Напишите и испытайте процедуру, принимающую два параметра – числа, и печатающую их сумму и их разность.

Задачи на темы предыдущих глав

Д) Пользователь вводит строку с телефонным номером (только цифры), количество цифр заранее неизвестно. Ваша программа должна дополнить номер дефисами, разбивающими его на триады, т.е. по три цифры двумя способами:

• начиная с первых цифр, например 112-345-1;

• начиная с последних цифр, например 1-123-451.

Е) Почтальон разносит газеты по улице, состоящей из N домов. Четные и нечетные номера расположены по разные стороны улицы. В здравом уме почтальон не рискует лишний раз переходить её. Ваша программа должна напечатать последовательность номеров, по которым будут разнесена почта, когда почтальон начинает работу:

• с первого дома;

• со второго дома;

• с N-го (то есть последнего) дома.

Глава 20

Процедуры: первый опыт

 Сделать закладку на этом месте книги




Некоторые считают программирование искусством. Если так, то в чем оно? Искусный программист умеет (кроме прочего) превращать сложную программу в простую, – он равномерно распределяет сложность между процедурами и функциями. Как научиться этому? Усвойте несколько ключевых истин, но главное здесь – практика. Без «шишек» и «синяков» тут не обойтись. Однако, сколько за одного битого небитых дают?

Следующая задача слегка надумана, – это всего лишь полигон для испытания наших собственных процедур. Условие задачи таково: пусть пользователь введет одну за другой несколько строк, например, три (потребуется цикл со счетчиком, улавливаете?). В каждой введенной строке надо заменить латинские буквы «A» – если они там есть – на латинские буквы «B». Например, приняв строку «ABBA», программа должна превратить её в строку «BBBB».


Мухи – налево, котлеты – направо!

Рис. 43 избавляет вас от необходимости малевать алгоритм будущей программы. Ясно, что программа не так проста, – она включает условный оператор и два цикла, причем один из них вложен в другой. Внешний цикл отвечает за ввод строк, а внутренний – за их обработку. Можно ли упростить это сооружение? Бывалый программист сразу смекнет, как отделить здесь мух от котлет, – внутренний цикл, отмеченный серым цветом, лучше выделить в отдельную процедуру, и тогда программа распадется на два несложных алгоритма (рис. 44). Слева на этом рисунке показан алгоритм главной программы, а справа – алгоритм процедуры, которой я дал имя Scan. Пунктирные линии со стрелками показывают места входа в процедуру и выхода из нее.






Рис.43 – Блок-схема программы с двумя циклами





Рис.44 – Блок-схемы главной программы (слева) и процедуры (справа)

Согласитесь, – каждая из этих блок-схем в отдельности не так уж сложна, значит можно приступить к написанию программы.


Сверху вниз

Легко сказать «приступить», но с чего начать? Настрочить программу целиком и сразу? – вот прекрасный способ запутаться! Нет, профессионалы поступают иначе, следуя одному из двух направлений. Первое из них именуется разработкой «сверху вниз», – проект лепят начиная с главной программы, переходя затем к процедурам. Другое направление противоположно первому и называется разработкой «снизу вверх». Оба направления имеют свои достоинства, поэтому в крупных проектах их иногда используют одновременно. Но сейчас нам лучше подходит первый способ.

Итак, последуем выбранному нами порядку разработки «сверху вниз». Этот подход хорош тем, что на промежуточных этапах получаются почти работающие программы. Почему «почти»? – сейчас поймете. Итак, забудем на время о недостающей процедуре Scan и напишем лишь главную программу, вот она.


{ P_20_1 – первый этап разработки }

var S: string; k: integer;

begin       {--- главная программа ---}

      for k:=1 to 3 do begin

      Write(’Введите строку: ’); Readln(S);

      { Scan(S); } 

      Writeln(S);

      end;

end.


Обратите внимание на закомментированный вызов процедуры Scan(S), – он напоминает о незавершенной части работы. Скелет нашей будущей программы готов, его можно не только скомпилировать, но и запустить, – сделайте это обязательно! Разумеется, программа не выполняет всего задуманного, но уже делает кое-что.

Убедившись в работоспособности скелета, перенесём внимание на процедуру. На этом этапе тоже есть свои хитрости: сначала дадим частичное описание процедуры, создав заголовок и оставив тело пустым. Такую процедуру называют заглушкой или пустышкой. Написав заглушку уберите комментарий с вызова Scan(S), и тогда на скелете нарастет немного «мяса».


{ P_20_1 – второй этап разработки }

var S: string; k: integer; 


      {--- Заглушка процедуры –--}

procedure Scan(arg : string);

begin

end;


begin       {--- главная программа ---}

      for k:=1 to 3 do begin

      Write(’Введите строку: ’); Readln(S);

      Scan(S);

      Writeln(S);

      end;

end.


Процедура Scan принимает строковый параметр arg (это сокращение от слова argument). Аргумент – так ещё называют параметр процедуры или функции. Теперь снова запустите программу. Если все в порядке, значит вызов процедуры Scan(S), как говорят программисты, видит описание этой процедуры, и его фактический параметр S отвечает формальному параметру процедуры arg.

Переходим к третьему этапу, где можно забыть о главной программе и сосредоточиться на теле процедуры Scan. Напомню, что ей поручено заменить в строке буквы «A» на буквы «B». С этой несложной работой справится цикл, содержащий вложенный в него условный оператор.


      for k:=1 to Length(arg) do

      if arg[k]=’A’ then arg[k]:=’B’;


Напомню, что arg – это переданная в процедуру строка, а k – счетчик цикла. Вставив этот цикл в тело процедуры Scan, получим готовенькую программу.


{ P_20_1 – третий этап разработки }

var S: string; k: integer ;


procedure Scan(arg : string);

begin

      for k:=1 to Length(arg) do

      if arg[k]=’A’ then arg[k]:=’B’;

end;


begin       {--- главная программа ---}

      for k:=1 to 3 do begin

      Write(’Введите строку: ’); Readln(S);


убрать рекламу






      Scan(S);

      Writeln(S);

      end;

end.


Обратите внимание на счетчик циклов k. Он – счетчик – используется нами в двух местах: в главной программе и в процедуре. Налицо экономия памяти, не так ли? Насколько оправдана эта надежда? Скоро узнаем.

Для пишущих на Delphi . Компилятор Delphi не позволит использовать счетчик k так, как сделано в этой программе, – но об этом чуть позже.


Первые раны

Теперь запустите наше творение. Если вам это удалось, значит компилятор не нашел ошибок. Но вот незадача: работает программа неправильно! Во-первых, буква «A» не меняется на букву «B». Ещё печальней то, что перестал работать цикл главной программы. Она, что называется, зациклилась, запрашивая непрестанно все новые и новые строки. А ведь на скелете цикл работал, – мы проверяли!

Впрочем, если ввести строку из трех символов, программа чудесным образом завершится. Это наводит на размышление, – ведь цикл главной программы тоже считает до трех. Не промахнулись ли мы, доверив переменной k «служить двум господам», работая в двух циклах? Ведь внутри процедуры значение счетчика k изменяется, что нарушает работу цикла в главной программе. И лишь когда счетчик случайно станет равен трем, программа завершается.

Как исправить ошибку? Объявить для счетчика внутреннего цикла переменную с другим именем? Да, можно. Но я воспользуюсь этой ошибкой, чтобы показать иной подход и лучше раскрыть механизм процедур и функций.


Глобальные и локальные

Процедуры и функции не зря называют подпрограммами. Так же, как в главной программе, внутри подпрограмм можно объявлять свои собственные константы и переменные, – их называют локальными, то есть местными. А всё, что объявлено за пределами подпрограмм, называют глобальным, или всеобщим. Рассмотрим механизм действия локальных объектов и связанные с этим выгоды, для чего исследуем следующую программу.


const c1 = ’Глобальная’;


procedure Local;

begin

      Writeln(c1);

end;


begin       {--- главная программа ---}

      Local;

      Writeln(c1);

      Readln;

end.


Очевидно, программа дважды напечатает константу C1, – проверьте меня. Теперь добавим объявление локальной константы с тем же именем C1, поместив его между заголовком процедуры Local и её телом. К совпадающим именам я прибегнул не от бедности фантазии, – мой умысел скоро прояснится.


const c1 = ’Глобальная’;


procedure Local;

const c1 = ’Локальная’;

begin

      Writeln(c1);

end;


begin       {--- главная программа ---}

      Local;

      Writeln(c1);

      Readln;

end.


Известно, что компилятор не допускает совпадающих имен, но здесь – иное дело. Локальная константа C1 «спряталась» внутри своей процедуры и, как говорят программисты, не видна за её пределами.

Запустив на выполнение этот вариант программы, вы убедитесь, что внутри процедуры будет напечатана локальная константа, а в главной программе – глобальная. Отсюда следуют два правила, имеющих силу для констант, переменных и других объектов, о которых вы со временем узнаете. Правила эти таковы:

• локальные объекты (константы, переменные и прочие) видны лишь внутри тех подпрограмм, в которых они объявлены;

• при совпадении имен локального и глобального объектов, внутри подпрограммы имеет силу локальный объект; при этом глобальный объект скрывается локальным.

С учетом сказанного нашу неработающую программу можно исправить так:


{ P_20_1 – вариант программы с локальной переменной }

var S: string; k: integer ; { глобальная переменная }


procedure Scan(arg : string);

var k: integer ; { локальная переменная }

begin

      for k:=1 to Length(arg) do

      if arg[k]=’A’ then arg[k]:=’B’;

end;

begin { главная программа }

      for k:=1 to 3 do begin

      Write(’Введите строку: ’); Readln(S);

      Scan(S);

      Writeln(S);

      end;

end.


Теперь совпадение имен локальной и глобальной переменных k не нарушает работу программы, поскольку это разные переменные. Они могли бы иметь даже разные типы! Убедитесь, что отныне путаницы в циклах нет.


Локально – это разумно!

Локальные объекты – константы, переменные и прочие – отличное средство для разумного распределения данных в пространстве вашей программы.

Во-первых, они облегчают многотрудную жизнь программиста. Если некоторые объекты нужны только внутри процедуры, их следует объявить там же, то есть как локальные. И тогда не придется гадать, повлияют ли они на другие части программы.

Другой выигрыш заключается в экономии памяти. Все переменные занимают оперативную память («оперативку»). Чем больше переменных, тем больше памяти им подавай. Глобальные переменные занимают память в течение всего времени работы программы. А для локальных память выделяется лишь на время работы соответствующей процедуры или функции. Завершилась подпрограмма – освободилась память.


Неподдающаяся строка

Теперь вновь проверим нашу программу. В ответ на запрос строки введите что-нибудь вроде «QAAAW». Если все нормально, программа напечатает «QBBBW» (буква «A» заменяется буквой «B»). Не вышло? Что ж, тогда идем «на поклон» к отладчику, – мы сделаем это в следующей главе.


Итоги

• Программа упрощается, если вынести части алгоритма в отдельные подпрограммы — процедуры и функции.

• Объекты, используемые лишь внутри подпрограмм, следует объявлять там же, – как локальные.

• Локальные объекты (константы, переменные и прочие) видны, то есть доступны, лишь внутри тех подпрограмм, где они объявлены.

• Если имя локального объекта совпадает с глобальным, то внутри подпрограммы действует локальный объект, а глобальный делается «невидимкой».

• Локальные объекты упрощают программирование, придают программам надежность и экономят оперативную память.


А слабо?

А) В 17-й главе нами создан экзаменатор, проверяющий знания таблицы умножения. Переработайте программу P_17_1 так, чтобы оценка выставлялась в процедуре, принимающей один параметр – количество допущенных ошибок.

Б) Создайте процедуру, печатающую все числа, кроме единицы, на которые без остатка делится число N, где N – параметр процедуры. Напишите программу для проверки этой процедуры.

В) Два сотрудника подали своему начальнику заявления на отпуск. Первый попросил отпустить его с A1 по B1 день (дни отсчитываются с начала года), второй – с A2 по B2 день. Считаем, что A1<B1 и A2<B2. Однако дело требует, чтобы кто-то из сотрудников находился на рабочем месте. Мало того, при смене отдыхающих необходимо не менее 3-х дней их совместной работы – для передачи дел. Напишите программу с процедурой, принимающей четыре указанных выше параметра, и печатающей заключение о том, удовлетворяют ли заявления работников требованиям начальника.

Г) Подойдя к перекрестку, пешеход решает, переходить ли ему улицу или остановиться. На решение влияет характер пешехода и ещё два фактора: сигнал светофора и близость опасно движущегося транспорта. Напишите программу с процедурой, которая принимает и печатает решение в зависимости от переданных в неё трех параметров, а именно.

• Параметр A = true, если горит зеленый;

• Параметр B = true, если поблизости опасно движется транспорт;

• Параметр C – это число, определяющее характер пешехода так:

1 – послушный и осторожный – учитывает и светофор и опасность;

2 – послушный, но беспечный – смотрит только на светофор;

3 – хитрый вольнодумец – идет только на красный, если это ничем не грозит;

4 – непримиримый вольнодумец – идет только на красный;

5 – экстремал – идет только на красный, и так, чтобы грозила опасность;

6 – «безбашенный» – идет, несмотря ни на что;

7 – запуганный – никогда не идет через дорогу, а ищет подземный переход.

Глава 21

Отладка

 Сделать закладку на этом месте книги




Предыдущую главу мы покинули, понурив голову, так и не совладав с программой P_20_1. Почему не заменяются символы в строке? – этот вопрос остался без ответа. Эх, знать бы, что творится внутри программы! Сейчас она для нас – загадочный «черный ящик», и мы видим лишь то, что входит и выходит из него. К счастью, в IDE есть средство для доступа внутрь этого «ящика», и мы воспользуемся им. Это средство называется отладчиком. Так же, как редактор текста и компилятор, отладчик встроен в интегрированную среду разработки.


Отладчик

Отладчик – это набор инструментов для исследования «потрохов» программы. Посредством отладчика можно следить за выполнением отдельных операторов, делая остановки в нужных местах или на каждой строке программы. Застопорив программу, вы сможете выяснить значения тех или иных переменных и даже изменить их. Одним словом, отладчик – это чудо-оружие!

Инструменты отладчика доступны через два пункта меню: Run – запуск и Debug – удаление багов (жучков). Программные ошибки прозвали багами – «жучками».

В пункте Run собраны команды для управления ходом выполнения программы (рис. 45).






Рис. 45 – Пункты меню RUN для доступа к отладчику

Примечание.  В данной главе показаны окна отладчика для Borland Pascal, в IDE Free Pascal они выглядят чуть иначе.

В табл. 1 даны пояснения к пунктам этого меню.

Табл. 1 – Описание пунктов меню Run

Команда Горячая клавиша Пояснение
Run Ctrl+F9 Запускает программу в непрерывном режиме.
Trace into F7 Выполняет одну строку программы (шаг). Если в строке есть вызов процедуры, то останов происходит на входе в нее, – так можно «войти» внутрь процедуры и следить за ходом её выполнения.
Step over F8 Выполняет одну строку программы. Если в строке есть вызов процедуры, то процедура выполняется целиком, без остановки.
Go to cursor F4 Выполняет программу, пока не будет достигнута строка, где установлен текстовый курсор. Курсор надо предварительно установить на нужной строке!
Program Reset Ctrl+F2 Сброс программы. Если программа остановлена в пошаговом режиме, она перейдет в исходное состояние.
Parameters… нет Используется для отладки программ, принимающих параметры через командную строку.

Обратите внимание: за один шаг отладки выполняется либо одна строка программы, либо один оператор, если он занимает несколько строк. Стало быть, операторы, помещенные в одной строке, будут выполнены за один шаг. Если компилятору безразлично, как вы располагаете операторы, но при отладке это важно. Не размещайте операторы в одной строке, если при отладке намерены выполнять их раздельно.

Теперь обратимся к пункту меню Debug (рис. 46), где собраны команды для просмотра переменных, их редактирования, а также для просмотра выводимых программой результатов. Эти результаты можно увидеть либо на экране (User screen) либо в специальном окне (Output). Рядом с командами показаны соответствующие им горячие комбинации клавиш.






Рис. 46 – Пункт меню Debug для просмотра результатов работы программы

Теперь испробуем основные команды отладчика на своей программе.


Жучки, вылезайте!

Итак, приступим к поиску жучков, притаившихся в программе «P_20_1». Хорошо бы проследить за изменением переменных в ходе выполнения программы. Для этого вставим переменные в окно обзора «Watches». Откомпилировав программу, поместите курсор под переменной k и нажмите Ctrl+F7. Появится диалоговое окно для добавления переменной в окно обзора (рис. 47).






Рис. 47 – Добавление переменной в окно обзора

Поскольку переменная k была взята на мушку заранее, поле уже содержит её имя. Теперь щелчок по кнопке OK отправит переменную в окно обзора (рис. 48). Если же поле «Watch expression» пусто, или содержит нечто другое, значит, вы промахнулись, не попали курсором. Тогда впечатайте имя нужной переменной и щелкните OK. Действуя так, добавьте в окно обзора все интересующие вас переменные (рис. 48).






Рис. 48 – Окно обзора переменных Watches

Пока программа не запущена, напротив имен переменных выводится сообщение о невозможности доступа к ним, – пусть вас это не смущает. Лучше взгляните на то, как расположено окно «Watches». Сейчас оно занимает нижнюю часть экрана и закрывает собой часть окна с программой. Это неудобно, а посему обратитесь к пункту меню Window –> Tile (Окна –> Рядом) как показано на рис. 49.






Рис. 49 – Пункт меню Window –> Tile

В результате окна с текстом программы и списком переменных поместятся, не перекрывая друг друга (рис. 50). То же самое можно сделать и мышкой, перетаскивая и меняя размеры окон.

Теперь станем выполнять программу по шагам, следя за изменением переменных. Вместо привычной комбинации Ctrl+F9, для пуска программы в пошаговом режиме нажимают клавишу F7 (команда Run –> Trace). Тогда отладчик остановит программу перед первым оператором, подсветив его особым образом. Последующие нажатия клавиши F7 заставят выполняться следующие строки программы, и очередная строка будет выделяться цветной полоской.

Нажав клавишу F7 четыре раза, мы достигнем оператора Readln, – здесь программа остановится в ожидании ввода строки. Введите как обычно строку из латинских букв «QAAAW» и нажмите Enter, – и тогда программа остановится перед входом в процедуру Scan, как показано на рис. 50.

Примечание.  В отладчике IDE Free Pascal при вводе строки необходимо нажать клавишу Enter дважды.






Рис.50 – Состояние программы перед входом в процедуру Scan

В этом месте рассмотрим переменные в окне «Watches». Счетчик циклов k равен единице, – это глобальная переменная k, поскольку локальной переменной с этим же именем пока не существует. Переменная S содержит то, что мы ввели с клавиатуры. Параметр arg тоже пока не виден отладчику, о чём говорит сообщение «Unknown identifier».

Нажмите клавишу F7 ещё пару раз, пока цветная полоска не перескочит внутрь процедуры Scan. Здесь параметр arg примет то же значение, что и глобальная переменная S, – это прекрасно видно в отладчике. Продолжайте нажимать клавишу F7, пока цветная полоска не дойдет до слова END в конце процедуры. Вы увидите, как параметр arg постепенно принимает значение «QBBBW», – это то, что нам нужно. Состояние программы в этот момент показано на рис. 51.






Рис. 51 – Состояние программы перед выходом из процедуры Scan

Теперь переменная k равна пяти, – это длина введенной строки. Но это уже другая, локальная переменная k, поскольку её глобальная тёзка внутри процедуры не видна. Но переменная S (тоже глобальная) по-прежнему видна внутри процедуры, ведь её имя не перекрывается локальной переменной.

Нажмите клавишу F7 ещё раз, – программа выйдет из процедуры и цветная полоска перепрыгнет на строку, следующую за вызовом процедуры Scan (рис. 52).






Рис. 52 – Состояние программы после выхода из процедуры Scan

Итак, к чему мы пришли? Сравнив это состояние с тем, что было до входа в процедуру (рис. 50), находим, что значения переменных не изменились. Переменная k снова стала равна единице, и это понятно – ведь теперь это глобальная переменная. Беда в том, что не изменилась и переменная S, а ведь именно этого мы добивались. В чем же дело?

Причина кроется в способе передачи параметра. При вызове процедуры Scan фактический параметр S копируется в формальный параметр arg, и далее внутри процедуры работа введется с этой копией. Иначе говоря, данные передаются только внутрь процедуры, но не обратно. Этот способ передачи параметров называют передачей по значению. Стало быть, глобальная переменная S не должна была измениться! Здесь надо что-то исправлять!


Ссылка на переменную

Рассмотрим ещё раз объявление параметра в процедуре Scan.


procedure Scan(arg : string);


Оказывается, что при таком объявлении формальный параметр arg представляет собой локальную переменную. От прочих таких переменных он отличается лишь тем, что при вызове процедуры в него автоматически копируется значение фактического параметра. Вы знаете, что локальные переменные существуют, пока выполняется процедура, а по её завершении исчезают. Потому результат обработки и не возвращается назад в вызывающую программу.

Впрочем, добиться нужного результата несложно: достаточно вставить в объявление параметра ключевое слово VAR.


procedure Scan(var  arg : string);


Это мелкое изменение влечет важное следствие: теперь arg – не локальная переменная, а ссылка на другую переменную. Это значит, что в момент вызова процедуры данные не будут копироваться, но параметр arg на время исполнения процедуры станет дублером фактического параметра S. Теперь, изменяя параметр arg, мы тем самым будем изменять и переменную S – наш фактический параметр.

Передавая параметр по значению, вызывающая программа как бы говорит вызываемой процедуре: «вот тебе данные (строка, число и т.п.), сохрани их у себя внутри и делай с ними, что угодно, – дальнейшая их судьба меня не интересует».

Передавая же параметр по ссылке, вызывающая программа «говорит» иначе: «нужные тебе данные находятся в такой-то глобальной переменной, и ты вправе поступать с нею как угодно».

Обратите внимание на двоякое предназначение ключевого слова VAR. Во-первых, оно открывает секцию объявления переменных, а во-вторых, служит для указания ссылки на переменные в параметрах процедур.

Вернемся к программе. Если она остановилась в пошаговом режиме, прервите её комбинацией Ctrl+F2. Затем исправьте заголовок процедуры указанным выше манером, откомпилируйте программу и вновь пройдите по шагам. Находясь внутри процедуры Scan, вы заметите, что переменные arg и S теперь изменяются синхронно (рис. 53). Это то, что нам нужно, стало быть, проблема решена!






Рис. 53 – Синхронное изменение формального и фактического параметров

Далее можете «толкнуть» программу в непрерывном режиме, нажав комбинацию Ctrl+F9.


Итоги

• Для поиска ошибок применяют встроенный отладчик, который позволяет выполнять программу по шагам, а также просматривать переменные и менять их значения.

• При объявлении параметра без ключевого слова VAR, данные передаются только внутрь процедуры (по значению). Такой параметр используют как локальную переменную.

• Для передачи данных как внутрь процедуры, так и обратно, параметр объявляют с ключевым словом VAR. Тогда он служит ссылкой на другую переменную и меняется синхронно с нею.


А слабо?

А) Комбинация клавиш Ctrl+F8 устанавливает так называемые точки останова на исполняемых операторах. Эта же комбинацией отменяет их. Точка останова – это строка, на которой отладчик задерживает выполнение программы и ждет команды на её продолжение в непрерывном или пошаговом режиме..

Установите точку останова на выходе из процедуры Scan (на строке END) и запустите программу в непрерывном режиме (Ctrl+F9). Что произойдет? Чем, по-вашему, удобны точки останова?

Б) Перед запуском программы установите курсор внутри процедуры Scan и испытайте действие команды Run –> Go to cursor (клавиша F4).

Глава 22

О передаче параметров

 Сделать закладку на этом месте книги




Современные программы — даже не самые сложные — насчитывают тысячи строк. Как же распределена эта сложность? Почти вся она «размазана» по процедурам и функциям, а главную программу составляют обычно несколько строчек. Процедуры и функции, вызывая друг друга, передают данные словно эстафету по цепочке. Будущий профессионал должен овладеть тонкостями этого механизма.


Процедура обмена

Рассмотрим процедуру с несколькими параметрами. Пусть надо обменять значения в переменных A и B, это можно сделать так:


      T:= A;       { временно запомнить A }

      A:= B;

      B:= T;       { поместить в B то, что раньше было в A }


Здесь T – переменная для временного хранения данных. Поручим эту простенькую работу процедуре, которую назовем Swap (обмен). Создавать процедуру начнем, как водится, с заголовка. Поскольку в обмене участвуют два числа, оба их надо передать через параметры. Для разделения формальных параметров используют точку с запятой. Если заголовок процедуры будет таким:


procedure Swap (x: integer; y: integer);


мы не добьемся своего, поскольку при передаче по значению результаты не вернутся в вызывающую программу. Правильным будет заголовок с двумя ссылками на переменные.


procedure Swap (var x: integer; var y: integer);


Если формальные параметры имеют одинаковый тип и способ передачи, то заголовок можно сократить так:


procedure Swap (var x, y: integer);


Принцип объединения в заголовке тот же, что при объявлении однотипных переменных в секции VAR.

Теперь напишем процедуру Swap и программу «P_22_1» для её проверки.


{ P_22_1 – процедура обмена и программа её проверки }


{ процедура обмена }

procedure SWAP(var x,y : integer);

var t: integer;

begin

      t:= x;       x:= y;       y:= t;

end;


var A, B : integer;

begin       {--- главная программа ---}

      A:= 10; B:= 20;

      Writeln(’A= ’, A, ’ B= ’, B);

      SWAP(A, B);

      Writeln(’A= ’, A, ’ B= ’, B);

      Readln;

end.


Работает ли эта программа? Обязательно проверьте!


Замена символов в строке

Вернемся к программе P_20_1, где возможности процедуры Scan небогаты: допускается менять только символы «A» на символы «B». А если надо менять символы по своему усмотрению? Пожалуйста! Добавим в заголовок процедуры пару формальных параметров, например, так:


procedure Scan(var arg: string; Ch1, Ch2: char);

var k: integer;

begin

      for k:=1 to Length(arg) do

      if arg[k]= Ch1 then arg[k]:= Ch2;

end;


Здесь параметры Ch1 и Ch2 указывают, что и на что надо поменять. Поскольку параметры однотипны, они разделяются запятой. Порядок объявления формальных параметров в заголовке не важен. Но важно, чтобы при вызове процедуры порядок фактических параметров был таким же. Вот пример правильного вызова (символ «1» меняется на символ «2»).


Scan(S, ’1’, ’2’);


А вот ошибочные:


Scan(S, ’1’);       { указаны не все параметры }

Scan(’1’, S, ’2’);       { нарушен порядок следования параметров }

Scan(S, ’1’, ’2’, ’3’);       { указан лишний параметр }

Scan(S, 1, 2);       { неверный тип параметров }


За соответствием фактических параметров формальным жестко следит компилятор. Исключение составляют встроенные в язык процедуры ввода-вывода, такие как Readln и Writeln, где допускается гибкая передача параметров разных типов.

Переработайте программу «P_20_1» с тем, чтобы испытать новую версию процедуры замены символов, а затем исследуйте её в пошаговом режиме.


О передаче строк

Передача строковых данных таит свои тонкости. Рассмотрим процедуру Calc для подсчета заданного символа в некоторой строке.


procedure Calc(arg: string; Ch: char; var Res: integer);

var k: integer;

begin

      Res:=0;

      for k:=1 to Length(arg) do

      if arg[k]= Ch then Res:= Res+1;

end;


Процедура принимает три разнотипных параметра: строку arg, символ Ch и ссылку на переменную Res – в ней возвращается результат. Здесь все правильно. Но недаром говорят: «меньше знаешь, – крепче спишь», – мой сон тревожит параметр arg строкового типа.

Поскольку строка может содержать до 255 символов, параметру arg отводится немалая память – 256 байтов! При передаче по значению все эти байты копируются в параметр arg, и на это тратится время. Если же параметр arg будет ссылкой на строку, то копирования не потребуется, и программа заработает быстрее. Вдобавок мы и память сэкономим, ведь ссылка на строку занимает в памяти всего 4 байта! Раз так, объявим процедуру иначе.


procedure Calc(var arg: string; Ch: char; var Res: integer);


Этот вариант лучше, но не сработает, если в вызове процедуры указать строковую константу, например:


      Calc(’PASCAL’, ’L’, Result);


Здесь компилятор воспротивится не на шутку, требуя в первом параметре переменную. И будет прав, поскольку ключевое слово VAR в заголовке процедуры объявляет ссылку на переменную, а не на константу. Что делать? Вернуться к первому способу? Нет, есть лучшее средство: вместо ключевого слова VAR укажите в заголовке слово CONST, вот так:


procedure Calc(const  arg: string; Ch: char; var Res: integer);


Такая ссылка будет годна как для переменной, так и для константы.


      Calc(’PASCAL’, ’L’, Result);       { вызов с константой }

      Calc(S, ’L’, Result);       { вызов с переменной }


Слово CONST перед формальным параметром, так же, как и VAR, определяет ссылку на данные, но без возможности их изменения. Обратите внимание на двойное назначение слов CONST и VAR: их применяют и для открытия соответствующих секций, и для объявления ссылочных параметров.


Итоги

• Количество фактических параметров, их тип и порядок следования в вызове должны совпадать со списком формальных параметров процедуры.

• Для экономии памяти и повышения быстродействия строковые данные (и другие сложные типы данных) передают по ссылке с применением ключевых слов CONST и VAR.

• Если строку передают по ссылке только внутрь процедуры, используют ключевое слово CONST, а если обратно или в оба направления – слово VAR.

• Если строка передается только внутрь процедуры и далее применяется там как локальная переменная, то ключевые слова CONST и VAR в объявлении параметра не ставят (так происходит передача параметра по значению).


А слабо?

А) Введите в компьютер программу «P_22_1» и проверьте её работу.

Б) Измените программу «P_20_1» так, чтобы заменяемый и замещаемый символы передавались в процедуру Scan через параметры.

В) Напишите программу для проверки рассмотренной выше процедуры Calc, подсчитывающей символ в строке.

Глава 23

Функции

 Сделать закладку на этом месте книги




убрать рекламу







Процедуры и функции – сестры-близнецы, потому и носят общее имя – подпрограммы. Все, что сказано о передаче параметров, относится и к тем, и к другим. И все же функции чем-то отличаются от процедур, иначе, зачем их придумали? А затем, чтобы упростить возвращение результата.

Нередко таким результатом бывает число, строка, символ или булево значение. Конечно, вернуть результат можно и через ссылку на переменную, но функция сделает это удобней – через своё имя. Результат, возвращаемый функцией, можно вставлять внутрь выражений наряду с переменными и константами. Взять хотя бы знакомые нам функции Random и Length, вызовы которых можно применить, например, так:


      x:= 1+ Random(10);       { арифметическое выражение }

      Writeln(Length(S)); { печатается длина строки S };


Функции избавляют программиста от объявления лишних переменных, упрощая программы и повышая их надежность. Сейчас мы научимся создавать собственные функции.


Объявление функции

Подобно объявлению процедуры, объявление функции состоит из заголовка и тела. Тело строят по тем же правилам, что и для процедур, а вот заголовок выглядит немного иначе.


function  Имя_Функции : Тип ;       { функция без параметров }

function  Имя_Функции (Параметры) : Тип ;       { функция с параметрами }


Отличий от процедуры всего два. Во-первых, вместо ключевого слова PROCEDURE указано слово FUNCTION. А во-вторых, завершает заголовок тип функции (тип возвращаемого ею результата), – его указывают после двоеточия.


Пример функции

Разберем все это на примере. Создадим функцию, выбирающую большее из двух чисел. Разумеется, что функция будет принимать два параметра – сравниваемые числа, и возвращать будет тоже число. Стало быть, её заголовок может быть таким:


function Max(arg1, arg2 : integer) : integer;


Имя функции выбираем на свой вкус, здесь имя Max вполне подходит, оно означает MAXIMUM (наибольший). К этому заголовку прилепим тело функции, состоящее из одного условного оператора.


function Max(arg1, arg2 : integer) : integer;

begin

      if arg1 > arg2

      then Max := arg1

      else Max := arg2

end;


Но откуда взялась переменная Max, которой присваиваем значение? Ведь мы её не объявляли! А её и не надо объявлять, – это имя нашей функции, оно и принимает в себя результат. Мало того, если результату не присвоить значение, он останется неопределенным, и это будет ошибкой!

Созданная нами функция может вызываться так:


      A:= Max( 20, 10 );       { A = 20 }

      Writeln( Max( A, B ) );       { печатается большее из A и B }


Вызов функции можно использовать даже как фактический параметр в её собственном вызове, то есть организовать вложенные вызовы, например:


      A:= Max ( Max ( 20, 10 ), 40 );       { A = 40 }

      A:= Max ( Max ( 20, 10 ), Max ( 200, 100 ) ); { A = 200 }


В первом случае сначала вызывается функция Max(20,10), вставленная как первый фактический параметр, а затем Max(20,40), – то есть результат первого вызова подставляется параметром во второй. Похоже работает и другой пример, только функция вызывается трижды. Полезно понаблюдать за такими вызовами через отладчик. Напишите главную программу для исследования функции Max и прогоните её в отладчике.


Подсчет символов в строке

В прошлой главе я предложил вам написать процедуру для подсчета заданного символа в строке. Если вы справились с той задачей, то для возврата результата наверняка воспользовались ссылкой на переменную. Теперь рассмотрим решение с применением функции.

Начнем, разумеется, с заголовка функции, дадим ей имя Count (подсчет).


function Count(const Str : string; Ch : char): integer;


Функция принимает два параметра: ссылку на строку и символ, который надо подсчитать. Напомню, что ключевое слово CONST в объявлении параметра позволяет ссылаться и на константу, и на переменную. Тело функции строим на базе цикла со счетчиком.


function Count(const str : string; ch: char): integer;

var N, i: integer;

begin

N:=0; { обнуляем счетчик }

for i:=1 to Length(str) do

      if str[i]=ch then N:= N+1;

Count:= N; { определяем результат функции }

end;


Подсчет символов в массиве ведется в локальной переменной N, и лишь по завершении цикла результат копируется в имя функции. Грубой ошибкой было бы накапливать счетчик прямо в имени функции:


      if str[i]=ch then Count:= Count+1 ; { – это ошибка! }


Запомните: в теле функции её имя применяется только слева от оператора присваивания! Есть исключения из этого правила, но мы пока не будем их касаться.

И, наконец, напишем программу «P_22_1» для проверки функции Count. В главной программе функция вызывается сначала для переменной S, а затем для константы «BANAN». Причем во втором случае она вызывается дважды, а результат суммируется. Испытайте эту программу.


{ P_23_1 – подсчет заданных символов в строке }


function Count(const str : string; ch: char): integer;

var N, i: integer;

begin

N:=0; { обнуляем счетчик }

for i:=1 to Length(str) do

      if str[i]=ch then N:= N+1;

Count:= N; { передаем результат через имя функции }

end;

var S: string;

begin {--- главная программа ---}

S:='PASCAL';

Writeln( Count(S, 'A'));

Writeln( Count('BANAN', 'N') + Count('BANAN', 'B'));

Readln;

end.



Возврат строк

Вернемся к программе «P_20_1», заменяющей символы «A» на символы «B». Помните сколько крови она попортила прежде чем заработать? Заменив процедуру Scan на функцию с тем же именем, мы решим проблему возврата результата. Результат, разумеется, должен иметь строковый тип. Обратите внимание на то, что ключевые слова VAR или CONST в заголовке не указаны, а потому параметр arg можно употребить в теле функции в качестве локальной переменной.


{ P_23_2 – замена символов в строке с применением функции }


function Scan(arg : string): string;

var k: integer;

begin

      for k:=1 to Length(arg) do

      if arg[k]=’A’ then arg[k]:=’B’; { замена в параметре arg }

      Scan:= arg; 

end;

var S: string; k: integer;

begin {--- главная программа –--}

      for k:=1 to 3 do begin

      Write(’Введите строку: ’); Readln(S);

      Writeln(Scan(S));

      end;

      Readln;

end.



Когда результат не важен

Хорошая функция возвращает правильный результат, а отличная делает ещё что-нибудь полезное. Программисты нередко поручают одной функции несколько дел, вот пример: напишем функцию Swap (обмен) булевого типа, принимающую ссылки на две переменные. Функция должна сравнить эти переменные и вернуть TRUE, если первая из них окажется больше второй. Мало того, в этом случае она должна обменять значения этих переменных (как в процедуре Swap, рассмотренной ранее). Короче, функция будет такой.


function Swap( var a1, a2 : integer) : Boolean;

var t: integer;

begin

      if a1 > a2

      then begin

      { обмен значений переменных }

      t:=a1; a1:=a2; a2:=t;

      Swap:= true

      end

      else Swap:= false

end;


Где применить такую функцию? Пусть переменные N1, N2, N3 содержат три разных числа. Переложим эти числа так, чтобы в N1 оказалось наименьшее, а в N3 – наибольшее число, то есть, чтобы соблюдалось условие: N1 < N2 < N3. Такая сортировка выполняется тремя вызовами функции Swap (в комментариях показаны результаты обмена).


      Swap (N1, N2);       { N1 < N2 }

      if Swap (N2, N3)       { N2 < N3 }

      then Swap (N1, N2);       { N1 < N2 < N3 }


Здесь в первой и третьей строках функция вызывается как процедура, поскольку возвращаемый ею булев результат не используется. Во второй строке она вызывается как функция, поскольку результат использован оператором IF.

Возможность вызывать функцию как процедуру называют расширенным синтаксисом (Extended syntax), – он должен быть разрешен в настройках компилятора, иначе вызов функции как процедуры компилятор сочтет ошибкой.


Неявная переменная Result

Современные версии компиляторов дают новую возможность в части построения функций. Так, компилятор Delphi позволяет, наряду с именем функции, для возврата результата использовать автоматически объявляемую переменную Result. Тип переменной Result совпадает с типом функции. Тогда функцию подсчета символов можно упростить так:


function Count(const str : string; ch: char): integer;

var i: integer;

begin

Result:=0 ; { обнуляем счетчик }

for i:=1 to Length(str) do

      if str[i]=ch then Result:= Result + 1 ;

end;


Как видите, переменную Result можно использовать как в левой, так и в правой части оператора присваивания. Последнее значение переменной станет результатом функции.

Итак, потратив три главы на изучение процедур и функций, мы готовы, наконец, к настоящему делу. Сколько можно в цацки играть? В следующей главе приступим к шифрованию файлов!


Итоги

• Функции – это подпрограммы, возвращающие результат через свое имя. Тип возвращаемого результата указывают в заголовке функции.

• В теле функции обязательно присваивают значение функции (через её имя), иначе результат останется неопределенным, случайным.

• Вызовы функций можно использовать в выражениях наряду с константами и переменными.

• Когда результат функции не используется, её вызывают как процедуру. При этом через настройки компилятора должен быть позволен расширенный синтаксис – «Extended syntax».


А слабо?

А) Напишите функцию для поиска буквы в заданной строке. Она должна возвращать TRUE, если в строке есть хоть одна эта буква, и FALSE в противном случае. Напишите программу для проверки функции. Или слабо?

Б) Напишите функцию для определения позиции буквы в заданной строке. Функция должна вернуть позицию первой такой буквы или ноль, если буквы в строке нет. Напишите программу для проверки функции.

В) Напишите функцию и программу для её проверки, принимающую число и возвращающую строку: слово «четное» или «нечетное» в зависимости от четности или нечетности параметра. Подсказка: для проверки четности числа N надо проверить остаток от его деления на два: if (N mod 2) = 0 then …

Глава 24

Криптография

 Сделать закладку на этом месте книги




Говорят, что хороший разведчик стоит целой дивизии. Ещё бы! Ведь лишенный секретов противник почти безоружен. Но вот умолкли пушки, а разведка не спит, – у мирного времени свои тайны: коммерческие и технические секреты. Впрочем, если секретов нет, их можно придумать, – почему бы нам не поиграть в шпионов? Приятно сознавать, что «отмыленное» приятелю письмо никто, кроме вас двоих, не прочтет, – надо лишь зашифровать его. Придумана уйма способов шифрования, есть даже наука об этом – криптография; сейчас и мы коснемся краешка этой премудрости.


Секреты Юлия Цезаря

Римскому полководцу Юлию Цезарю выпали лихие времена. Отправляя гонца с письмом в отдаленный уголок империи, Цезарь рисковал «подарить» свои тайны недругам, – ведь на дорогах было неспокойно. Это надоумило его шифровать свои письма. В чем заключался метод Цезаря?

Прием Юлия состоял в замене одних букв другими путем кругового сдвига алфавита на несколько позиций. На рис. 54 показано превращение букв при сдвиге алфавита на две позиции. Буква «А» становится буквой «В», буква «Б» – буквой «Г» и так далее. Двум последним уготовано превратиться соответственно в буквы «А» и «Б». Такое шифрование превращает письмо в дикую абракадабру!






Рис.54 – Принцип шифрования Юлия Цезаря

Как расшифровать её? Очень просто – сдвинуть буквы в обратную сторону. Но надо знать количество сдвигов – это число называют ключом шифра (в примере на рисунке ключ шифра равен двум). Разумеется, что ключ шифра и метод шифрования знали лишь двое: получатель письма и сам Юлий Цезарь.

Пойдем и мы вслед римскому полководцу, – создадим программу для шифрования текстового файла и его расшифровки. Скажу прямо: задача непростая, а потому решать её будем в два этапа. Вначале освоим шифрование отдельной строки, а уж потом «замахнемся» на файл. Но начнем с шифрования отдельного символа.


Суть проблемы

Зашифровать строку – значит зашифровать каждый её символ. Будь у нас готовая функция шифрования символа, задача решалась бы вмиг. Так займемся ею и начнем с заголовка. Дадим нашей функции имя Encrypt – «шифровать», она должна принимать исходный символ и возвращать другой, зашифрованный. Значит, заголовок функции может быть таким:


function Encrypt (X: char): char;


Теперь сосредоточимся на теле функции и рассмотрим известные нам приёмы обработки. Один из них состоит в применении каскада условных операторов:


if X=’А’

      then Crypt:=’В’

else if X=’Б’

      then Crypt:=’Г’

else...


Насколько удачно это решение? Прикинем количество вложенных операторов в этой лесенке. В русском алфавите 33 буквы, если взять заглавные и строчные, то получится 66. А если надумаем шифровать ещё и латинские буквы, и цифры и знаки препинания, то наберется около двух сотен символов. Такая лесенка условных операторов растянется на несколько этажей!

Не прибегнуть ли к оператору выбора CASE? Тогда тело функции будет намного проще:


case X of

      ’А’: Crypt:=’В’;

      ’Б’: Crypt:=’Г’;

      ...

end;


Обратите внимание, что метками оператора CASE здесь служат символы, – скоро вы узнаете, почему такое возможно. Этот вариант очевидно лучше первого, хотя две сотни меток – тоже не подарок. Но главное неудобство в ином: при изменении ключа шифра придется переписать все ветви оператора CASE, а это, согласитесь, скучно. Не поискать ли иного решения, простого и гибкого?


О кодировании символов

Первые компьютеры принесли инженерам массу неудобств. Взять хотя бы ввод и вывод данных. Дисплеи, принтеры и звуковые карты – тогда никто не слышал о них! Результат размышлений цифрового «мозга» высвечивался лампочками на инженерной панели ЭВМ, и в эту двоичную «цветомузыку» был посвящён лишь узкий круг мудрецов. Со временем изобрели простые принтеры, способные печатать лишь цифры, а затем и более совершенные – для печати букв и других символов. Как действуют подобные устройства?

Процессор компьютера, как известно, оперирует с числами. А людям подавай то текст, то картинку. Как связать одно с другим? Здесь инженеры вспомнили об алфавите. Ведь буквы в нём упорядочены, а значит, каждой букве можно сопоставить число; например, букве «А» – один, «Б» – два и так далее. Такое сопоставление называют кодированием, оно и решает проблему представления символов. Намерившись напечатать некоторый символ, компьютер передает его код на принтер, а уж принтер знает, как поступить с этим числом. При вводе с клавиатуры происходит обратное преобразование: нажатие клавиши заставляет клавиатуру отправить в процессор код соответствующего символа.

Итак, символы внутри компьютера кодируются числами. Мы посчитали, что общее количество букв, цифр и других знаков составляет более двухсот. Инженеры не поскупились и отвели для кодирования символов 256 чисел – от 0 до 255 включительно. Почему именно 256, а не 300 или 500?

Дело в том, что в двоичной системе счисления 256 – это круглое число, оно равно двойке в восьмой степени (если вам знакомо слово «байт», то речь о нём). Так был создан «алфавит» для компьютеров, он включает буквы, цифры, знаки препинания и управляющие символы, – последние выполняют специальные действия с печатающим устройством, например, перевод на следующую строку.

Понятно, что можно придумать несметное количество вариантов кодирования символов. Желая добиться взаимопонимания между техническими устройствами разных изготовителей, инженеры договорились о единой системе кодирования. Теперь она известна под именем ASCII (читается «аски») – American Standard Code for Information Interchange – американский стандартный код для обмена информацией. Со временем этот стандарт стал международным. Ныне используют несколько стандартов кодирования, один из них (для MS-DOS) представлен в приложение И.

Все кодируемые символы разбиты на три группы. Первую составляют управляющие символы с кодами от 0 до 31. Их названия вам мало о чем скажут, обратите внимание лишь на символы с кодами 10 и 13, – они служат для разбивки текста на строки.

Вторую группу составляют символы с кодами от 32 до 127, – здесь собран весь латинский алфавит, цифры и основные знаки. Коды латинских букв следуют в порядке латинского алфавита, причем разница между кодами одноименных больших и маленьких букв составляет 32.

Наконец, в третьей группе собраны русские буквы, символы псевдографики (их применяют для рисования таблиц) и другие редко используемые знаки. Коды большинства русских букв тоже следуют в порядке русского алфавита, но некоторые выпадают из этой последовательности.

Заметьте также, что символы русского и латинского алфавитов со схожими начертаниями (такие, как «А», «В», «Р») представлены разными кодами!


Чудесные превращения

Итак, символы в компьютере представлены своими кодами, то есть числами. А с числами работать легко: для превращения кода одного символа в код другого надо лишь прибавить либо вычесть некоторое число – шифрующий ключ.

Но как превратить символ в число и наоборот, — число в символ? Ведь это данные разных типов. Паскаль поможет вам своими встроенными функциями. Преобразовать число в символ можно либо функцией CHR, которая изначально присутствовала в языке, либо её современным аналогом по имени CHAR, которым я иногда буду пользоваться в дальнейшем. Обе функции принимают число, а возвращают символ, вот их объявления:


function Chr(arg : integer) : char;

function Char(arg : integer) : char;


Случайно ли, что имя функции CHAR совпадает с именем типа данных? Нет, ведь на самом деле обе эти функции ничего не делают! Они лишь подсказывают компилятору, что число в скобках — это код символа. И все! С такими «ненастоящими» функциями мы ещё встретимся, их применяют для преобразования типов данных. Вот как можно напечатать нескольких символов с их кодами.


var n: integer;

begin

      for n:=40 to 50 do

      Writeln(n,' ', Char(n))

end.


Для обратного преобразования — символа в число — применяют другую «ненастоящую» функцию по имени ORD (от ORDER — «порядковый номер»). Cейчас компиляторы предлагают и её аналог по имени Byte. Функция действительно возвращает порядковый номер символа в таблице ASCII, вот её заголовок:


function Ord(arg : char) : integer;


Воспользовавшись ею, мы тоже можем напечатать символы с их кодами.


var с: char;

begin

      for c:=’A’ to ’F’ do

      Writeln(c,' ', Ord(c))

end.


Здесь счетчиком цикла FOR служит переменная символьного типа. Паскаль допускает это, поскольку «знает», что каждому символу соответствует некоторое число – его код.

Итак, научившись превращать числа в символы и наоборот, мы оказались в шаге от поставленной цели – шифрования символа.


Шифрование символа

Вернемся к функции шифрования Encrypt, теперь мы можем упростить её до предела.


function Encrypt(arg: char): char;

begin

      Crypt:= Char(Ord(arg) + CKey);

end;


Здесь CKey – ключ шифра, хранящийся где-то в глобальной константе или переменной. Превратив символ arg в число, мы прибавляем к нему ключ, а полученную сумму вновь превращаем в символ.

Все хорошо, прекрасная маркиза, за исключеньем пустяка: сумма в скобках может оказаться больше 255, а символа с таким кодом не существует! Как тогда поступит функция Char? Она вернет символ, укоротив его код на 256. Например, функция Char(260) вернет символ с кодом 260–256=4. Устроит нас это? Никак нет, поскольку первые 32 символа таблицы (коды от 0 до 31) – это управляющие символы. К сожалению, такие символы нарушат структуру текстового файла, и редактор не сможет прочесть его.

Значит, при передаче суммы в функцию Char надо проверить, не превышает ли она 255? Если да, то обрубим ей «хвост» и сдвинем ещё на 32 позиции выше, чтобы попасть в область видимых символов с кодами от 32 и далее.


if X>255 then X:=X–256+32; { смещаем «хвост» – в начало видимых символов }


Так получаем окончательный вариант функции шифрования символа.


function Encrypt(arg: char): char;

var x: integer;

begin

      x:= Ord(arg)+ CKey;

      if x>255 then x:= x–256+32;

      Crypt:= Char(x);

end;



Расшифровка символа

Понятно, что для расшифровки символа надо выполнить обратный сдвиг. После вычитания ключа проверим, не попадает ли полученная разность в область управляющих символов? Если попадает, поправим её, сместив в область видимых символов. Вот текст функции расшифровки Decrypt.


function Decrypt(arg: char): char;

var x: integer;

begin

      x:= Ord(arg)– CKey;

      if x<32 then x:= x+256–32;

      Decrypt:= Char(x);

end;


Теперь все готово для построения программы шифрования и расшифровки строки «P_24_1».


{ P_24_1 – Шифрование строки}

const CKey = 2; { Ключ Цезаря }


{––––– Шифрование одного символа –––––}

function Encrypt(arg: char): char;

var x: integer;

begin

      x:= Ord(arg)+ CKey;

      if x>255 then x:= x–256+32;

      Encrypt:= Char(x);

end;

{––––– Расшифровка одного символа –––––}

function Decrypt(arg: char): char;

var x: integer;

begin

      x:= Ord(arg)– CKey;

      if x<32 then x:= x+256–32;

      Decrypt:= Char(x);

end;


{––––– Шифрование строки –––––}

procedure EncryptStr(var arg: string);

var k: integer;

begin

      for k:=1 to Length(arg) do

      arg[k]:= Encrypt(arg[k]);

end;

{––––– Расшифровка строки –––––}

procedure DecryptStr(var arg: string);

var k: integer;

begin

      for k:=1 to Length(arg) do

      arg[k]:= Decrypt(arg[k]);

end;

      {––––– Главная программа –––––}

var S: string;

      Oper: integer;

begin

      repeat

      Write('Введите строку: '); Readln(S);

      Writeln('Укажите операцию: 1– шифровать,’+

      ’ 2– расшифровать,’+

      ’ Прочие – выход');

      Readln(Oper);

      case Oper of

      1: EncryptStr(S);

      2: DecryptStr(S);

      else Break;

      end;

      Writeln(S); { печатаем результат }

      until false;

end.


Программа нуждается лишь в кратких пояснениях. Глобальная константа CKey содержит ключ шифра. Если со временем захотите сменить его, достаточно будет изменить константу и заново откомпилировать программу. Далее следуют описания двух функций: Encrypt и Decrypt – для шифрования и расшифровки символа. Процедуры EncryptStr и DecryptStr шифруют и расшифровывают строки, передаваемые им по ссылке VAR. И, наконец, в главной программе организован цикл для ввода шифруемой строки и кода выполняемой операции (Oper).

Откиньтесь в кресле и полюбуйтесь простотой блоков, составляющих эту программу! А во что бы мы превратили её, свалив в кучу эти простые алгоритмы? В заключение приведу протокол шифрования: пользователь ввел слово «pascal» и зашифровал его, получив слово «rcuecn». Затем ввел строку «rcuecn» и расшифровал её, получив назад данное мною слово.


Введите строку: pascal 

Операции: 1 – шифровать, 2 – расшифровать, прочие – выход

Введите операцию: 1

rcuecn

Введите строку: rcuecn 

Операции: 1 – шифровать, 2 – расшифровать, прочие – выход

Введите операцию: 2

pascal

Операции: 1 – шифровать, 2 – расшифровать, прочие – выход

Введите операцию: 3


Вряд ли я удержу вас от испытания столь полезного изделия. Во избежание ошибок, шифруйте строки небольшой длины. Рекомендую также хотя бы разок пройти программу по шагам.


Итоги

• В памяти компьютера символы представлены своими кодами – числами.

• Общее количество символов составляет 256, из них первые 32 – это управляющие, а остальные – видимые символы.

• Для преобразования числового кода в символ применяют функцию Char. Для обратного превращения – символа в число – пользуются функцией Ord..

• Паскаль «знает» о том, что символы кодируются числами, поэтому в счетчике цикла FOR допустимы символьные переменные, а в метках оператора CASE – символьные константы.


А слабо?

А) Измените программу шифрования с тем, чтобы ключ задавать с клавиатуры и передавать в процедуры и функции через параметр. Заголовки процедур и функций сделайте такими:


function Encrypt(arg: char; key: integer): char;

procedure EncryptStr(var arg: string; key: integer);


Хотя здесь проще держать ключ в глобальной переменной, но крупные программы этот приём запутывает, – там лучше передавать данные через параметры.

Б) Предположим, вы пятикратно зашифровали строку. Можно ли расшифровать её? И как это сделать?

В) Для введенной пользователем строки напечатать позиции всех входящих в неё символов (кроме пробелов) в алфавитном порядке. Для символов, которые встречаются несколько раз, напечатать их позиции в одной строке. Например, для слова «PASCAL»:


A – 2 5

C – 4

L – 6

p – 1

S – 3


Г) Для введенной пользователем строки напечатать позиции всех встречающихся в ней символов, кроме пробелов, в порядке их следования в строке. Например, для слова «PASCAL»:


P – 1

A – 2 5

S – 3

C – 4

L – 6


Д) Строки текстовых файлов порой содержат управляющие символы, например символ горизонтальной табуляции (код 9). Шифрование этих символов нашей программой нарушит структуру файла. Исправьте функции Encrypt и Decrypt так, чтобы они не изменяли символы, коды которых меньше 32.

Глава 25

Текстовые файлы

 
убрать рекламу






lse;>Сделать закладку на этом месте книги




Мы мастерим программу шифрования текста. Шифрование отдельной строки освоено нами в предыдущей главе. Теперь научимся читать строки из одного файла и записывать их в другой.


Файлы хорошие и разные

Файлы – это хранилища данных, там может быть все что угодно: музыка, фильмы, книги. Ясно, что эта информация как-то закодирована, то есть, представлена в виде чисел – байтов. Файл любого типа – это набор байтов, хранящийся на диске (говорим пока о дисковых файлах). Каждому типу файлов нужен свой подход: к файлу нужна программа, «понимающая» его содержимое. Вам угодно слушать музыку? – к вашим услугам медиа-проигрыватель. Или надо печатать текст? – тогда запустите редактор текста. Но не наоборот! А все потому, что каждый тип файлов обладает структурой, понятной лишь соответствующей программе. Таким образом, файл и программа для работы с ним составляют логическое единство, – одно без другого лишено смысла.

Стало быть, структура или формат файла – его важнейшая характеристика. Все файловые форматы можно разделить на две категории:

• текстовые файлы;

• все прочие файлы, – их называют двоичными или бинарными.

О формате файла можно судить по его расширению. К текстовым относятся файлы с расширениями TXT – текст, BAT – пакетный файл, LOG – файл протокола и многие другие. Файлы наших программ с расширением PAS – тоже текстовые. А вот документы в формате Word (с расширением DOC) обладают сложной структурой, правильнее отнести их к бинарным. Так же, как и книги PDF–формата. В отличие от DOC и PDF, текстовые файлы открываются простыми редакторами текста – вроде «Блокнота» или редактора нашей IDE, который тоже работает с текстовыми файлами.


Формат текстовых файлов

Итак, любой файл – это набор байтов, записанных на диске. Как же расположены байты в текстовых файлах? – мы должны это знать. Воспользуемся «волшебным микроскопом» и рассмотрим через него отдельные байты небольшого текстового файла, составленного из четырех строк: в первой помещены три символа «1», во второй – два символа «2», третья строка пуста, а четвертая содержит символ «3».

Примечание.  Вы можете исследовать текстовый файл в HEX–режиме просмотра такими программами, как Far, Total Commander и им подобными.


111

22


3


Наш воображаемый микроскоп изобразит этот файл цепочкой чисел (здесь показаны десятичные числа, хотя в HEX-режиме видны шестнадцатеричные).


49 49 49 13 10  50 50 13 10 13 10  51 13 10 


Числа 49, 50 и 51 – это коды символов «1», «2» и «3» (по кодировке ASCII), а выделенные курсивом числа 13 и 10 – это парочка управляющих байтов, разбивающая файл на строки. Открыв такой файл редактором, мы не увидим управляющих байтов, но в файле они есть! Любая программа, работающая с текстовыми файлами, умеет находить эти ограничители строк при чтении текста и вставлять их в файл при записи в него.

История названий ограничителей исходит из глубины веков. Символ с кодом 13 назван Carriage Return – «возврат каретки» или сокращенно CR. Те, кто застал электрические пишущие машинки прошлого, помнят: перед печатью следующей строки, каретка такой машинки сдвигалась в крайнюю правую позицию, – это и есть возврат каретки.

А управляющий символ с кодом 10 назван Line Feed (LF) – «подача строки». Он заведовал подачей бумаги в продольном направлении с тем, чтобы следующая строка печаталась после предыдущей. Вот так и работал консольный интерфейс прошлого: барабанил буквочку за буквочкой, пока не получал управляющие коды CR и LF. Тогда каретка со скрежетом сдвигалась вправо, барабан, дёрнувшись, слегка смещал бумагу вперед, и печаталась следующая строка.

С годами формат текстовых файлов не изменился, и будет жить, пока существуют компьютеры. Секрет его живучести – в простоте и универсальности. В некоторых операционных системах текстовые файлы разбивают на строки не парой символов CR+LF, а лишь одним из них. Это по сути ничего не меняет, – файл по-прежнему являет последовательность строк-макаронин, нарубленных управляющими символами.


Доступ к текстовым файлам

В Паскале можно работать с файлами любых типов – и текстовыми, и бинарными. Сейчас нас интересуют только текстовые, о прочих пока умолчим.

Насколько сложно работать с текстовыми файлами? Расслабьтесь, – это совсем не больно! Вы уже работаете с ними, даже не подозревая об этом. Чтение и запись строк в текстовые файлы выполняется все теми же процедурами Readln и Writeln. Но с одним маленьким отличием: в первом параметре этих процедур дается ссылка на файловую переменную типа TEXT, которая должна быть объявлена в программе следующим образом:


      var F: Text;


Тогда чтение и запись через текстовую переменную F выполняется так:


      Readln (F, S); { Чтение одной строки файла в переменную S }

      Writeln (F, ’Эта строка запишется в файл’);


Где тут сложности? Но пока неясно вот что:

• С каким именно файлом мы работаем? Ведь на диске их так много!

• В каком месте файла будет прочитана строка, и куда она будет помещена при записи?

Чтобы прояснить это, рассмотрим процесс чтения книги. Обычно я поступаю так:

1. Выбираю книгу на полке.

2. Открываю её в начале.

3. Читаю, пока не прочту или не усну.

4. В конце концов закрываю книгу и возвращаю на полку.

Точно так же – в четыре счета – обрабатывается файл. Далее в этой главе мы займемся чтением из файла, а запись в него рассмотрим в следующей главе.


Чтение из файла

Пусть нами объявлена файловая переменная F типа TEXT. Прежде чем воспользоваться ею для чтения некоторого файла, надо связать имя этого файла с файловой переменной. Это похоже на выбор книги для чтения – первый шаг в нашем списке. Связывание выполняют процедурой Assign – «назначить», в неё передают два параметра: файловую переменную и имя файла, например:


      Assign(F, ’C:\AUTOEXEC.BAT’);


Имя файла можно задать константой, переменной или их комбинацией – строковым выражением. Оно должно отвечать правилам, действующим в операционной системе. Указанный файл должен существовать, и система должна знать, где его найти. Впрочем, процедура Assign ничего не проверяет, она лишь помещает имя файла внутрь файловой переменной. И, если файла с указанным именем нет, процедура «не заметит» этого, но ошибка обнаружится на следующем шаге – при попытке открыть файл.

Второй шаг подготовки к чтению – открытие файла. Это вроде открытия книги на первой странице, оно выполняется процедурой Reset (что значит сброс или установка в исходное состояние). Этой процедуре нужен лишь один параметр – файловая переменная.


      Reset(F);


Процедура Reset готовит файл к чтению, обращаясь при этом к операционной системе. Система выделяет память для работы с файлом, а также блокирует его, не давая другим программам удалить файл. После успешного открытия файловую переменную можно использовать далее в процедуре Readln так, как это было сказано выше. А если имя файла оказалось неверным или файл не существует? Тогда вызов процедуры Reset приведет к ошибке: программа сообщит: «File not found» – файл не найден, и аварийно прекратит работу.

После успешного открытия файла переходят к третьему этапу – собственно чтению из него (чтению книги). С этим вы уже знакомы, поскольку чтение выполняется известной процедурой Readln. Например, прочитать строку из файла можно так:


      Readln(F, S);


Здесь S – это переменная строкового типа. Обратите внимание: в переменную S попадут только видимые символы строки, а управляющие коды – разделители строк – останутся «за бортом».

Но которая из строк файла будет прочитана? Первая, вторая или иная? При первом вызове после Reset процедура Readln прочтет первую строку файла, при втором – вторую и так далее. Если организовать цикл, то чтение продолжится вплоть до последней строки.

Применительно к чтению файлов говорят о позиции чтения, хотя увидеть эту позицию нельзя. Вызов процедуры Reset устанавливает эту воображаемую позицию в начало первой строки файла. Последующие вызовы процедуры Readln сдвигают её к началу очередной строки.

А что случится после чтения последней строки? Позиция достигнет конца файла, и очередной вызов процедуры Readln вызовет ошибку – событие крайне нежелательное. Чтобы избежать его, надо отслеживать достижение конца файла. Паскаль даёт для этого функцию по имени EOF, что означает End Of File – «конец файла». Булева функция EOF принимает один параметр – файловую переменную, и возвращает TRUE, когда позиция чтения «упирается» в конец файла.


      if Eof(F)

      then { достигнут конец файла }

      else { можно продолжать чтение }


Как видите, функцией EOF нельзя определить позицию чтения (то есть, номер читаемой строки); она сообщает лишь о том, достигнут конец файла или нет.

Что делать с прочитанной книгой? – закрыть и вернуть на полку. Так же поступают и с файлом – закрывают его. Эта операция выполняется процедурой Close – «закрыть».


      Close(F);


Закрытие файла освобождает память, выделенную для него операционной системой, и снимает блокировку, давая возможность другим программам делать с файлом все что угодно. Закрытие освобождает и саму файловую переменную, – теперь ею можно воспользоваться для доступа к другому файлу.

На рис. 55 показаны этапы чтения данных из файла.






Рис.55 – Четыре этапа чтения из файла

Последовательный доступ к файлу

Как видите, читать текстовый файл можно только последовательно, строку за строкой – от начала к концу файла, – нельзя читать строки в ином порядке. Поэтому текстовые файлы относят к файлам с последовательным доступом. В отличие от них, бинарные файлы (например, файлы баз данных) допускают произвольный доступ.

Впрочем, механизм последовательного доступа не запрещает программисту в любой момент вернуться к началу файла и повторить чтение – достаточно вызвать процедуру Reset.


Самореклама

Теперь испытаем то, что узнали о чтении текстовых файлов. Напишем небольшую программу, выводящую на экран свой собственный исходный текст, вот её первый вариант.


{ P_25_1 – распечатка текста программы }

var F: text;       { файловая переменная }

      S: string;       { строка }

begin

      Assign(F, 'P_25_1.pas');       { назначаем собственное имя }

      Reset(F);       { открываем файл для чтения }

      repeat

      if Eof(F) then Break ;       { прекратить, если конец файла }

      Readln(F, S);       { прочитать строку из файла }

      Writeln(S);       { вывести строку на экран }

      until false;

      Close(F);       { закрываем файл }

      Readln;       { ждать Enter }

end.


Выделенный курсивом оператор проверяет достижение конца файла, и делает это перед чтением строки. Если же проверять в конце цикла


      ...

until Eof(F);


это неизбежно приведет к ошибке после чтения последней строки файла.


Цикл с проверкой в начале

Достижение конца файла надо проверять своевременно! Для этого в Паскале есть подходящий оператор цикла, – пора познакомиться с ним. До сих пор мы обходились двумя циклическими операторами, а именно:

• циклом с проверкой условия в конце REPEAT-UNTIL;

• циклом со счетчиком FOR-TO-DO.

Новый для нас оператор цикла строится из двух ключевых слов, вот его формат:

WHILE <условие> DO <оператор>

По-русски это читается так: "ПОКА условие истинно, ВЫПОЛНЯТЬ оператор такой-то". После ключевого слова DO допускается лишь один оператор, но на практике требуется больше. Потому здесь часто вставляют операторный блок BEGIN-END, в итоге получается такая конструкция.


WHILE <условие> DO BEGIN

      <последовательность операторов>

END


Обратите внимание, что условия продолжения циклов в операторах WHILE-DO и REPEAT-UNTIL взаимно противоположны! Первый из них выполняется, пока условие истинно, а второй – пока оно ложно.

С новым оператором «самораспечатка» станет такой.


{ P_25_2 – распечатка текста программы }

var F: text;       { файловая переменная }

      S: string;       { строковая переменная }

begin

      Assign(F, 'P_25_2.pas');       { назначаем собственное имя }

      Reset(F);       { открываем файл для чтения }

      while not Eof(F)  do begin       { пока не конец файла }

      Readln(F, S);       { прочитать строку из файла }

      Writeln(S);       { вывести строку на экран }

      end ;

      Close(F);       { закрываем файл }

      Readln;       { ждем нажатия Enter }

end.


В условии цикла WHILE видим отрицание NOT, значит, цикл будет выполняться, пока НЕ обнаружен конец файла. Проверьте работу этой программы. В следующей главе мы рассмотрим запись данных в текстовый файл и завершим наш шифровальный проект. А сейчас, как обычно, подведем итоги.


Итоги

• Текстовые файлы содержат строки видимых символов, отделенные друг от друга невидимыми на экране управляющими кодами CR (возврат каретки) и LF (перевод строки).

• К текстовым файлам обращаются через файловые переменные типа TEXT.

• Перед чтением файла нужны два шага: 1) связывание файловой переменной с именем файла процедурой Assign, и 2) открытие файла для чтения процедурой Reset.

• Для чтения отдельных строк вызывают процедуру Readln, при этом первым параметром процедуры указывают файловую переменную.

• После открытия файла его чтение начинается с первой строки; каждый вызов процедуры Readln смещает позицию чтения в начало следующей строки.

• Чтение файла возможно, пока не будет прочитана последняя строка. Попытка чтения за концом файла вызовет аварию программы.

• Чтобы узнать о достижении конца файла, вызывают функцию Eof, которая возвращает TRUE, если достигнут конец файла.

• Признак окончания файла исследуют в начале цикла, и для этого лучше подходит оператор цикла WHILE-DO.

• По окончании работы с файлом его закрывают процедурой Close.


А слабо?

А) Можно ли связать текстовую переменную F с файлом оператором присваивания?


      F := ’c:\autoexec.bat’;


Б) Напишите программу для вывода на экран файла, имя которого задается с клавиатуры.

В) Напишите три функции для подсчета:

• строк в файле;

• видимых символов в файле;

• всех символов файла (фактический объём файла).

Функции принимают один параметр – ссылку на файловую переменную. Напишите программу, определяющую упомянутые характеристики файла.

Г) Объявите две файловые переменные, свяжите их с одним и тем же файлом, а затем откройте через обе переменные. Вызовет ли это ошибку? Объясните результат, исходя из здравого смысла.

Д) Усовершенствуйте программу «вопрос-ответ» (глава 16) с тем, чтобы ответы хранились не в программе, а в отдельном текстовом файле. Тогда пользователи программы сами смогут сочинять ответы.

Е) Напишите процедуру для вывода на экран N–й строки файла, где N – параметр процедуры. Воспользовавшись этой процедурой, напишите программу для распечатки строк файла в обратном порядке. Подсказка: предварительно посчитайте количество строк в файле.

Глава 26

Я не читатель, – я писатель!

 Сделать закладку на этом месте книги




Наш шпионский проект по шифрованию файла подвигается к финишу. Ступим завершающий шаг: освоим запись в текстовый файл.


Запись в текстовый файл

Порядок записи в текстовый файл схож с его чтением, судите сами:

• для доступа к файлу используют файловую переменную типа TEXT;

• файловую переменную надо связать с файлом процедурой Assign;

• по окончании записи файл закрывают процедурой Close.

Вот схема, где отражены четыре этапа записи в файл (рис. 56).






Рис.56 – Четыре этапа записи в файл

Как видите, запись в файл отличается от чтения вторым и третьим этапами, ими и займемся.

Итак, после привязки файла процедурой Assign, файл открывают для записи процедурой Rewrite – «перезапись».


      Rewrite(F);


Тут находим первое отличие: если для чтения требуемый файл должен существовать, то для записи этого не нужно. Если файла ещё нет, будет создан новый пустой файл. А при наличии файла он будет очищен, и вся информация в нём сотрется, как мел с доски. Будьте внимательны, иначе лишитесь нужной информации!

В открытый таким образом файл можно «печатать» нужные нам строки. Как? Вы уже знаете – процедурой Writeln. А что указать первым параметром? Правильно, – файловую переменную, вот так:


      Writeln(F, S); { F – переменная типа TEXT, S – строковая }


Каждый вызов такой процедуры добавляет в конец файла очередную строку с разделителями. В отличие от чтения, где надо следить за достижением конца файла, при записи вы ограничены лишь объёмом винчестера и здравым смыслом (в большей степени последним).

По окончании записи файл закрывают все той же процедурой Close. Как и при чтении, закрытие файла освобождает выделенную для него память и снимает блокировку файла, позволяя другим программам работать с ним. К тому же закрытие файла гарантирует сохранение записанных данных на диске.


Пример записи в файл

Рассмотрим небольшой пример: заполнение файла числами от 1 до 10.


{ P_26_1 }

var F: text;       { файловая переменная }

      k: integer;

begin

      Assign(F, 'P_26_1.txt'); { назначаем имя файла }

      Rewrite(F);       { открываем файл для записи }

      for k:=1 to 10 do       { записать 10 строк с числами }

      Writeln(F, k);

      Close(F);       { закрываем файл }

end.


Есть вопросы? Запустите программу и проверьте, работает ли она. Запустили? Теперь отыщите в папке с программой файл «P_26_1.TXT» и откройте его любым редактором. Уверен, что вы обнаружите в нём столбик из десяти чисел.


Завершение шпионского проекта

Подойдя к финалу нашего проекта, мы научились: 1) шифровать отдельную строку, 2) читать строки из файла и 3) записывать строки в файл. Пора соединить все это: читая строки исходного файла, будем шифровать их, и записывать в другой файл, – так будет работать наша программа.

Прежде всего договоримся об именах файлов. Назначив зашифрованному файлу постоянное имя, например «CRYPT.TXT», мы избавим себя от ввода его имени с клавиатуры. Вводить мы будем либо имя исходного файла – при шифровании, либо имя конечного файла – при расшифровке. Обозначим эти неизвестные нам имена файлов как X1 и X2, и тогда схема обработки файлов будет такой.






Рис. 57 – Схема именования файлов при шифровании и расшифровке

С учетом этих договоренностей составим блок-схему программы (рис. 58).






Рис.58 – Блок-схема программы шифрования/расшифровки

Основную работу поручим процедуре шифрования-расшифровки, блок-схема которой показана на рис. 59. В неё передаём два параметра: имя обрабатываемого файла и код операции (зашифровать или расшифровать).






Рис.59 – Блок-схема процедуры шифрования-расшифровки

Теперь мы готовы смастерить шпионскую программу. Может быть, сами справитесь? По крайней мере, попытайтесь. Функции и процедуры шифрования символов и строк возьмите из программы «P_24_1». Написав свой вариант, сравните с представленным ниже.


{ P_26_2 – шифрование и расшифровка файлов }


const CKey = 2; { Ключ Цезаря }


      { Шифрование одного символа }

function Encrypt(arg: char): char;

var x: integer;

begin

Encrypt:=arg;

if Ord(arg)>=32 then begin { управляющие символы не трогаем! }

x:= Ord(arg)+ CKey;

if x>255 then x:= x-256+32;

Encrypt:= Char(x);

end;

end;

      { Расшифровка одного символа }

function Decrypt(arg: char): char;

var x: integer;

begin

Decrypt:=arg;

if Ord(arg)>=32 then begin { управляющие символы не трогаем! }

x:= Ord(arg)- CKey;

if x<32 then x:= x+256-32;

Decrypt:= Char(x);

end;

end;

      { Шифрование строки }


procedure EncryptStr(var arg: string);

var k: integer;

begin

      for k:=1 to Length(arg) do arg[k]:= Encrypt(arg[k]);

end;

      { Расшифровка строки }


procedure DecryptStr(var arg: string);

var k: integer;

begin

      for k:=1 to Length(arg) do arg[k]:= Decrypt(arg[k]);

end;

      {----- Процедура шифрования-расшифровка файла -----}

procedure CryptFile(const aFile: string; aOper: boolean);

const CFixName='Crypt.txt'; { фиксированное имя файла }

var FileIn: text; { входной файл для чтения }

      FileOut: text; { выходной файл для записи }

      S: string;

begin

      if aOper then begin       { если шифровать }

      Assign(FileIn, aFile);

      Assign(FileOut, CFixName);

      end else begin       { если расшифровать }

      Assign(FileIn, CFixName);

      Assign(FileOut, aFile);

      end;

      Reset(FileIn);    { открыть входной файл для чтения }

      Rewrite(FileOut); { открыть выходной файл для записи }

      while not Eof(FileIn) do begin

      { пока не закончился входной файл }

      Readln(FileIn, S);       { читать очередную строку из файла }

      if aOper

      then EncryptStr(S) { зашифровать }

      else DecryptStr(S); { расшифровать }

      Writeln(FileOut, S);       { записать в выходной файл }

      end;

      { закрыть оба файла }

      Close(FileIn); Close(FileOut);

end;

      {----- Главная программа -----}

var S: string;

      Oper: boolean; { TRUE – шифровать, FALSE – расшифровать}

begin

      Write('Укажите операцию (1 – шифровать, иначе – расшифровать):');

      Readln(S);

      Oper:= S='1'; { Oper=TRUE если S='1' }

      if Oper

      then Write('Введите имя шифруемого файла: ')

      else Write('Введите имя расшифрованного файла: ');

      Readln(S);

      CryptFile(S, Oper); { Вызов процедуры шифрования–расшифровки }

      Write('OK, нажмите Enter'); Readln;

end.


Пространные пояснения излишни. Признак выполняемой операции формируется в булевой переменной Oper в третьей строке главной программы по цифре, введенной в переменную S. Значение Oper=TRUE влечет зашифровку файла, а FALSE — расшифровку. Затем в переменную S вводится имя обрабатываемого файла. В конце концов, вызывается процедура CryptFile с передачей в неё двух параметров: имени файла и признака выполняемой операции (aFile и aOper). Приставка «a» в начале имен этих параметров (префикс) помогает при чтении программы отличить параметр от других переменных.

Полюбуйтесь, во что превратила эта программа один из файлов на Паскале (приведен небольшой фрагмент).


}"Rtqi2420rcu"

xct"Ocp"<"uvtkpi=

}///"░гьёднзпкз"▒т░шзжхтэ"///

rtqegfwtg"Rcwug=

dgikp

"""""Ytkvgnp*)Пвиокфз"Gpvgt<)+=""Tgcfnp=


Как говорится, родная мама не узнает! Все, что попадает в «мясорубку» нашего шифровальщика, обращается в фарш. Однако последующая расшифровка «перемолотого» файла в точности восстановила его.

Примененный нами метод шифрования не так уж крут, опытный взломщик легко раскроет его. Но фундамент заложен, и когда-нибудь вы придумаете изощренные методы шифрования. Например, ключ шифра можно сделать переменным и зависящим от номера символа в строке или файле. Подумайте над этим. Если же вы намерены заняться криптографией всерьез, изучайте математику! Для программиста это наука номер один.


Итоги

• Для записи в текстовый файл, как и для чтения, требуется файловая переменная типа TEXT.

• Перед записью выполняют два действия: связывание переменной с файлом процедурой Assign и открытие файла для записи процедурой Rewrite.

• Вызов процедуры Rewrite либо создаёт новый файл, либо очищает существующий (вся бывшая в нём информация теряется!).

• Запись отдельных строк в файл выполняют процедурой Writeln, первым параметром здесь указывают файловую переменную.

• По окончании записи файл закрывают процедурой Close, – это гарантирует сохранение данных на диске.


А слабо?

А) Программа создает файл, печатает в него несколько строк с числами, а затем выводит этот файл на экран. Воспользуйтесь одной файловой переменной.

Б) Программа для нумерации строк файла. Строки исходного файла должны копироваться в конечный файл с добавлением перед каждой строкой её номера, например:

Исходный файл:


В лесу родилась елочка,

В лесу она росла.

Зимой и летом стройная,

Зеленая была.


Конечный файл:


1

В лесу родилась елочка,

2

В лесу она росла.

3

Зимой и летом стройная,

4

Зеленая была.


В) Скопировать один файл в другой:

• с перестановкой местами четных и нечетных строк;

• с перестановкой строк в обратном порядке (см. условие задачи «Е» к 25-й главе).

Г) Для передачи по интернету секретного текстового файла разбейте его на два других: в первый запишите нечетные строки исходного файла, а во второй – четные. Напишите для этого программу, или слабо?

Д) Создайте программу для объединения двух файлов (см. условие предыдущей задачи). Из первого составьте нечетные строки конечного файла, а из второго – четные.

Глава 27

Дайте кораблю минутный отдых!

 Сделать закладку на этом месте книги




Ой, что мы с вами натворили! Могучая программа шифрования файлов дает нам право если не на медаль, то хотя бы на передышку. Пощадим наши серые клеточки и отправимся на экскурсию по своему кораблю – среде программирования Free Pascal. Ведь мы обошли ещё не все палубы этого лайнера. Сейчас рассмотрим настройку компилятора, а в следующей главе обсудим возможности текстового редактора и справочно


убрать рекламу






й системы.


Ошибка ошибке рознь

Где найти безгрешных программистов? Нет таковых! Лихорадочно барабаня по клавишам в попытке изваять очередной проект, мы то и дело ошибаемся. Часть этих ошибок отлавливает компилятор, – он видит синтаксические ошибки – нарушения правил языка. Вы споткнулись на ключевом слове или забыли объявить переменную? – нажмите клавишу F9, и компилятор «ткнет носом» в место ошибки. И пока не исправите свои огрехи, не надейтесь получить исполняемый файл. Зато и работают такие программы, «непосильным трудом нажитые», весьма надежно. Восхищенный новичок однажды породил афоризм: «компилируется – значит работает». Увы! если бы так! Некоторые ошибки проявляются лишь во время работы программы, – это ошибки времени исполнения – Runtime errors.


Фатальные ошибки

Да, компилятор Паскаля способен уберечь от многих ошибок, но посмотрите на следующий пример.


var X : integer;

begin

      Readln(X);

      Writeln(100 div X);

end.


Программа печатает результат деления числа 100 на переменную X. Здесь нет синтаксических ошибок. И все работает прекрасно, пока пользователь не введет число ноль. Тогда вместо результата деления вы получите неприятное сообщение «Runtime error 200», и программа прервется. Иначе говоря, деление на ноль не позволено никому, даже компьютеру.

Выручит ли здесь компилятор? Ведь это логическая ошибка, то есть ошибка в алгоритме. Нет, тут поможет лишь исправление программы, например, так:


var X : integer;

begin

      Readln(X);

      if X<>0

      then Writeln(100 div X)

      else Writeln(’Не делите на ноль, умоляю Вас!’);

end.


Деление на ноль – это фатальная, то есть неисправимая ошибка, она приводит к аварийной остановке программы. Но случаются и ошибки иного рода.


«Простительные» ошибки

Вот пример по части обработки файлов, – на этой «кухне» мы уже побывали. Попытка открыть для чтения несуществующий файл влечет ошибку вода/вывода (по-английски – «I/O Error»), – это тоже ошибка времени исполнения. Кто виноват? Разумеется, пользователь, – данные надо вводить внимательней. Но программе от этого не легче, – она обязана как-то реагировать. Как? Проще всего аварийно завершиться. Но можно поступить мягче – разобраться в ситуации и подсказать пользователю, где он неправ.

И здесь компилятор поддержит вас, позволив настроить реакцию программы на некоторые ошибки времени исполнения. По сути, способов реагировать только два: прервать программу при появлении ошибки, либо нет. Вариант реакции настраивают через опции компилятора. Рассмотрим выгоды такой настройки на примере ошибок ввода/вывода.


Опции компилятора

Обратимся к настройкам компилятора. Щелкните по пункту меню Options –> Compiler… (рис. 60), и перед вами появится окно для настройки опций (рис. 61).






Рис.60 – Выбор пункта меню для настройки опций компилятора





Рис.61 – Окно настроек опций компилятора

Вкладка «Generation code» содержит нужную нам группу флажков «Code generation». Флажок «I/O checking» заведует реакцией программы на ошибки ввода-вывода («I/O» – это сокращение от Input/Output – «ввод/вывод»). При установленном флажке компилятор будет создавать исполняемые EXE–файлы так, что ошибки ввода-вывода аварийно завершат программу. А если сбросить флажок и снова откомпилировать ту же программу, она поведет себя иначе, – программа не погибнет, однако и работать, как следует, не будет. В чем же смысл настройки?


Обработка ошибок ввода-вывода

Смысл в том, чтобы самому следить за вероятными ошибками. Для слежки используют функцию IOResult, которая не имеет параметров и возвращает ноль, если ошибок ввода-вывода не произошло. А если эта неприятность все же случилась, функция вернет ненулевой код ошибки, по которому легко выяснить её причину. Обратите внимание: функция возвращает состояние последней выполнявшейся операции ввода-вывода. При ошибке дальнейшая работа с файлом автоматически блокируется до его повторного открытия.

Рассмотрим способ безаварийного определения наличия файла на диске (здесь имя файла содержится в переменной FileName).


Assign(F, FileName); Reset(F);

if IOResult=0

      then Writeln (’Нашелся файл ’+ FileName)

      else Writeln (’Файл ’+FileName+’ не обнаружен!’);


Этот фрагмент надёжно сработает только при отключенном флажке «I/O checking», иначе программа может прерваться аварийно. Стало быть, перед компиляцией надо проверять состояние флажка, а это хлопотно и ненадежно.

В настройках опций компилятора через меню есть и другой изъян. Как быть, когда в разных местах программы требуется по-разному реагировать на ошибки: где-то включить этот контроль, а где-то нет? Но флажок действует на всю программу в целом, глобально, – он не допускает выборочной настройки. Что делать?


Директивы компилятора

Выручают директивы, – особые сочетания символов, избирательно настраивающие компилятор. Директивы не являются элементами языка, поэтому вставляются в программу по-хитрому – внутри комментариев. Ведь комментарии, как известно, компилятор должен игнорировать, пропускать мимо ушей. Но компилятор просматривает и комментарии, «процеживая» их в поисках директив (подобно тому, как мы «процеживали» строки в поиске заменяемых символов).

Большинство директив выглядит как сочетание символа доллара «$» с латинской буквой и последующего знака «+» или «–». Все это заключается внутрь комментария. Знак «+» включает действие директивы, а «–» – отключает, что равносильно установке или сбросу флажков на вкладке опций компилятора. Например, директива, управляющая реакцией на ошибки ввода-вывода, записывается так:


{ $I+       - включить контроль ввода-вывода }

{ $I-       - отключить контроль ввода-вывода }


В один комментарий можно вместить несколько директив. Перечень директив вы найдете в справке по компилятору и в приложении Ж.


Директиву – в студию!

Сейчас мы извлечем первую пользу из директив: сотворим функцию, определяющую наличие файла на диске. Применим для этого директиву $I. Наша булева функция будет возвращать TRUE, если файл, имя которого передано в параметре, существует. Вот её текст, а заодно и фрагмент тестирующей программы.


{ P_27_1 – определение наличия заданного файла }


function FileExists(const aName: string): boolean;

var F: text;

begin

      FileExists:= false; { предполагаем, что файла нет }

      Assign(F, aName);

      {$I-} Reset(F); {$I+}  { контроль отключен на время Reset }

      if IOResult=0 then begin { если файл существует }

      Close(F);       { закрываем файл }

      FileExists:= true;

      end;

end;


begin       {--- главная программа ---}

      Writeln( FileExists('AUTO.BAT') ); { печатает false }

      Writeln( FileExists('C:\AUTOEXEC.BAT') ); { печатает true }

end.


В выделеной строке процедура открытия файла Reset заключена между парой директив. Первая из них отключает контроль ошибок ввода-вывода, а вторая снова включает его. Это значит, что при выполнении процедуры Reset программа не прервется даже при отсутствии открываемого файла. Причем это уже не будет зависеть от состояния флажка в опциях компилятора, поскольку директивы имеют преимущество перед флажками, то есть более высокий приоритет.

Как сработает наша функция? После попытки открыть файл вызовем функцию IOResult. Если она вернула ноль, значит, файл существует, и его надо закрыть, поскольку никаких действий с ним внутри функции FileExists не намечается. Проверьте работу этой полезной функции, она ещё пригодится вам!


Парад директив

Разбогатев со временем собственными программами, вам, вероятно, захочется поделиться ими. При передаче исходных текстов важно передать и настройки опций компилятора, иначе EXE–файл может быть построен неправильно. Эти настройки лучше передать путём вставки директив компилятора прямо в программу. Но директив много, – запомнить их трудно, а ошибиться легко. Впрочем, есть один волшебный способ…

Откройте опции компилятора (рис. 61) и настройте в нём флажки так, как нужно, не забыв сохранить их кнопкой ОК. Затем откройте файл с программой и нажмите волшебную комбинацию клавиш Ctrl+O+O. То есть, удерживая клавишу CTRL, дважды нажмите латинскую букву «O». И – о, чудо! – в начале программы появятся строчки с настройками всех директив, например, такие.


{$IFDEF NORMAL}

{$H-,I+,OBJECTCHECKS-,Q-,R-,S-}

{$ENDIF NORMAL}

{$IFDEF DEBUG}

{$H-,I+,OBJECTCHECKS-,Q+,R+,S-}

{$ENDIF DEBUG}

{$IFDEF RELEASE}

{$H-,I-,OBJECTCHECKS-,Q-,R-,S-}

{$ENDIF RELEASE}


Здесь представлены настройки директив для трех вариантов компиляции. Эти варианты (Normal/Debug/Release) выбираются в пункте меню Options –> Mode…. Знаки «+» и «–» соответствуют состоянию флажков в окне опций. Директивы вида $IFDEF нужны для выбора одного из вариантов компиляции (об условных директивах я расскажу в главе 60). Можно упростить эту конструкцию, оставив, лишь одну строку.


{$H–, I+, OBJECTCHECKS–, Q–, R–, S–}


Потребовалось изменить настройки? Пожалуйста! – Удалите эти строчки и повторите «волшебные заклинания». Или расставьте плюсы и минусы вручную.


Итоги

• Программист допускает два рода ошибок: синтаксические и семантические (смысловые).

• Синтаксические ошибки обнаруживает компилятор. Пока вы не исправите все такие ошибки, исполняемый файл не сформируется.

• Смысловые ошибки проявляются в ходе выполнения программы, – это ошибки времени исполнения. Такие ошибки кроются либо в алгоритме программы, либо в неправильных действиях пользователя.

• Реакция программы на некоторые ошибки определяется настройкой опций компилятора. Программа может либо пренебречь ошибкой, либо аварийно завершиться.

• Опции компилятора настраивают двумя способами: в диалоговом окне и вставкой директив непосредственно в программу.

• Директивы в тексте программы имеют преимущество (приоритет) перед настройками опций в диалоговом окне.


А слабо?

А) Выясните код ошибки, возвращаемый функцией IOResult при попытке открыть для чтения несуществующий файл. Напишите для этого небольшую программу.

Б) Сделайте то же самое, когда программа пытается открыть для записи файл с установленным атрибутом «только чтение». Для настройки атрибутов файла щелкните по файлу правой кнопкой мыши и выберите пункт «Свойства».

В) Дан файл, строки которого содержат круглые скобки (это может быть программа или математические выкладки – неважно). Ваша программа должна распечатать строки, где скобки расставлены неверно, вот примеры.


2+3       – правильно, хотя скобок нет;

(2+3       – ошибка – здесь нет закрывающей скобки;

()2+3() – это правильно (хоть и лишено смысла);

))2+3(( – ошибка – скобки закрываются до открытия.


Рекомендация: для исследования строки напишите булеву функцию Check, возвращающую TRUE, если скобки расставлены без ошибок.

Г) Дребезг контактов давно уже бесит специалистов по электронике. Дребезг возникает кратковременно при замыкании-размыкании кнопок, тумблеров, реле и других подобных устройств. Сигнал от контактов поступает в микропроцессор с периодичностью, скажем, 100 раз в секунду. Если контакт постоянно разомкнут, микропроцессор принимает «0», а если замкнут – «1». При замыкании-размыкании контакт неустойчив, и процессор получает пачки чередующихся нулей и единиц, – надо отфильтровать эти ложные срабатывания.

Ваша программа будет моделировать поведение микропроцессора. Входной файл содержит последовательность нулей и единиц (по одному символу в строке). Первый символ примите как исходное значение сигнала, а дальше сигнал на выходе программы формируется так: если три подряд идущие значения совпадают, то берется это новое значение, а иначе сохраняется текущее, например:

На входе На выходе
0 1 0 1 1 1 0 0 0 0 0 0 1 1

В выходной файл запишите в две колонки входной и выходной сигналы.

Глава 28

Редактор и справочная система

 Сделать закладку на этом месте книги




Ошибки, ошибки… Мы отбиваемся от них всеми средствами, и компилятор, как вы убедились, – важный рубеж в этой обороне. Важный, но не единственный. Согласитесь, лучше не допускать ошибок, чем устранять их. Хорошо, когда рядом есть мудрый советчик, – вовремя подскажет, объяснит, остережет. К счастью, в IDE есть такие «советчики» – это редактор текста и справочная система, – о них спою в этой главе.

Сегодня никого не удивишь возможностями нынешних IDE: тут и встроенный редактор и справочная система. Но так было не всегда. В начале 90-х годов прошлого века появление замечательных продуктов фирмы Borland было сродни чуду. Подумать только! Куча окон, «умная» раскраска текста, встроенная справочная система и отладчик, – это ли не чудеса?


Небьющиеся окна

Встроенный многооконный редактор – одно из новшеств Borland Pascal, он появился там едва ли не раньше самой MS Windows. Пока мы обходились одним окном редактора, но так будет не всегда, – в сложных проектах приходится одновременно открывать несколько файлов. Впрочем, это нужно уметь и сейчас, например, для копирования частей одной программы в другую.

Окна встроенного редактора схожи с окнами Windows: они открываются и закрываются, меняют размер и положение, допускают перенос кусков текста из одного окна в другое. Для управления окнами IDE служит раздел меню «Window». На рис. 62 рядом с названиями пунктов этого раздела показаны соответствующие им горячие комбинации клавиш.

Рассмотрим самые полезные возможности этого меню.

Команды Next и Previous переключают окна редактора. То же самое делается нажатием клавиш F6 и Sift+F6 или щелчками мыши по окнам. Текущее активное окно выдвигается на передний план и обрамляется особой рамкой с полосами прокрутки (в пассивных окнах этих полос нет).






Рис.62 – Пункт меню «Window»

Касательно активного окна надо сделать важное замечание, связанное с компиляцией. Когда открыто несколько окон, нажатие клавиши F9 вызовет, вероятней всего, компиляцию файла, открытого в активном окне. Поэтому не забывайте перед компиляцией своей программы переключаться в нужное окно!

В скопище окон не мудрено заблудиться, и тогда выручит команда Window –> List (комбинация Alt+0, где «0» – это цифра). Нажав её, вы увидите список всех открытых в данный момент окон (рис. 63).






Рис.63 – Список окон

Для перехода в нужное окно выделите его в списке и щелкните по кнопке OK (или сделайте двойной щелчок по строке с именем окна).

Изменить размер и положение окна можно командами Size/Move и мышью. Для перетаскивания окна «схватите» его мышью за верхнюю границу рамки, а для изменения размера – за правый нижний угол.


Буфер обмена

Кто сказал, что списывать – плохо? Копирование кусков текста – любимое занятие программистов. В самом деле, разумно ли набивать заново такой же или похожий кусок текста? Куда быстрее и надежней «скопипастить» его (от слов Copy – «копировать» и Paste – «вставить»). И время сбережем, и ошибиться трудней, – а ошибки мы душим всеми средствами, не так ли?

Куски текста копируются и в пределах одного файла, и между разными файлами. При этом копируемый фрагмент временно сохраняется в памяти – так называемом буфере обмена. Фокус с копированием выполняем в четыре счета:

• выделяем кусок текста (об этом чуть позже);

• копируем выделение в буфер обмена (Ctrl+Insert);

• помещаем курсор в то место, куда требуется вставить текст (в этом же или другом окне);

• вставляем текст из буфера обмена (Shift+Insert).

Теперь о выделении текста. Оно может выполняться и клавиатурой, и мышью. Поместите курсор в начале или в конце нужного куска текста. Затем одной рукой удерживайте клавишу Shift, а другой в это время двигайте текстовый курсор (клавишами со стрелками или любым способом, изменяющим положение курсора). Другой прием – «мышиный»: протащите мышь по нужному тексту, удерживая нажатой её левую кнопку.

Когда выделение станет ненужным, снимите его, щелкнув мышью в любом месте текста, либо нажав комбинацию Ctrl+K+H.

«Постойте, да ведь в редакторах Windows это делается точно так же» – скажет бывалый читатель. Да, но с одной поправкой: редакторы IDE и Windows используют разные буферы обмена, – у каждого свой. Текст, помещенный в буфер обмена Windows, не вставляется в окно IDE и наоборот. Кстати, содержимое буфера обмена IDE можно открыть через пункт меню Edit –> Show Clipboard.

Примечание. В среде Free Pascal под Windows имеются пункты меню Copy to Windows и Paste from Windows, они служат для обмена кусками текста со средой Windows.


Справочная система

Как ни полезны «примочки» редактора текста, они не способны ответить на вопросы забывчивого программиста. Например, о правильном написании ключевого слова или о параметрах некоторой процедуры. С такими вопросами обращаются к руководству по языку, – и шурши страницами! Впрочем, в каком веке мы живем? Все это есть в компьютере, надо лишь поискать. Справка открывается через пункт меню «Help» или клавишей F1 – нажал, и вот тебе счастье! Но если вас интересует что-то конкретное, лучше поступить иначе, – я расскажу о двух таких приемах.

Первый удобен, когда интересующее вас слово уже содержится в тексте. Установите курсор в пределах этого слова (под любой его буквой), например, под словом IOResult, и нажмите комбинацию Ctrl+F1. Если справочная система найдет «досье» на это слово, то покажет его в окне «Help» (рис. 64).






Рис.64 – Вызов окна справки для слова «IOResult»

А если слово не обнаружится? Тогда справочник покажет список всех своих статей – так называемый индекс – и выделит ближайшее похожее слово. С этого момента вы можете самостоятельно искать нужные слова в индексе. Для поиска просто набирайте слово буква за буквой. Для повторного поиска сдвиньте курсор в любом направлении и снова набирайте слово. Когда искомое слово подсветится, для просмотра статьи просто нажмите Enter. Это второй прием получения справки. На рис. 65 показан результат поиска в индексе слова «Close».

Все, что выделено в справке желтым цветом – это гиперссылки на статьи справочной системы. Щелкая по ним двойным щелчком (либо нажимая Enter), вы можете разгуливать по справочной системе, как по Интернету.

C окном справочной системы можно обращаться так же, как с окнами редактора: перемещать, изменять размеры. Вот где пригодится умение работать в многооконной среде! Хотите скопировать что-то из окна справки? Тогда выделите нужный фрагмент буксировкой мыши, а затем перенесите его в свою программу через буфер обмена (Ctrl+Insert, затем Shift+Insert).






Рис.65 – Поиск слова «Close» в индексе справочной системы

Напомню, что порядок установки справочной системы для IDE Free Pascal изложен в главе 4. Пользователи Borland Pascal могут найти в Интернете перевод этой справки на русский. Для установки русской справки поместите её файл в ту же папку, где находится исполняемый файл «BP.EXE», и дайте файлу справки стандартное имя «TURBO.TPH». Не забудьте предварительно сохранить или переименовать исходный «английский» файл, – а вдруг ещё пригодится?


Итоги

• Редактором текста можно открыть столько файлов, сколько вам нужно. Каждый файл открывается в отдельном окне; обращаться с окнами так же легко, как с окнами Windows.

• Для переноса кусков текста используйте буфер обмена.

• Буфер обмена IDE и буфер обмена Windows не связаны между собой. Для переноса текста в другие файлы Windows открывайте файлы своих программ в редакторах этой системы, например, в блокноте. Или воспользуйтесь пунктами меню Copy to Windows и Paste from Windows.

• Ищите ответы на свои вопросы в справочной системе IDE.

Глава 29

Читайте по-новому

 Сделать закладку на этом месте книги




Отдохнув на экскурсии, с новой силой набросимся на файлы, – ведь именно там хранятся наши данные. Научимся извлекать из файлов числа.


Полицейская база данных, версия 1

Одна из первых наших программ исполняла должность электронного часового, охранявшего секретный объект. Теперь поможем другой силовой структуре – дорожной полиции.

Долг автоинспектора – в числе прочего – поиск угнанных автомобилей. Работа нехитрая: заприметив подозрительный автомобиль, инспектор сверяет его номер со своей картотекой. И, если номер в картотеке найдется, принимает меры к задержанию автомобиля и поимке преступника. В отличие от часового, который помнит всего один пароль, полицейский роется в пухлой картотеке с тысячами номеров. В этом и состояла его главная трудность, пока не явились компьютерные базы данных.

Базы данных (сокращенно БД) – кто не слышал о них? На ум приходят базы данных Пентагона, ЦРУ и налоговой инспекции. Да, эти чудовищные БД впечатляют! Впрочем, чтобы увидеть базу данных, не спешите потрошить Пентагон. Вот расписание поездов, программа телепередач или классный журнал, – все это простые базы данных. В конце концов, любая БД – это организованное хранилище данных, приспособленное для удобного поиска информации. Нам тоже по силам создать несложную полицейскую базу данных.

Соорудим такую базу с номерами угнанных автомобилей, и воспользуемся для этого текстовым файлом. Допустим, что номера автомобилей – это числа; тогда база данных – это файл с напечатанными в столбик номерами: каждая строка файла содержит один номер. Номера могут следовать в любом порядке, например:


123

325

234

11


Такой файл можно напечатать любым редактором текста, в том числе и встроенным в IDE. Мы так и поступим: создайте новый файл, впечатайте в него десяток-другой пришедших на ум номеров и сохраните в рабочей папке под именем «Police.txt». Окно с этим файлом пока не закрывайте, оно ещё пригодится.

Все, база данных готова! Только не предлагайте полицейскому рыться в этом файле, – вместо благодарности вы услышите совсем другие слова. В довершение доброго дела напишем программу для поиска номера в этой базе. Такая программа должна работать как часовой, запрашивая у полицейского номер автомобиля и сообщая о том, содержится ли этот номер в БД. Признаком выхода из программы будет ввод нулевого номера.

Итак, приступим к программе «P_29_1». Схема главной программы ясна из вышесказанного. Выносить заключение об автомобиле будет функция булевого типа, принимающая два параметра: файловую переменную, связанную с нашей БД, и номер искомого автомобиля. Если номер в базе данных обнаружится, функция вернет значение TRUE. Ввиду простоты алгоритма не буду рисовать блок-схему. Если чуете в себе силу, напишите программу сами, и, после некоторых мучений, сравните с тем, что показано ниже.


{ P_29_1 – Полицейская база данных, версия 1 }


function FindNumber(var aFile: text ; aNumber: integer): boolean;

var N: integer; { текущий номер в БД }

begin

      FindNumber:= false ; { на случай, если файл пуст }

      Reset(aFile) ; { позицию чтения устанавливаем в начало файла }

      N:=0;       { в начале цикла задаем несуществующий номер }

      { читаем номера из файла, пока НЕ конец файла И номер НЕ найден }

      while not Eof(aFile) and (N<>aNumber)  do begin

      Readln(aFile, N);

      FindNumber:= (N=aNumber) ; { true, если номер нашелся }

      end;

end;

var F: text; Num: integer;

begin {----- Главная программа -----}

      Assign(F, 'Police.txt');

      repeat

      Write('Укажите номер автомобиля: '); Readln(Num);

      if FindNumber(F, Num)

      then Writeln('Эта машина в розыске, хватайте его!')

      else Writeln('Пропустите его');

      until Num=0; { 0 – признак завершения программы}

      Close(F);

end.


Поясню некоторые моменты. В начале главной программы файловая переменная F связывается с файлом «Police.txt». Далее следует хорошо знакомая конструкция REPEAT–UNTIL с проверкой условия в конце цикла.

Самое интересное скрыто внутри функции FindNumber (от Find – «искать», Number – «номер»). Туда передаются два параметра, один из которых – файловая переменная. Обратите внимание на способ её передачи: файловая переменная передается по ссылке (в заголовке указано слово VAR). И никак иначе такую переменную не передают! Со временем узнаете причину, а пока просто запомните: файловые переменные передают внутрь процедур и функций только по ссылке! Следовательно, параметр aFile ссылается на глобальную переменную F.

А к чему здесь приставки «a» перед именами параметров: aFile, aNumber? Или это тоже правило языка? Нет, друзья, это всего лишь уловка программистов, которую полезно перенять. Чем сложнее будут ваши программы, тем гуще будут заселены разного рода переменными и параметрами. Во избежание путаницы лучше учредить разумную систему обозначений. Большинство программистов используют для систематизации имен так называемые префиксы или приставки. Например, для параметров (аргументов) процедур и функций применяют префикс «a» (от слова «argument»). Помеченные таким образом параметры уже не спутаешь с локальными или глобальными переменными.

Теперь заглянем внутрь функции FindNumber. В первой строке результату функции присваивается значение FALSE. И это оправдано, поскольку значение функции обязательно должно быть определено, а в случае, если файл БД окажется пустым, этого не случится, поскольку следующий далее цикл WHILE не будет выполняться.

Поиск номера должен начинаться с начала файла. Оператор 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:=''; { очистка накопителя строки }

{ чтение символа до первой буквы }

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;

      {----- Процедура обработки строки -----}


procedure HandleString;

var N : integer; { оценка, прочитанная из файла }

      Cnt: integer; { количество оценок }

      Sum: integer; { сумма баллов }

      Rating: Real; { средний балл }

      Fam: string ; { фамилия }

begin

      Fam:= ReadFam ; { читаем фамилию }

      { для выравнивания столбцов добавляем пробелы }

      while Length(Fam) < 12 do Fam:= Fam + ' ';

      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 / Cnt; { вычисляем и печатаем ср. балл }

      Writeln(OutFile, Counter:3, Fam:18 , Cnt:8,

      Sum:14, Rating:11:1);

      end

      else       { а если оценок не было }

      Writeln(OutFile, Counter:3, Fam:18,' : Ученик не аттестован');

end;


begin       {--- Главная программа ---}

      Counter:= 0;       { обнуляем счетчик строк }

      { открываем входной файл }

      Assign(InFile,'Journal2.in '); Reset(InFile);

      { создаем выходной файл }

      Assign(OutFile,'Journal2.out '); Rewrite(OutFile);

      { выводим шапку таблицы }

      Writeln(OutFile, 'Номер Фамилия Количество Сумма Средний');

      Writeln(OutFile, '       оценок       баллов балл');

      { пока не конец входного файла… }

      while not Eof(InFile) do begin

      Counter:= Counter+1; { наращиваем счетчик строк }

      HandleString;       { обрабатываем строку }

      { переход на следующую строку }

      if not Eof(InFile) then Readln(InFile);

      end;

      { закрываем оба файла }

      Close(InFile); Close(OutFile);

end.



Итоги

• Для чтения отдельного слова в строке файла не годятся ни оператор Readln (он прочитает всю строку), ни оператор Read, который не видит конца строки. Слово читается посимвольно оператором Read с отслеживанием признака окончания строки и других условий.

• Строку выходного файла можно формировать порциями, применяя несколько вызовов процедуры Write. Каждый такой вызов формирует часть строки и продвигает позицию записи, оставляя её в текущей строке. Для перехода к следующей строке вызывается процедура Writeln.


А слабо?

А) Напишите программу для преобразования первого варианта базы данных «Police.txt» (которая содержит по одному числу в строке) во второй вариант (будет содержать по три числа в строке).

Б) Файл с физическими данными старшеклассников содержит три колонки: фамилия, рост и вес ученика. Создайте программы для решения следующих задач:

• отбор кандидатов для занятий баскетболом, – рост кандидата должен составлять не менее 175 см;

• поиск учеников с избыточным весом, для которых разница между ростом ученика (см) и его весом (кг) составляет менее 100.

Ваши программы должны сформировать соответствующие файлы с фамилиями и данными учеников.

Глава 32

Порядковые типы данных

 Сделать закладку на этом месте книги




Вот поле битвы, где там и сям мелькают спины бегущего противника. Разгоряченные боем, наши полки готовы гнать его хоть на край света. Но что это? Зачем полководец прекращает атаку и велит трубить сбор? Поверьте, он знает свое дело: выигрыш битвы – ещё не победа в войне. Предстоят новые сражения, и надо укрепить армию: дать отдых бойцам, накормить, подлечить и вновь построить в боевые порядки.

Освоенные нами элементы Паскаля (считайте их нашим войском) разбили в пух и прах все поставленные задачи. Но, то ли ещё будет! Впереди сильнейший противник. Так соберем свою армию в кулак, соединим все, что нам известно о Паскале. В этой и двух последующих главах мы детально рассмотрим уже освоенные элементы языка, и в первую очередь – типы данных.


Типы данных: простые и сложные

Кто из вас видел «предметы вообще»? Также не бывает и «данных вообще», – они обязательно принадлежат к тому либо иному типу. Учреждая переменную, параметр или функцию, потрудитесь сообщить их тип компилятору, иначе он не уяснит, сколько памяти отвести для этих данных и что позволено совершать с ними.

На рис. 73 представлены почти все типы данных, встроенные в язык Паскаль. Их принято делить на три категории: простые, сложные и указатели. К настоящему моменту вы знакомы со многими простыми типами данных и одним сложным – строковым типом String.

Чем разнятся сложные типы от простых? Тем ли, что сложные труднее изучать? Отчасти так, но суть не в этом. Сложные типы обладают внутренней структурой, в которой выделяются отдельные элементы. Так, например, можно выделить отдельные символы в строке. Простые же типы данных не «раскалываются» на мелкие детали.

А указатели? Их применяют для доступа к данным других типов. Указатель чем-то похож на адрес электронной почты или на гиперссылку, в свое время я расскажу об указателях все.






Рис.73 – Типы данных языка Паскаль

Сейчас направим внимание на простые типы данных с тем, чтобы снять гроздь, висящую на рис. 73 слева. Разобравшись с простыми типами, мы укрепим свой тыл и подготовим атаку на сложные типы данных. В этой главе ознакомимся с общими свойствами порядковых типов данных, а к вещественным обратимся в следующей главе.

Но прежде, чем дать общую характеристику порядковым типам, рассмотрим их по отдельности.


Целое братство

Целые числа образуют дружную «семью» из нескольких братьев. Вам пока знаком лишь один из них – это тип Integer, а где остальные? Начнем с двух младших братьев: типов Byte и ShortInt.

Изучая символы, мы узнали, что они кодируются целыми числами. Основной набор составляют 256 символов с кодами от 0 до 255 включительно. Этот диапазон значений может храниться в ячейке памяти, называемой байтом (BYTE). Байт – это наименьшая порция данных, адресуемая в памяти компьютера. Вы знаете, что байтом названа и единица измерения информации. Мог ли язык Паскаль пренебречь этим фактом? Нет, и ещё раз нет! В Паскале существует тип данных, который так и называется – Byte. Переменные типа Byte объявляются так:


var A, B, C : byte;


Байтовые переменные вмещают числа от 0 до 255. Это немного, но в некоторых случаях достаточно, и тогда применение байтовых переменных значительно экономит память.

Перейдем к брату-близнецу байта – коротышке ShortInt. Его имя расшифровывается как Short Integer – «короткое целое». Почему близнец? А потому, что он тоже занимает один байт памяти, но вмещает другой диапазон чисел – от минус 128 до плюс 127. Вместе с нулем получаются те же 256 значений. Этот тип данных тоже введен для экономии памяти. В самом деле, к чему тратить лишнюю память на переменные, хранящие маленькие числа? Отведем им один байт, только кодировать будем так, чтобы половина значений стала отрицательной. Так родился близнец-коротышка ShortInt.

Понятно, что ёмкости младших братьев хватает далеко не всегда, – даже количество дней в году не помещается в байтовой переменной. Для действий с более крупными числами программист обращается к средним братьям: типам Integer и Word. Каждый из них занимает по два байта памяти. Но если тип Integer вмещает диапазон чисел от минус 32768 до плюс 32767 (справедливо для Borland Pascal), то для типа Word диапазон сдвинут в положительную область и составляет от 0 до 65535. Кстати, название этого типа чисел – Word – переводится как «слово». Оно восходит ко временам 16-разрядных мини-ЭВМ, где длина так называемого машинного слова составляла два байта.

Когда не хватает ёмкости средних братьев, программисты зовут старшего – четырехбайтовый тип LongInt (Long Integer – «длинное целое»). Этот тип данных вмещает числа, превышающие два миллиарда. В табл. 2 представлены целочисленные типы данных языка Паскаль.

Примечание.  Размеры и ёмкость целочисленных типов зависят от компилятора и его настроек. Так, в 32-разрядном компиляторе Delphi типы Integer и LongInt совпадают и представлены 4-мя байтами, а также имеется 8-байтовый тип Int64.

Табл. 2 – Целочисленные типы данных (для Borland Pascal)

Тип данных Размер в байтах Диапазон возможных значений
От До
Byte 1 0 255
Shortint 1 –128 127
Word 2 0 65535
Integer 2 –32768 32767
Longint 4 –2147483648 2147483647

Хорошо, ну а если и ёмкости LongInt недостаточно? Неужели это предел? Конечно, нет. Но рассмотренных целочисленных типов хватает в большинстве случаев, где требуется точный подсчет. Подчеркиваю ещё раз – точный. Вещественные числа, о которых я расскажу в следующей главе, вмещают огромные значения, но представляют их приближенно. Для точного представления громадных чисел используют сложные типы данных.


Капля, переполняющая чашу

Конечно, вы догадались, что размер числового типа определяет его емкость, то есть диапазон возможных значений. А что случится при попытке выйти за этот диапазон? На ум приходит доверху наполненная чаша: очевидно, что лишняя капля стечет по стенке, и в чаше ничего не изменится. Так ли будет с числовой переменной? Вопрос не праздный, и, для ответа на него, проведем эксперимент.


{$R+ – включить проверку диапазонов }

var N : byte;

begin

      N:= 255; { 255 – максимальное значение для байта }

      N:= N+1;

      Writeln(N); Readln;

end.


Введите и откомпилируйте эту программу. В первой её строке вставлена директива, разрешающая компилятору следить за диапазонами числовых переменных. Эта директива соответствует флажку «Range checking» в окне опций компилятора (рис. 74).






Рис.74 – Окно опций компилятора

Запуск программы приведет к сообщению об ошибке «Runtime Error 201». Это значит, что попытка превысить диапазон для байтовой переменной, вызвала аварию программы.

Теперь измените директиву в первой строке, отключив проверку диапазонов (замените знак «+» знаком «–»).


{$R- – отключить проверку диапазонов }


Этот вариант программы не выдаст сообщений об ошибке, но результат ошеломит вас – это будет ноль! Вот так чаша! Числовая переменная оказалась необычной посудой, – лишняя капля полностью опустошила её! И теперь можно вновь заполнять пустую чашу. Убедитесь в этом, поменяв единицу на другое слагаемое, например 5, – в результате сложения получится 4. Открытое нами явление называют переполнением (по-английски – OVERFLOW).

В следующем опыте запустим такую программу.


{$R- – отключить проверку диапазонов }

var N : byte;

begin

      N:= 0;       { 0 – минимальное значение для байта }

      N:= N-1;

      Writeln(N); Readln;

end.


Результат ещё удивительней: теперь программа напечатает число 255! То есть, удалив из пустой чаши несуществующую каплю, мы наполнили её доверху! Этот фокус называют антипереполнением, то есть переполнением наоборот.

Проделав опыты с переменными других числовых типов, вы убедитесь, что переполнение и антипереполнение может постигнуть любую из них. Так, добавление единицы к положительному числу 32767 в переменной типа INTEGER дает отрицательный результат -32768. Отсюда следует общее правило: добавление единицы к максимальному значению для числового типа дает минимальное значение. И наоборот: вычитание единицы из минимального значения дает максимальное. Рис. 75 наглядно показывает это.






Рис.75 – Изменение числовых переменных при переполнении и антипереполнении

Такая вот чудная арифметика! Причина переполнений и антипереполнений кроется в устройстве регистров процессора, — в свое время мы узнаем о них больше при изучении двоичной системы счисления. Или вспомните одометр — прибор для подсчёта пробега автомобиля: по достижении предельного количества километров (99999) одометр сбрасывается в ноль.

Сейчас важно понять, что присвоение переменной некоторого выражения не гарантирует правильного результата, – он будет верным лишь при отсутствии переполнений и антипереполнений. Когда в вычислении участвуют переменные разных типов, оно выполняется в самом емком формате, то есть в Longint, а затем результат «обрубается» в соответствии с типом принимающей переменной, например:


{ $R- }

var B: Byte; S: ShortInt;       W: Word; N: Integer;

      ...

      N:= B + S + W;


Здесь даже при положительных значениях всех суммируемых операндов, результат в переменной N может оказаться отрицательным! Если вам не по нраву такое поведение программы, включайте директиву проверки диапазонов $R+.


Инкремент и декремент

Угадайте, что чаще всего делают с целыми переменными? — прибавляют и вычитают единицу. Потому в процессорах стараются ускорить эти операции. Паскаль не обошел вниманием эту особенность программ, и предлагает вам две процедуры, объявленные так:


procedure Inc (var N : longint); { прибавление единицы к переменной N }

procedure Dec (var N : longint); { вычитание единицы из переменной N }


Хотя параметр N в процедурах объявлен как LONGINT, в действительности здесь может стоять переменная любого порядкового типа: INTEGER, WORD, BYTE, CHAR и даже BOOLEAN.


var B: byte; N: integer; C: char;

  ...

  Inc(B); { B:= B+1 }

  Dec(N); { N:= N–1 }

C:= ‘A‘; Inc(C); { ‘B‘}


Процедуры инкремента и декремента – так их называют – выполняются быстрее операторов присваивания N:=N+1 и N:=N-1.

Работающим в IDE Borland Pascal, следует учесть, что здесь процедуры инкремента и декремента не подвластны директиве $R+ (в отличие от сложения и вычитания). То есть, переполнения и антипереполнения не вызывают аварий.


Диапазоны

Контроль переполнений директивой $R+ повышает надежность программ. Но порой нужны более сильные ограничения. Предположим, некая переменная M по смыслу является порядковым номером месяца в году. Стало быть, её значения должны быть ограничены диапазоном от 1 до 12. Программист может указать это компилятору, объявив переменную как диапазон, и явно задав допустимые пределы её изменения:


var M : 1..12;


Диапазон выражается двумя константами: минимальным и максимальным значениями, разделенными двумя точками. Теперь, при включенной директиве $R+, будет выдано сообщение об ошибке при попытке присвоить этой переменной любое значение за пределами 1…12. Во всем прочем диапазон – это обычный целочисленный тип (в данном случае – однобайтовый).


Перечисления

Рассмотрим ещё пример.


var M : 1..12;       { месяцы }

      D : 1..7;       { дни недели }

      …

      M:= D;       { здесь возможна смысловая ошибка }


Здесь объявлены две переменные: M – номер месяца в году, и D – номер дня недели. Это сделано через диапазоны, что гарантирует соблюдение границ. Но ничто не мешает нам присвоить месяцу значение дня, – ведь это не нарушит установленных пределов. Другое дело – смысл. Есть ли смысл в таком присваивании, или налицо ошибка программиста? Вероятней всего – последнее. Выявить ошибки такого рода помогает ещё один тип данных – перечисление.

Перечислением программист дает имена всем возможным значениям переменных, эти имена перечисляются внутри круглых скобок. Например, переменные M1 и M2 могут быть объявлены через сокращенные названия месяцев, а переменные D1 и D2 – через сокращенные названия дней недели.


var M1, M2 : (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dcb);

      D1, D2 : (Mond, Tues, Wedn, Thur, Frid, Satu, Sund);


Теперь компилятор разрешит присваивать переменным только объявленные значения, например:


      M1:= Apr;       { допустимо }

      M1:= M2;       { допустимо }

      M1:= 3;       { ошибка }

      M1:= Jan+2;       { ошибка }

      D2:= M1;       { ошибка }


Кстати, один из перечислимых типов вам знаком – это булев тип. Объявление булевой переменной равнозначно объявлению перечисления.


var B : ( FALSE, TRUE );       { равнозначно B : Boolean; }


Имена в перечислениях – это не строковые константы. Поэтому имя Jan и строка «Jan» совсем не одно и то же. Иначе говоря, оператор Write(M1) не напечатает вам название месяца, который содержится в переменной M1. Вы спросите, а как же печать булевых данных? Ведь они печатаются как «TRUE» и «FALSE». Да, но это единственное исключение.


Порядковые типы

Итак, вы познакомились с пятью числовыми типами данных, диапазонами и перечислениями. Вместе с булевым и символьным типами они составляют семейство порядковых типов данных, а значит, имеют общие свойства и области применения. Рассмотрим их.

Определение порядкового номера

Название «порядковый» говорит о том, что значения этих типов данных упорядочены относительно друг друга. С числами все ясно, – здесь порядок очевиден. А символы? Если вспомнить алфавит и таблицу кодировки символов, вопрос отпадет.

Хорошо, а как насчет перечислений и булевого типа? Оказывается, в памяти компьютера они тоже хранятся как числа. Например, упомянутое выше перечисление месяцев в памяти компьютера кодируется числами 0, 1, 2 и так далее, то есть как числовой диапазон 0..11. Таким образом, значение Jan соответствует нулю, Feb – единице и так далее. Подобным образом кодируются и булевы данные: FALSE – нулем, а TRUE – единицей.

В Паскале есть функция, определяющая числовой код данных любого порядкового типа. Она называется Ord (от Order – «порядок»), вот примеры её применения (в комментариях указаны результаты).


      Writeln ( Ord(5) );       { 5 }

      Writeln ( Ord(’F’) );       { 70 – по таблице кодировки}

      Writeln ( Ord(Mar) );       { 2 – смотри перечисление месяцев }

      Writeln ( Ord(False) );       { 0 }

      Writeln ( Ord(True) );       { 1 }


Для числа функция возвращает само число, для символа – код по таблице кодировки, а для перечислений – порядковый номер в перечислении, считая с нуля.

Сравнение

Из того, что данные порядковых типов кодируются числами, следует возможность их сравнения. Например, для перечислений месяцев и дней недели можно записать.


if M2 > M1 then … { если второй месяц больше первого }

if D1 = D2 then … { если дни совпадают }


Нельзя сравнивать данные разных перечислимых типов.


if M2 > D1 then …       { месяц и день – недопустимо }

if 'W' > 20 then …       { символ и число – недопустимо }


Но любые типы можно сравнить, приведя их к числовому типу.


if Ord(M2) = Ord(D1) then … { сравниваются числовые коды }

if Ord(’W’) > 20 then …       { сравнивается код символа с числом }


Прыг-скок

Итак, числа, символы, булевы данные, диапазоны и перечисления принадлежат к порядковым типам. В общем случае наращивать и уменьшать порядковые переменные путём сложения и вычитания нельзя (можно лишь числа и диапазоны). Но рассмотренные ранее процедуры инкремента (INC) и декремента (DEC) умеют это делать, они были введены в Паскаль фирмой Borland. Другим таким средством являются функции SUCC и PRED, которые существовали ещё в исходной «виртовской» версии языка.

Функция SUCC (от слова SUCCESS – «ряд», «последовательность») принимает значение порядкового типа и возвращает следующее значение того же самого типа, например:


      Writeln ( Succ(20) );       { 21 }

      Writeln ( Succ(’D’) );       { ’E’ }

      Writeln ( Succ(False) ); { True }

      m:= Succ(Feb);       { переменной m присвоено Mar }


Функция PRED (от PREDECESSOR – «предшественник») возвращает предыдущее значение порядкового типа:


      Writeln ( Pred(20) );       { 19 }

      Writeln ( Pred(’D’) );       { ’C’ }

      Writeln ( Pred(True) );       { False }

      m:= Pred(Feb);       { переменной m присвоено Jan }


Функции SUCC и PRED подчиняются директиве контроля диапазонов $R+. Например, следующие операторы вызовут аварийное прекращение программы:


{ $R+ }

      m:= Succ(Dcb); { превышение верхнего предела }

      m:= Pred(Jan); { выход за нижний предел }


В Borland Pascal есть одна тонкость: директива $R+ не действует, если функции SUCC и PRED вызываются для чисел, например:


{ $R+ }

var B : byte;

      ...

      B:=255; B:= Succ(B);       { нет реакции на переполнение }

      B:=0;       B:= Pred(B);       { нет реакции на антипереполнение }


В таких случаях в Borland Pascal имеет силу директива проверки переполнения $Q+, которая соответствует флажку «Overflow Checking» в окне опций компилятора (рис. 74). Директивы $R+ и $Q+ можно применять совместно, например:


{ $R+, Q+ }

var B : byte;       { допустимые значения для байта от 0 до 255 }

      C : ’a’..’z’; { это ограниченный диапазон символов }

      ...

      C:=’z’; C:= Succ(C);       { сработает R+ }

      B:=255; B:= Succ(B);       { сработает Q+ }


Счет


убрать рекламу






чики циклов

В операторе FOR-TO-DO для счетчика цикла мы применяли числовые переменные. Теперь разнообразим меню: ведь для этого годятся переменные любого порядкового типа, например:


var m : (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dcb);

      ...

      for m:= Jan to Dcb do...


А вот так вычисляется сумма кодов для символов от «a» до «z», здесь счетчиком цикла является символьная переменная:


var Sum : word; Chr : char;

      ...

      Sum:=0;

      for Chr:= ’a’ to ’z’ do Sum:= Sum + Ord(Chr);


Метки в операторе выбора

Вот ещё одно следствие числового кодирования: любой порядковый тип может служить меткой в операторе CASE-OF-ELSE-END:


var c : char;

      ...

      Case c of

      ’0’..’9’: Writeln(’Цифра’);

      ’a’..’z’: Writeln(’Латинская строчная’);

      ’A’..’Z’: Writeln(’Латинская заглавная’);

      end;


А вот ещё пример.


type TMonth = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dcb);

var m : TMonth; { здесь хранится один из месяцев }

      ...

      Case m of

      Jan, Feb, Dcb : Writeln(’Зима’);

      Mar..May       : Writeln(’Весна’);

      Jul..Aug       : Writeln(’Лето’);

      Sep..Nov       : Writeln(’Осень’);

      end;


Как видите, метки можно группировать, перечисляя их через запятую или объединяя в диапазон.


Разумный контроль

Директивы $R+ и $Q+ лучше использовать при отладке программы. В хорошо отлаженной программе таких ошибок возникать не должно, – за это отвечает программист. При компиляции окончательной версии эти директивы лучше отключить, чтобы не увеличивать размер программы и не замедлять её работу.


Итоги

• Существуют три категории типов данных: простые, сложные и указатели.

• Простые типы данных делятся на порядковые и вещественные.

• К порядковым типам относятся целые числа, символы, перечисления и булевы данные.

• Целые числа представлены пятью типами, которые отличаются размерами и диапазонами.

• Присвоение переменной порядкового типа значения, выходящего за допустимый диапазон, влечет ошибку нарушения диапазона.

• При включенной директиве $R+ нарушение диапазона приводит к аварии программы, а при отключенной – к переполнению или антипереполнению.

• Функцией ORD можно определить код любого значения порядкового типа.

• Переход к следующему или предыдущему значению порядкового типа выполняется функциями SUCC и PRED.

• Для быстрого прибавления и вычитания единицы предпочтительней применять процедуры INC и DEC.

• Порядковые типы данных обладают рядом общих свойств, что позволяет применять их в счетчиках циклов и в метках оператора выбора.


А слабо?

А) Напомню, что функция SizeOf возвращает объём памяти, занимаемый переменной, например:


      Writeln( SizeOf( LongInt ) );       { 4 }

      Writeln( SizeOf( M1 ) );       { 1 }


Воспользуйтесь ею для распечатки размеров всех известных вам порядковых типов данных.

Б) Перечислимые типы и диапазоны строятся на базе других типов данных (Byte, ShortInt и так далее). Какие типы данных, по вашему мнению, будут положены в основу следующих диапазонов:


var N : -10..10;

      M : -200..200;

      R : 0..40000;

      L : 0..400000;

      S : ’0’..’9’;


В) Процедура печати Writeln не способна распечатать название месяца, представленного в перечислении. Напишите для этого свою собственную процедуру (объявите тип TMonth и воспользуйтесь оператором CASE).

Г) «Не думай о секундах свысока…». Штирлицу подарили секундомер, который показывал секунды, прошедшие с начала суток. Пусть ваша программа переведёт это число в привычные часы, минуты и секунды.

Подсказки: во-первых, примените операции DIV и MOD. Во-вторых, переменную для секунд объявите как LONGINT (а не INTEGER), поскольку количество секунд в сутках (86400) не поместится в типе INTEGER.

Глава 33

Вещественные числа

 Сделать закладку на этом месте книги




Почему так несовершенны все людские поделки? Даже компьютер и язык Паскаль! Эх, был бы числовой тип, пригодный на все случаи жизни, но…

Пять целочисленных типов не покрывают всех потребностей в вычислениях. Во-первых, диапазон их значений не так уж велик. Скажем, население Земли – около шести миллиардов – не поместится в переменной типа LongInt. А что сказать о комарином «населении»? Это, во-первых. А во-вторых, такими числами нельзя выразить дробные значения.

Выручают вещественные числа. Откуда такое чудное название? – Этими числами можно выразить количество сыпучих и жидких веществ. Если так, то целые числа следовало назвать штучными. У вещественных чисел есть и другое название – действительные. Которое из двух предпочтете? – дело вкуса.


Изображение вещественных чисел

Вещественные числа отнесены к простым типам, но устроены сложнее целых. Рассмотрим способы изображения таких чисел. Представить их можно двояко: либо в привычной для нас форме с фиксированной точкой (в Паскале точку используют вместо запятой), либо в так называемом научном (логарифмическом) формате. Увидев где-либо такое число, не пугайтесь, – здесь применен научный формат изображения вещественного числа.


      3.33333343267441E-0002


Мы видим десятичную дробь, на хвосте которой болтается буква «E» и число -0002. Вот разгадка этой записи: дробь, что расположена до буквы «E», называется мантиссой, а число за этой буквой — порядком. Порядок показывает, на сколько позиций надо передвинуть десятичную точку в мантиссе для получения числа в привычном виде. Здесь порядок отрицательный, поэтому точка сдвигается на две позиции влево, а значит перед нами число 0.0333333343267441. Для положительного порядка точку двигают вправо, стало быть, число


      3.33333343267441E+0003


в форме с фиксированной точкой запишется так: 3333.33343267441.

Разумеется, что при нулевом порядке точку не трогают. Вот и вся премудрость научного формата, который называют ещё форматом с плавающей точкой. Если научная форма кажется вам причудливой и неудобной, изобразите иначе следующие числа.


9.1093829140E-0031 – масса электрона, кг

1.9889200000E+0030 – масса солнца, кг



Вывод вещественных чисел

Паскаль может избавить вас от мысленных передвижений десятичной точки: при печати вещественных чисел допустимы спецификаторы ширины поля. Напомню, что для вещественных чисел спецификатор состоит из двух частей, разделенных двоеточием. Первая часть задает общую ширину поля печати, а вторая – количество знаков после точки. Рассмотрим несколько вариантов вывода одного и того же числа со спецификаторами и без них. Подопытным будет число 10/3, что соответствует бесконечному ряду троек: 3.333… и т.д. Вот программа для этого опыта.


{ Программа для исследования форматов вывода вещественных чисел }

begin

      Writeln( 10/3);       { без спецификаторов }

      Writeln( 10/3 : 12);   { указывается только ширина поля }

      Writeln( 10/3 : 15:0); { только целая часть }

      Writeln( 10/3 : 15:2); { два знака после точки }

      Writeln( 10/3 : 15:3); { три знака после точки }

end.


Результат её работы таков.


3.33333333333333E+0000

3.333E+0000

      3

      3.33

      3.333


Как говорится, лучше раз увидеть… Вывод ясен: если не указать спецификатор поля или его вторую часть, то число выводится в научном формате с плавающей точкой, а иначе – с фиксированной.


Типы вещественных чисел

Подобно целым, вещественные числа представлены несколькими типами, которые разнятся размерами и диапазонами значений. Причина разнообразия все та же – стремление сэкономить память. В табл. 3 показаны четыре типа вещественных чисел языка Паскаль.

Табл. 3 – Вещественные типы

Тип данных Точность Диапазон возможных значений Количество значащих цифр (точность) Размер в байтах
От До
Real Стандартная 2.9 x 10–39 1.7 x 1038 11-12 6
Single Одинарная 1.5 x 10–45 3.4 x 1038 7-8 4
Double Двойная 5.0 x 10–324 1.7 x 10308 15-16 8
Extended Повышенная 3.6 x 10–4951 1.1 x 104932 19-20 10

Но почему в колонке минимальных значений я указал не нули, а очень маленькие числа? Да, ноль допустим, но для оценки точности вычислений важно знать именно этот предел. Разумеется, что указанные диапазоны распространяются и на отрицательные числа.

Теперь исследуем точность представления чисел разными типами данных.


{ Программа для исследования точности вещественных типов }

var F0 : Real; F1 : single; F2 : double; F3 : extended;

begin

      F0:= 1/3; F1:= 1/3; F2:= 1/3; F3:= 1/3;

      Writeln('Single = ', F1:23:18);

      Writeln('Real = ', F0:23:18);

      Writeln('Double = ', F2:23:18);

      Writeln('Extended= ', F3:23:18);

end.


Десятичное представление дроби 1/3 нам известно, – это бесконечная последовательность троек, а результат вычислений по этой программе перед вами (для Borland Pascal, в других компиляторах результаты могут немного отличаться):


Single = 0.333333343267440796

Real = 0.333333333333484916

Double = 0.333333333333333315

Extended= 0.333333333333333333


Как и следовало ожидать, тип Extended дает самую высокую точность, – после десятичной точки следуют одни тройки. Другие типы менее точны. Если так, зачем они нужны? Обратимся к истории.

Первые версии Паскаля ещё не застали персональных компьютеров. Тогда в языке существовал только один тип вещественных чисел – Real. Его считают стандартным типом Паскаля, и для обработки таких чисел годится любой процессор (но вычисления будут медленными).

Но вот появились компьютеры с математическими сопроцессорами, многократно ускоряющими счет. Эти сопроцессоры оперируют с форматами, отличными от Real. Для совместимости с новой техникой в язык были введены ещё три типа чисел, указанные в табл. 3. Тип Extended даёт наивысшую точность и самый широкий диапазон представления чисел. И это понятно, ведь его размер больше, чем у других, и составляет 10 байтов. Но почему он выигрывает и в скорости? А потому, что для сопроцессора тип Extended – родной, применяйте его для вычислений. А что же Single и Double? Поскольку они занимают меньше места в памяти, то лучше подходят для хранения больших объёмов данных.


Сравнение вещественных чисел

Вещественные числа часто сравнивают между собой. Однако проверка их на точное равенство таит неприятный сюрприз, – такие сравнения ненадежны! Все потому, что вещественные числа – приближенные; они могут быть очень близки, и все же чуточку не совпадать друг с другом. Точное совпадение – это удача, а не закономерность. Правильней сравнивать числа с некоторой точностью, как в показанном ниже примере.


var A, B : Extended;

...

if A = B then …       { это ненадежное сравнение }

if Abs(A-B) < 0.001 then … { надежное сравнение с точностью 0.001}


Во втором сравнении переменные A и B считаются одинаковыми, если отличаются менее чем на одну тысячную. Как видите, знаком равенства тут и не пахнет. К слову, функция Abs возвращает абсолютное значение аргумента, – ведь здесь надо получить положительное значение разности. Выражение Abs(A-B) в математике пишется так: |A-B|.


Типы данных пользователя

Богатый арсенал типов данных, запасенный в Паскале, кажется достаточным на все случаи жизни. Скоро вы убедитесь, что это не так. Но Паскаль разрешает программисту создавать свои собственные типы данных, заточенные под определенную задачу. Их называют пользовательскими типами, и строят на основе все тех же базовых типов Паскаля. Рассмотрим пример.

Предположим, ваша программа содержит много переменных типа Integer. Но, по ходу работы над проектом, вы решили заменить этот тип чисел на какой-то иной, например на Longint или даже Extended. Такую замену можно сделать редактором текста, тщательно порывшись в программе и найдя все места, где объявлены переменные. Но можно сделать лучше – объявить собственный тип данных.

Для объявления пользовательских типов в Паскале служит секция описания типов, которая начинается с ключевого слова TYPE – «тип». Внутри секции можно объявить один или несколько типов данных пользователя. Так, например, вы можете объявить свой тип на базе встроенного типа Integer.


Type TValue = Integer;


Здесь объявлен тип данных по имени TValue (Value – «значение»), он равнозначен типу Integer. Как видите, объявление типа схоже с объявлением константы. Только справа от знака равенства следует не значение, а описание типа.

Имя пользовательского типа придумывают по общим правилам для имен. В свое время мы учредили префиксы для констант и аргументов процедур, – префиксы делают программу понятней. Для констант мы договорились применять префикс «C», для аргументов процедур и функций – префикс «a». Для типов возьмем префикс «T» (от слова Type). Повторяю: префиксы – это всего лишь добровольное соглашение программистов, а не требование языка.

Теперь, когда тип TValue объявлен, его можно использовать для объявления переменных, например:


Type TValue = Integer;

Var A, B, C : TValue;

      ...

      Readln(A, B);

      C:= A+B;


Если со временем потребуется изменить типы переменных A, B и C на тип Longint, то мы исправим лишь объявление пользовательского типа.


Type TValue = Longint;


И после компиляции все переменные типа TValue примут тип Longint.

На первый взгляд, пользовательские типы дают лишь косметические удобства. Но скоро – при освоении сложных типов данных – вы и шагу не ступите без них. Впрочем, пользовательские типы пригодятся нам гораздо раньше – для преобразования типов данных.


Совместимость и преобразование типов

Поздравляю! Теперь вам знакомы все простые типы данных – солдаты нашей армии. Сражаясь в едином строю, они будут передавать при необходимости данные друг другу. Такая передача данных должна подчиняться определенным правилам. Они просты, но заставляют программиста всякий раз задуматься: то ли я делаю? А это придает программам надежность.

Далее рассмотрим правила, по которым данные одного типа обращаются в другой: вещественное число — в символ, или целое — в булево. Эти волшебства возможны благодаря числовому кодированию всех типов данных. Поэтому целые числа будут центральным звеном всех преобразований, с них и начнем.

Целое и целое

Все целые типы совместимы между собой, а значит позволено взаимное присваивание их значений. Но не забывайте о возможном нарушении диапазонов. Вот общее правило: переменные более ёмких старших типов всегда примут данные из младших типов своего братства. Обратное не возбраняется, но может вызвать нарушение диапазонов, например:


Var B: Byte; I: Integer; W: Word; L: Longint;

      ...

      { Эти операторы не вызовут нарушения границ диапазонов }

      I:= B;       W:=B;       L:= W;       L:=I;

      { Эти операторы могут повлечь нарушения диапазонов }

      B:=I;       I:=W;       W:=L;


Когда число N не помещается в переменной, то в неё попадает лишь младшая часть числа N (т.е. остаток от деления N mod 256 или N mod 65536).

Целое и символ

Взаимно превращать эти типы данных мы научились при шифровании символа; напомню об этом. Функция Ord возвращает числовой код любого порядкового типа, в том числе и символа. А функция Char делает обратный фокус, превращая число в символ, вот примеры:


      Writeln ( Ord(’D’) );       { 68 }

      Writeln ( Char(68) );       { D }


Как видите, число в символ преобразуется через имя типа Char. Это общий прием, волшебная палочка для обращений типов данных. Например, булевых.

Целое и булево

Превратить булево в целое можно все той же функцией Ord.


      Writeln ( Ord(False) );       { 0 }

      Writeln ( Ord(True) );       { 1 }


А для обратного превращения воспользоваться именем типа Boolean.


      Writeln ( Boolean(0) );       { False }

      Writeln ( Boolean(1) );       { True }


Целое и перечисление

Вернемся к перечислению месяцев, вымышленному нами в предыдущей главе, где переменная была объявлена так:


var m : (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);


Превратить значение такой переменной в число можно функцией Ord. А наоборот? Пока нам этого не удавалось. Но после объявления пользовательского типа данных задача решается очень просто.


Type TMonth = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);

Var m : TMonth;

      ...

      m:= 3;       { это ошибка }

      m:= TMonth(3); { это равнозначно m:= Apr (счет идет от нуля) }


Здесь объявлен пользовательский перечислимый тип TMonth (Month – «месяц»), далее вы вольны применять его и для объявления переменных, и для преобразования типов. Вот где проявляется сила пользовательского типа!

Вещественное и вещественное

Подобно целому братству, вещественное братство дружно между собой. Переменной одного вещественного типа можно присвоить значение другого типа, при условии, что это значение поместится в новое «жилище», то есть, не приведет к нарушению диапазона.

Целое и вещественное

Вещественным переменным можно присваивать целые значения, не задумываясь о последствиях, – преобразование происходит автоматически. Но обратная операция не так проста, поскольку здесь надо решить судьбу дробной части вещественного числа, которая не попадет в целочисленную переменную. Есть две возможности: либо отбросить дробную часть, либо округлить вещественное число до ближайшего целого. Для этого Паскаль предлагает две функции, возвращающие целочисленные значения: Trunc – усечение, и Round – округление. Вот примеры их вызова.


      Writeln ( Trunc(3.75) ); { 3 }

      Writeln ( Round(3.75) ); { 4 }

      Writeln ( Round(3.25) ); { 3 }


Напоследок рассмотрите рис. 76, где показана общая картина совместимости и преобразования простых типов данных.

Строгий контроль типов в Паскале задуман для пущей надежности программам. В старых языках программирования (Си, Фортран) такого контроля либо не было, либо он был очень слаб. Программист перебрасывал данные как ему вздумается, не слишком заботясь о последствиях. Подобные вольности порождали массу ошибок. Теперь же Паскаль предлагает программисту следующее: пожалуйста, переноси данные, куда угодно, но при этом укажи явным образом, что ты делаешь.


Размеры переменных и типов данных

Иногда требуется знать не только содержимое переменных, но и объём занимаемой ими памяти. Разумеется, вы можете узнать это из таблиц, приведенных в справке или руководстве по языку. Размеры сложных типов данных тоже поддаются расчету. И все же лучший способ определить размер переменной некоторого типа – вызов псевдофункции SizeOf. В качестве параметра она принимает либо имя переменной, либо имя типа, а возвращает целое число – объём занимаемой памяти в байтах. Вот примеры.


Type TMonth = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);

Var m : TMonth;

      ...

      Writeln ( SizeOf(m) );             { 1 }

      Writeln ( SizeOf(TMonth) );       { 1 }

      Writeln ( SizeOf(Integer) );       { 2 }

      Writeln ( SizeOf(Extended) );       { 10 }






Рис.76 – Совместимость и преобразования типов

Я обозвал SizeOf псевдофункцией за то, что никаких вычислений она не делает, – результат вычисляется при компиляции программы. Ведь компилятор сам «знает» объём памяти, занимаемой любым типом данных, и подставляет в программу уже готовое число.

Псевдофункция SizeOf удобна, и вдобавок улучшает переносимость программ. Например, в разных режимах компиляции Free Pascal и в разных компиляторах размер типа Integer может отличаться (2 или 4 байта). Применяя функцию SizeOf, вам не придется задумываться об этом и менять вручную одни числа на другие, – компилятор сделает это за вас.


Итоги

• Для представления дробных, а также очень больших и очень маленьких чисел используют вещественные типы данных. Разные вещественные числа различаются размером, диапазоном хранимых значений и точностью их представления.

• Тип Extended предпочтительней использовать для вычислений, тип Single – для хранения больших объёмов данных в памяти и на диске.

• Вещественные числа печатаются либо в форме с плавающей точкой, либо в форме с фиксированной точкой.

• Вещественные числа, в отличие от целых, – приближенные. Сравнивать их между собой можно лишь с некоторой точностью.

• Вещественным переменным разрешено присваивать целые значения, при этом преобразование типов происходит автоматически.

• Целым переменным нельзя присвоить вещественные значения непосредственно, для этого используют либо функцию отсечения дробной части Trunc, либо функцию округления Round.

• Порядковые типы данных допускают взаимное преобразование посредством псевдофункций, имена которых совпадают с именами типов данных.

• Пользовательские типы данных объявляют внутри секции TYPE, такие типы данных делают программу гибче и надежней.

• Размер памяти, занимаемый переменной любого типа, определяют псевдофункцией SizeOf. Её применение снижает зависимость программы от особенностей компиляторов и компьютерных платформ.


А слабо?

А) Напишите две функции, округляющие вещественное число:

• до большего значения (например: 3.1 –> 4; 3.9 –> 4);

• до меньшего значения (например: 3.1 –> 3; 3.9 –> 3).

Б) Ваша процедура принимает строковую переменную, вычисляет среднее арифметическое кодов её символов и печатает его с двумя цифрами после точки.

В) Напечатайте с тремя знаками после точки 20 случайных вещественных чисел в диапазоне от 0 до 10. Подсказка: для формирования дробных чисел можно делить случайное число на другое число, например, Random(10000)/1000.

Г) Напечатайте с тремя знаками после точки 20 случайных чисел в диапазоне от 0 до 10 так, чтобы числа следовали по возрастанию. Подсказка: сравнивайте очередное число с предыдущим.

Д) Программа для подсчета стоимости покупок. Для каждой покупки пользователь вводит два действительных числа: вес покупки и цену за 1 кг в рублях. Признак завершения ввода данных – нулевой вес. Программа должна напечатать общую стоимость с точностью до копейки (два знака после точки) с округлением в большую сторону. Проверьте результат на калькуляторе.

Е) Квадратный корень. Квадрат – это равносторонний прямоугольник, его площадь вычисляется по формуле S=D•D, где D – сторона квадрата. А когда площадь S известна, и надо определить сторону D? Тогда из S извлекают квадратный корень (обозначается символом V ). Так, если S=9, то D=V 9=3.

Для извлечения корня в Паскале есть функция SQRT. Напишите собственную функцию MySQRT, прибегнув к методу последовательных приближений. В грубом, нулевом приближении примем D0=1. Последующее, более точные значения D будем вычислять по формуле

Di+1 = (Di + S/Di)/2

Так, при S=9 получим D1=(1+9/1)/2= 5, D2=(5+9/5)/2= 3.4  и так далее, пока абсолютная разность между двумя последовательными значениями D станет пренебрежимо мала. Функция MySQRT должна принять число и вычислить его корень с точностью 0.0001. Внутри функции напечатайте промежуточные значения D. Подсказка: для Di и Di+1 вам потребуются лишь две локальные переменные.

Ж) В тесто кладут четырех главных ингредиента: муку, сахар, яичный порошок и молоко. Все это смешивается в пропорции, заданной рецептом. Например, рецепт 100:5:7:500 означает, что на 100 граммов муки кладут 5 граммов сахара, 7 граммов яичного порошка и 500 граммов молока. У пекаря есть некоторое количество всех ингредиентов, и он хочет замесить из них максимально возможное количество теста, соблюдая рецепт. Ваша программа должна ввести:

• Рецепт – это 4 целых числа.

• Исходное количество ингредиентов – это 4 действительных числа.

Программа должна напечатать:

• Общее количество полученного теста с точностью два знака после точки.

• Остатки ингредиентов – 4 числа с точностью два знака после точки.

Глава 34

Структура программы

 Сделать закладку на этом месте книги




В этой главе мы рассмотрим структуру программы, и завершим тем самым боевое построение нашего войска, начатое в 32-й главе.


Управляющие структуры

Управляющие структуры составляют основу языков программирования. Ключевых структур всего три:

• линейная последовательность – это естественный порядок выполнения операторов друг за другом, то есть слева направо и сверху вниз;

• альтернатива – выбор одного из двух или нескольких направлений исполнения операторов;

• цикл – повторное исполнение операторов до соблюдения некоторого условия.

Альтернатива и цикл представлены в Паскале несколькими операторами, из которых программист выбирает тот, что лучше подходит к решаемой задаче (рис. 77).






Рис.77 – Управляющие структуры языка Паскаль

Итак, для организации альтернативы может быть использован один из трех операторов:

• неполный условный оператор IF-THEN;

• полный условный оператор IF-THEN-ELSE;

• оператор выбора CASE-OF-ELSE-END.

Для организации циклов программист также применяет три оператора:

• цикл с проверкой условия в конце REPEAT-UNTIL;

• цикл с проверкой условия в начале WHILE-DO;

• цикл со счетчиком FOR-TO-DO и FOR-DOWNTO-DO.

Обратите внимание на условия продолжения циклов WHILE-DO и REPEAT-UNTIL, – они взаимно противоположны! Первый из них выполняется, пока условие истинно, а второй – пока оно ложно.

Странно, что из этих немногих структур лепятся столь сложные программы!


Структура программы

Программа на Паскале состоит из ряда секций (Section – «часть», «раздел»). Под структурой программы будем понимать взаимное положение этих секций. На рис. 78 показана упрощенная структура программы.






Рис.78 – Структура программы на языке Паскаль

Каждую секцию открывает своё ключевое слово. Три секции: Const, Type и Var – образуют описательную часть программы. Здесь компилятор черпает информацию о размещении данных в памяти. Секции с описаниями процедур и функций и главная программа формируют исполнительную часть, – здесь содержатся исполняемые операторы (секция кода). Все секции, кроме главной программы, необязательны. Но, при необходимости, секции могут повторяться и чередоваться в любом порядке, соблюдая два п


убрать рекламу






ростых правила:

• любой объект программы – будь то константа, тип, переменная или процедура – объявляется до своего применения;

• главная программа располагается в тексте последней (хотя исполнение начинается именно с нее!).

Два слова о точке с запятой (;). В описательной и в исполнительной частях программы её назначение слегка различается. Если в объявлениях точка с запятой завершает оператор и обязательна, то в секции кода она разделяет операторы и не нужна за последним оператором блока.


Структура процедур и функций

Процедуры и функции – основные строительные блоки программ, в крупных проектах их сотни. Главная программа обычно содержит несколько операторов, а основная работа отдается процедурам и функциям. Такой подход не только упрощает разработку, отладку и понимание программ, но и существенно уменьшает их размер (объём занимаемой памяти). Всё, что требует алгоритм, достигается вызовом одних процедур и функций из тела других, – то есть применением вложенных вызовов. Глубина вложения таких «матрешек» практически не ограничена. Опытный программист обычно разбивает большую программу на ряд мелких и простых процедур и функций.

Внутренняя структура процедур и функций схожа со структурой программы. Это своего рода программы в программе, потому их и называют подпрограммами. На рис. 79 показана упрощенная структура процедуры с условным именем ABC.






Рис.79 – Структура процедуры

Такой же структурой обладают и функции, которые, в отличие от процедур, возвращают значение некоторого типа. Правила чередования секций внутри подпрограмм – локальных секций – точно такие же, как и для секций программы в целом, а именно:

• любой объект объявляется до своего применения;

• тело процедуры или функции обязательно и размещается последним.

Объявленные внутри подпрограммы константы, типы и переменные – локальные объекты – видны лишь внутри этой подпрограммы. При совпадении их имен с глобальными объектами, локальные имеют преимущество, то есть закрывают собою внешние объекты.


Обмен данными с подпрограммами

Вызов процедур и функций обычно сопровождается передачей данных между вызываемой подпрограммой с одной стороны и вызывающим её фрагментом с другой. Иначе говоря, данные либо передают внутрь подпрограммы, либо получают от нее. Иногда делают и то, и другое. Существует три способа такого обмена:

• через глобальные переменные;

• через параметры процедур и функций;

• возвратом результата через имя функции.

Передача данных через глобальные переменные кажется самой простой, – ведь эти переменные видны из многих частей программы. Но этот способ оправдан лишь в небольших проектах. С ростом размера и сложности программы все труднее отслеживать взаимные влияния её частей через глобальные переменные. Это запутывает программу и снижает её надежность.

Для обмена данными разумнее использовать параметры процедур и функций, а также имена функций. В табл. 4 показаны три способа передачи данных через параметры.

Табл. 4 – Три способа передачи данных через параметры

Способ передачи данных Пример заголовка процедуры Пример вызова
По значению:в процедуру передается значение параметра. Procedure ABC (arg:integer); ABC(10);ABC(X+3);
По ссылке CONST:В процедуру передается ссылка на константу или переменную, содержащую данные. Procedure ABC (const arg:integer); ABC(10);ABC(X);
По ссылке VAR:В процедуру передается ссылка на переменную, содержащую данные. Procedure ABC (var arg:integer); ABC(X)

Опытного программиста отличает умение эффективно передавать данные; табл. 5 поможет вам выбрать наиболее удачный способ такой передачи.

Табл. 5 – Рекомендуемые способы передачи данных

Куда передавать данные Рекомендуемый способ
Только в процедуру или функцию 1) По значению (простые типы) 2) По ссылке CONST (сложные типы)
Только из процедуры и функции 1) Через имя функции (одно значение) 2) По ссылке VAR (несколько значений)
В обоих направлениях По ссылке VAR (любые данные)

В каждом случае предпочтительный способ указан первым. Данные простых типов лучше передавать внутрь подпрограмм по значению. По ссылке CONST передают строки и другие сложные типы данных (скоро мы изучим их). Через имя функции возвращают лишь один результат. А если надо вернуть несколько результатов, или вернуть сложный тип данных, используют ссылки VAR.


Встроенные процедуры и функции

Программа, сработанная профессионалом, состоит почти из одних только процедур и функций, разработка которых отнимает львиную долю времени. Но не всегда программисты пишут их сами. В Паскале запасено немало готовых подпрограмм – это встроенные в язык и в библиотеки процедуры и функции. С ними можно ознакомиться в руководстве по языку и во встроенной справке. Некоторые из них вам известны, и применялись нами.


Текстовые файлы

Напоследок напомню об основных средствах обработки текстовых файлов.

Для чтения из файлов применяют следующие процедуры и функции:


Assign(F, ...) - Связать файловую переменную с файлом

Reset(F) - Открыть файл для чтения

Read(F, ...) - Прочитать часть строки файла

Readln(F, ...) - Прочитать строку файла и перейти к следующей

Eoln(F) - Проверить на конец строки

Eof(F) - Проверить на конец файла

Close(F) - Закрыть файл


Для записи в файл применяют такие процедуры:


Assign(F, ...) - Связать файловую переменную с файлом

Rewrite(F) - Открыть файл для записи

Write(F, ...) - Записать часть строки файла

Writeln(F, ...) - Записать строку файла и перейти к следующей

Close(F) - Закрыть файл


Чтобы связать текстовый файл с клавиатурой (при вводе) или с экраном (при выводе), можно прибегнуть к двум приёмам. Первый состоит в том, чтобы назначить файлу пустое имя.


var F_In, F_Out : Text;

begin

Assign(F_In,’’); Reset(F); { F_In связали с клавиатурой }

Assign(F_Out,’’); Rewrite(F); { F_Out связали с экраном }

. . .

end.


Второй приём заключается в применении специального имени "CON" — от слова Console (оно предусмотрено в MS-DOS и Windows).


Assign(F_In,’Con’); Reset(F); { F_In связали с клавиатурой }

Assign(F_Out,’Con’); Rewrite(F); { F_Out связали с экраном }


В операционных системах MS-DOS и Windows существует несколько специальных имен файлов, вот некоторые из них:


AUX - Первый асинхронный коммуникационный порт

CON - Клавиатура и экран (CONsole)

NUL - Фиктивное устройство (для тестирования)

PRN - Первый параллельный принтер


Аналогичные имена применяют и в UNIX-подобных системах.

Наконец, для действий с текстовыми файлами можно применять две встроенные в язык файловые переменные: INPUT и OUTPUT. Они не нуждаются ни в объявлении, ни в открытии, ни в закрытии файлов:


Readln(Input, S); { - то же самое, что Readln(S) }

Writeln(Output, S); { - то же самое, что Writeln(S) }


Файловые переменные INPUT и OUTPUT можно передавать в качестве фактических параметров внутрь процедур и функций, а также связывать их с дисковыми файлами. Вот пример копирования файла из «MyText.in» в «MyText.out»:


var S: string;

begin

Assign(Input,’MyText.in’); Reset(Input);

Assign(Output,’MyText.out’); Rewrite(Output);

While not Eof do begin

Readln(S);

Writeln(S);

end;

Close(Input); Close(Output);

end.



Что дальше?

Мы изучили фундамент языка Паскаль, который составляют простые типы данных и управляющие структуры. Впереди интересные и серьезные проекты, в основе которых лежат сложные типы данных. Вы осилите их, если пройденный материал надежно закрепился в вашей голове. Вы чувствуете это? Нет? Тогда без ложного стыда вернитесь к началу книги, ведь повторение – мать учения!


Итоги

• Основу программ составляют три базовые управляющие структуры: линейная последовательность, альтернатива и цикл.

• Альтернатива организуется условными операторами и оператором выбора.

• Для циклов в Паскале предусмотрено три оператора: 1) цикл с проверкой в начале, 2) цикл с проверкой в конце и 3) цикл со счетчиком.

• Программа состоит из ряда секций. Секции описания констант, типов и переменных нужны для размещения данных. Исполняемые секции содержат процедуры, функции и главную программу.

• Обязательной является лишь секция главной программы, прочие секции включают в программу по мере необходимости.

• Секции могут чередоваться произвольно. Но любой объект программы должен быть объявлен до того, как будет использован.

• Основная нагрузка по обработке данных возлагается на процедуры и функции – подпрограммы. Из тела одних подпрограмм вызывают другие подпрограммы, – такие вызовы называют вложенными.

• Передачу данных между подпрограммами предпочтительней выполнять через параметры и имена функций.


А слабо?

А) Найдите две ошибки в следующей программе.

var X : TNum;

type TNum = integer;

const A = 10;

begin

X:= A+B;

end.

Б) Напишите булеву функцию Test и программу для её демонстрации. Функция должна проверять, делится ли без остатка первое число на второе, например:


Writeln( Test(20, 4) );       { true }

Writeln( Test(21, 5) );       { false }


В) Напишите целочисленную функцию Division для деления первого числа на второе без применения операции DIV. Вот примеры вызовов:


Writeln( Division(20, 4) );       { 5 }

Writeln( Division(21, 5) );       { 4 }


Подсказка: внутри функции вычитайте второе число из первого. Предотвратите деление на ноль (как результат возвращайте ноль). Сделайте два варианта: 1) деление положительных чисел, 2) деление чисел с учетом знака.

Г) Пусть ваша программа распечатает все множители (кроме единицы) введенного пользователем целого положительного числа, например:


Введите число: 60 

2 2 3 5


Д) Напишите функцию для ввода целого числа. Она принимает строку-приглашение и возвращает введенное число, например:


      X:= GetNumber(‘Введите стоимость покупки=’);

Глава 35

Множества

 Сделать закладку на этом месте книги




С малых лет я завидовал обладателям волшебных палочек, ковров-самолетов и прочих волшебных штучек! Смел ли я мечтать о таких игрушках? И вот познакомился с Паскалем… Мы приступаем к мощнейшим средствам этого языка – сложным типам данных. Овладейте ими, и мудреные задачи разрешатся сказочно просто!


В директорском кабинете

Редкий смельчак сунется в директорский кабинет. Но чтобы вникнуть в предстоящую задачу, нам надо тайно проникнуть к директору школы. Вот вам шапка-невидимка (ещё одна волшебная штуковина), вдохните глубже и ступайте на цыпочках за мной.

Мы находим усталого Семена Семеновича перед кипой исчерканных листков с фамилиями учеников. Чем озабочен директор? Сейчас объясню. В начале учебного года Семен Семенович распорядился, чтобы все ученики вступили в какой-либо кружок или спортивную секцию – по желанию. А теперь, спустя пару месяцев, он проверяет исполнение приказа. Директор намерен наказать тех, кто не исполнил распоряжения, и поощрить состоящих в нескольких кружках или секциях. Но, промучившись неделю со списками кружков, он готов уж отказаться от своей затеи, – задача не поместилась в директорской голове. Судите сами: ведь в школе двести пятьдесят учеников! Спасайте Семена Семеновича!


Первым делом, первым делом – оцифровка

Директорскую задачу поручим компьютеру, а тому сподручней орудовать с числами. Заменим фамилии учеников числами, назначив каждому ученику уникальный, несовпадающий с другими, номер. Переход от фамилий к номерам и обратно – простая задачка, её мы оставим Семену Семеновичу. Таким образом, наш входной файл со списками учеников будет содержать по одной строке для каждого кружка, где перечисляются через пробел номера учеников, состоящих в этом кружке. Вот пример входного файла для трех кружков.


2 11 4 13

9 17 12 11 3 5 18

14 2 13 15 20


Здесь в первый кружок записались 4 школьника, во второй – 7, а в третий – 5 учеников. Как видите, их номера перечислены в произвольном порядке, что затрудняет ручную обработку таких списков. От компьютера требуется выявить номера учеников (от 1 до 250), которых нет в таком файле. Хочется найти простое решение, а оно возможно лишь с применением нового для нас типа данных – множества.


Множества глазами математика

Слово «множество» намекает на большое количество чего-либо. Чего именно? А все равно! Множества придумали математики, а им безразлично, что считать. Так подать сюда математика, и пусть ответит за всех! Скоро явился математик, взял два кружочка – черный и белый – и, протерев свои толстые очки, стал объяснять. Вот суть его речи.






Рис. 80 – Множества точек черного (B) и белого (W) кругов

Вы полагаете, что это кружочки? Нет, друзья, это два множества точек, – одно принадлежит черному кругу, другое – белому. Обозначим первое из них латинской буквой B (от Black – «черный»), а второе буквой W (от White – «белый»). Итак, черные и белые точки этих кружков назовём элементами множеств. Сколько там этих точек? Доказано, что бесконечно много, но к свойствам множеств это не имеет отношения. Что же это за свойства?

Добавление к множеству существующих элементов

Покройте черный круг таким же или меньшим черным кругом, или почеркайте его углем, – заметите разницу? Если на белый круг наложить такой же, или почеркать его мелом, – тоже не увидите изменений. Значит, множество не изменится при добавлении к нему элементов, уже входящих в это множество. На языке математики это свойство выразится так:

B + B = B

или так:

W + W + W = W

Не правда ли, странная арифметика?

Объединение множеств

Продолжим наши мысленные опыты и перекрасим оба круга в серый цвет. Будем считать их теперь одной фигурой, разорванной на части.






Рис. 81 – Объединение непересекающихся множеств G = B + W

Так мы получили новое множество, представляющее сумму или объединение двух предыдущих. Обозначим это новое множество буквой G (от Gray – «серый») и выразим то, что сделали, формулой.

G = B + W

Очевидно, что число точек во вновь образованном множестве равно их сумме в двух исходных. Пока в этом нет ничего интересного, – ведь исходные множества B и W, как говорят математики, не пересекаются. Сблизим круги так, чтобы добиться их частичного перекрытия (рис. 82).






Рис.82 – Объединение пересекающихся множеств G < B + W

Теперь количество точек в объединенном множестве будет меньше, чем в двух исходных по отдельности.

G < B + W

В общем случае при объединении множеств (как пересекающихся, так и не пересекающихся) соблюдается правило.

G ≤ B + W

Пересечение множеств

Иногда математиков (и не только их) интересует область пересечения множеств, отметим её серым цветом (рис. 83).






Рис.83 – Пересечение множеств G = B * W

Операцию пересечения множеств обозначают знаком умножения.

G = B • W

Количество точек в пересечении, как понимаете, не может быть больше, чем в любом из исходных множеств B и W. Для этого случая справедливо утверждение: пересечение множеств не больше любого из них.

B • W ≤ B и B • W ≤ W

Вычитание множеств

О солнечных и лунных затмениях слышали все, а кто-то и наблюдал их. Для математика это зримые примеры вычитания множеств; взгляните на рис. 84 – чем не затмения? Серую область можно трактовать как результат вычитания одного круга из другого. На левом рисунке белый круг «отгрыз» часть черного, превратив его в серую область, а на правом – наоборот. Подобающие этим случаям формулы будут таковы.

G = B – W или G = W – B






Рис.84 – Вычитание множеств

А если вычитаемый круг окажется больше того, из которого вычитают, и полностью поглотит его? В алгебре разность получится отрицательной, а здесь? Ничего подобного! При вычитании большего множества из меньшего или равного ему получается пустое множество, оно обозначается символом Ø. Из пустого множества тоже можно вычитать, и результатом опять будет пустое множество.

(B – B) – B = Ø

(Ø – W) – B = Ø

Вот такими интересными свойствами обладают множества!

Подмножества и надмножества

На рис. 85 белый круг полностью поглощен черным. Тогда говорят, что множество точек белого круга составляет подмножество точек черного. Или так: множество точек черного круга является надмножеством точек белого. Математик выразит это формулой:

B > W






Рис.85 Надмножество (B) и подмножество (W)

А если круги совпадают и полностью перекрывают друг друга? Тогда говорят, что множества равны, и любое из них является и подмножеством, и надмножеством другого. В общем случае:

если B ≥ W, то B является надмножеством W;

если B ≤ W, то B является подмножеством W.


Числовые множества

Мы рассмотрели несметные множества бесконечно маленьких точек. Но компьютеры ещё не умеют работать с бесконечностями. Так умерим свой аппетит и перейдем к множествам с конечным числом элементов. Поступим так: вместо раскраски кругов расставим на них ряд жирных точек и пронумеруем их числами от 1 до 9 (рис. 86). В ходе последующих опытов нас будут интересовать лишь эти избранные точки (то есть, числа).






Рис.86 – Множества чисел

Так мы получили два конечных множества чисел. Одно из них, обозначенное буквой A, содержит числа 8, 7, 9, 3, 5, 2. Другое обозначено буквой B и включает числа 5, 4, 6, 1, 2. Эти множества математики записали бы так:

A = { 8, 7, 9, 3, 5, 2 }

B = { 5, 4, 6, 1, 2 }

Для записи множеств они используют фигурные скобки. Обратите внимание: числа в скобках следуют в произвольном порядке. Это значит, что порядок перечисления элементов множества не важен. Учтите также, что числа 2 и 5 входят в оба множества.

Подобно точкам на круге, каждый элемент числового множества уникален, иными словами, может входить в множество лишь единожды. Вспомните нашу попытку покрасить углем черный круг, – добавление к множеству существующих в нём элементов не изменяет его. Этим же свойством обладают и числовые множества. Например, для нашего случая справедливо следующее.

A + { 8, 7 } = A

Множество A после объединения с множеством {8,7} не изменилось, поскольку уже содержало эти числа.

С числовыми множествами поступают так же, как и с бесконечными: объединяют, пересекают, вычитают и сравнивают. Вот примеры этих операций для нашего случая.

Объединение множеств содержит все числа исходных множеств, при этом повторения (дубликаты) отбрасывают:

G = A + B = { 8, 7, 9, 3, 5, 2 } + { 5, 4, 6, 1, 2 } = { 8, 7, 9, 3, 5, 2, 4, 6, 1 }

Хотя числа 2 и 5 входили в оба исходных множества, в объединении они встречаются по разу.

Пересечение множеств содержит только числа, входящие в оба множества:

A * B = { 8, 7, 9, 3, 5, 2 } * { 5, 4, 6, 1, 2 } = { 5, 2 }

Разность множеств A–B содержит числа, состоящие в множестве A, но отсутствующие в множестве B:

A – B = { 8, 7, 9, 3, 5, 2 } – { 5, 4, 6, 1, 2 } = { 8, 7, 9, 3 }

Разность множеств B–A содержит числа, состоящие в множестве B, но отсутствующие в множестве A:

B – A = { 5, 4, 6, 1, 2 } – { 8, 7, 9, 3, 5, 2 } = { 4, 6, 1 }

Эти «вычисления» легко проверить по рис. 86.


Мощность множества, полные и неполные множества

Мощность множества – это наибольшее количество элементов, которое может содержаться в нём. В нашем числовом примере мощность множества равна девяти.

Множество, содержащее все возможные свои элементы, называют полным. В нашем случае полным является объединение множеств A+B.

Множество, содержащее не все возможные элементы, является неполным. Так, множества A и B по отдельности – неполные.

Все это рассказал нам математик. А что же Семен Семенович, или мы забыли о директоре? Нет, конечно, но к директорской задаче мы вернемся после ознакомления с «паскалевскими» множествами.


Итоги

• Множество – это совокупность различимых объектов (точек, чисел, предметов), которую мы воспринимаем как нечто целое. Отдельные объекты множества называют его элементами.

• К множествам применим ряд операций: объединение, пересечение, вычитание, сравнение.

• Объединение двух множеств содержит по одному элементу из каждого исходного множества.

• Пересечение двух множеств содержит только общие их элементы. Если таких элементов нет, пересечение будет пустым.

• Разность множеств содержит элементы уменьшаемого множества за исключением элементов вычитаемого множества.

• Первое множество является подмножеством второго, если все элементы первого принадлежат второму. И тогда второе множество будет надмножеством первого. Множества совпадают, если содержат одни и те же элементы.


А слабо?

А) Полицейская база данных некоторого государства содержит номера всех автомобилей, сгруппированные в ряд множеств. Три множества составлены по типам автомобилей: легковые, грузовые, автобусы. Шесть множеств образованы по цвету автомобилей: множества белых, черных, желтых, красных, синих и зеленых.

• Пересекается ли множество легковых автомобилей с множеством грузовых? А множество желтых автомобилей с множеством черных?

• Может ли быть непустым пересечение множества желтых автомобилей с множеством автобусов?

• Свидетель дорожно-транспортного происшествия сообщил, что с места преступления скрылся грузовой автомобиль синего цвета. Как вычислить группу подозреваемых автомобилей?

• На улице висит знак: грузовым проезд запрещен. Как определить множество автомобилей, въезд которым разрешен?

Б) Два государства, назовем их A и B, спорят о некой территории, – каждое считает ее своей. Нарисуйте на листочке предполагаемую карту, заштрихуйте спорную область, а затем объясните:

• Как вычислить спорную область государств?

• Как вычислить бесспорную область, включая оба государства?

• Заштрихуйте область, отвечающую формуле G = (A-B) + (B-A).

• Заштрихуйте область, отвечающую формуле G = A+B – A•B. Совпадает ли она с той, что вычислена по предыдущей формуле?

В) Дайте ответы на следующие вопросы.

• Является ли множество ваших одноклассников подмножеством учеников вашей школы?

• Пересекается ли множество ваших друзей с множеством ваших одноклассников?

• Является ли множество ваших друзей подмножеством ваших одноклассников?

Глава 36

Множества в Паскале

 Сделать закладку на этом месте книги




Зная силу математических множеств, Никлаус Вирт – «отец» языка Паскаль – ввел в язык тип данных множество и предусмотрел операции с ним.

Элементами множеств здесь могут быть числа, символы и булевы данные – то есть порядковые типы данных размером в один байт. Стало быть, мощность множеств в Паскале не превышает 256.


Объявление множеств

Множества объявляются конструкцией вида

SET OF <диапазон или тип>

Вот примеры объявления переменных типа множество.


      { объявление множества } { возможные элементы множества }

var SN1 : set of 10..100;       { числа от 10 до 100 }

      SN2 : set of byte;       { числа от 0 до 255 }

      SC1 : set of ’a’..’z’;       { только малые латинские буквы }

      SC2 : set of Char;       { все символы }


Поскольку мощность множеств в Паскале не превышает 256, множества SET OF BYTE и SET OF CHAR представляют множества предельной мощности.


Присвоение значений множествам

Переменным типа множество присваивают значения выражений того же типа, вот примеры таких операторов.


      SN1:= [10, 20, 50];       { содержит три элемента }

      SN2:= [11..20, 51..60];       { содержит 20 элементов }

      SN2:= [0..255];       { содержит 256 элементов от 0 до 255 }

      SN2:= SN1;       { копия другого множества }

      SC1:= [’z’, ’y’, ’x’];       { содержит три элемента }

      SC2:= [’0’..’9’];       { содержит 10 элементов }


Как видите, для записи множеств в Паскале используют квадратные скобки, а не фигурные. Что позволено в записи множеств, и что запрещено?

Подряд идущие элементы можно заменять диапазоном с указанием крайних значений. Допустимо перечислять элементы в произвольном порядке и даже вставлять дубликаты, – они все равно будут отброшены. Вот примеры трех совершенно одинаковых по результату операторов.


SN1:= [5..8];       { множество задано диапазоном }

SN1:= [8, 7, 6, 5]; { то же множество, но в другом порядке }

SN1:= [5..8, 6, 6]; { трижды указано число 6, дубликаты будут отброшены }


Множеству любого типа можно присвоить пустое значение, например:


SB1:= []; SN1:= [];       SC1:= [];


Пустое множество изображается парой квадратных скобок, между которыми ничего нет. Нельзя считать пустым множество [0], поскольку оно содержит один элемент – число ноль.

Элементами множеств могут быть только значения переменных и выражений соответствующего типа.


var k, n : byte;       c: char;

      ...

      k:= 10; n:= 20;

      SN1:= [1..k, n+5];       { 1..10, 25 }

      c:= ’m’;

      SC1:= [c, ’a’, ’b’];       { ’m’, ’a’, ’b’ }


Компилятор не позволит включать в множество элементы, не относящиеся к нему, а также смешивать элементы разных типов, вот примеры таких ошибок.


SN1:= [5..200];       { в объявлении SN1 указан диапазон от 10 до 100 }

SC1:= [’a’, ’b’, 5]; { вместо символа ’5’ указано число 5 }



Операции с множествами

В Паскале предусмотрены три известные вам вычислительные операции с множествами, а также сравнение множеств и проверка на вхождение элемента в множество.

Вычислительные операции – объединение, пересечение и вычитание – записывают на Паскале так:


      SN2:= [3, 7] + [5, 2];       { объединение = [2, 3, 5, 7] }

      SN2:= [2..10] * [8..20]; { пересечение = [8, 9, 10] }

      SN2:= [2..10] – [8..20]; { разность = [2..7] }


Множества, объединенные знаками операций и круглыми скобками, образуют выражение, например:


      SN2:= (SN1 + [0..15]) * SN2;


Выражения, составленные из множеств, очень похожи на выражения из чисел, но вычисляются по другим правилам. Это обманчивое сходство может спровоцировать ошибку – смешение в одном выражении чисел и множеств. Предположим, вы хотите добавить к множеству число, содержащееся в переменной K. Следующее выражение будет неверным.


      SN1:= SN1 + K;  


убрать рекламу






     { сложение множества с числом – ошибка }


Правильно будет так:


      SN1:= SN1 + [ K ];       { добавляется множество из одного элемента }


Разумеется, за ошибками такого рода присматривает компилятор, проверьте его реакцию на практике.


Сравнение множеств

Множества можно сравнивать между собой, получая в результате булево значение – TRUE или FALSE.

Два множества равны, если содержат одни и те же элементы.


if SN1 = SN2       then … else …


Множества неравны, если одно из них содержит, хотя бы один элемент, которого нет в другом.


if SN1 <> [15, 17, 19] then … else …


Проверка на подмножество (<=) отвечает на вопрос: все ли элементы первого множества входят во второе?


if SN1 <= SN2 then … else …


Проверкой на надмножество (>=) выясняют, все ли элементы второго множества входят в первое.


if SN1 >= SN2 then … else …



Проверка на вхождение элемента в множество (операция IN)

Входит ли некоторый элемент в множество? Это можно выяснить так:


var N : byte; S : set of byte;

      ...

      if ([N] * S) <> [] then { N входит в S } else { не входит }


Понятно, что, если число N входит в множество S, то пересечение [N]*S не будет пустым. Но проще выяснить это операцией IN – она введена специально для этого. Операция дает TRUE, если значение перечислимого типа входит в данное множество, например:


      if N in S  then { N входит в S } else { не входит }

      if 20 in S  then { 20 входит в S } else { не входит }



Решение директорской задачи

Вернемся к временно покинутому директору Семену Семеновичу. Напомню стоящую перед нами задачу: есть текстовый файл, каждая строка которого содержит список номеров учеников, состоящих в некотором кружке.


2 11 4 13

9 17 12 11 3 5 18

14 2 13 15 20


Надо составить список нигде не числящихся разгильдяев.

Можно ли воспринимать эти списки как множества? Вероятно, да, судите сами:

• каждый список содержит номер ученика не более одного раза (ошибочные повторные записи все равно отбросят);

• порядок следования в списке не важен;

• список может быть пустым (если никто не записался в этот кружок).

Хорошо, а будет ли множеством список всех учеников школы? Конечно. Такое множество будет полным, поскольку содержит все возможные элементы. А раз так, директорскую задачку решим через множества.

Множество тех, кто записался хотя бы в один кружок, найдем объединением отдельных множеств-кружков (S1 + S2 + S3). Вычтя это объединение из полного множества учеников, получим множество уклонившихся. Вот и все решение! На Паскале это запишется так:


var R, S1, S2, S3 : set of 1..250;

begin

      S1:= [ 2, 11, 4, 13 ];       { 1-й кружок }

      S2:= [ 9, 17, 12, 11, 3, 5, 18 ]; { 2-й кружок }

      S3:= [ 14, 2, 13, 15, 20 ];       { 3-й кружок }

      R:= [1..250] – (S1 + S2 + S3) ; { R – множество уклонившихся }

end.


Выделеное выражение в скобках – это множество учеников, состоящих хотя бы в одном кружке. Итак, решение задачи вместилось в одну строчку! Нет, не зря мы терпели математика и корпели над множествами!

Показанное выше решение – это работающая программа, которую можно запустить в пошаговом режиме, и через отладчик увидеть результат. Сделайте это. А как быть с вводом и выводом множеств? Ведь исходные данные хранятся в файле, а результат – переменную R – тоже надо вывести в файл или на экран. Вот этим мы и займемся в следующей главе.


Итоги

• Множества – это инструмент, взятый в Паскаль из математики.

• В Паскале применяют конечные множества, элементами которых могут быть числа, символы и булевы значения. Мощность множеств в Паскале не превышает 256.

• В Паскале предусмотрен ряд операций с множествами: объединение, пересечение, вычитание, сравнение, а также проверка на вхождение элемента в множество.

• Сравнение двух множеств дает булев результат, который используют в условных и циклических операторах.

• Операция IN – удобное средство для проверки вхождения одного элемента в множество, она тоже дает булев результат.


А слабо?

А) Найдите ошибки в следующих операторах.


type TNumbers = set of 1..300;

      TChars = set of char;

      TBytes = set of byte;


var c1, c2 : TChars;

      b1, b2 : TBytes;

begin

      c1:= [1..9];

      c2:= ['1'..'9'];

      c2:= c2 + ’0’;

      c2:= c2 + [0];

      b1:= c1;

      b2:= b1 + [1,7,3];

      Writeln(b1=b2);

      Writeln(1 in b2);

      Writeln([1] in b2);

      Writeln(b1 in b2);

end.


Б) Напечатайте 20 случайных чисел в диапазоне от 1 до 50 так, чтобы каждое число встретилось в распечатке лишь по разу. Подсказка: после генерации числа функцией Random проверьте его на вхождение в множество уже напечатанных чисел.

В) Введите программу решения директорской задачи (см. предыдущую страницу), а затем запустите её в пошаговом режиме (клавишей F7). Перед запуском вставьте все переменные в окно обзора переменных «Watch» и проследите за их изменением. Напомню, что о средствах отладки рассказано в главе 21.

Глава 37

Ввод и вывод множеств

 Сделать закладку на этом месте книги




Мы узнали о множествах и приспособили их к директорской задаче. Чтобы покончить с нею доделаем ещё пару пустяков: организуем ввод и вывод множеств. Для ввода-вывода строк и простых типов данных годятся процедуры Read[ln] и Write[ln]. Но сейчас все не так просто, – эти процедуры не способны работать, ни с множествами, ни с другими сложными типами данных. Однако ж «нормальные герои всегда идут в обход», – пойдем так и на этот раз.


Вывод множества в текстовый файл

Начнем с вывода числового множества на экран (или в файл, – что одно и то же). Так мы получим средство для последующей проверки вводимых множеств.

Раз уж процедура Writeln не печатает множество одним махом, выведем каждый его элемент по отдельности – ведь это обычные числа или символы. Проверяя все возможные элементы множества, будем печатать лишь те, что входят в него – в этом основная идея. Напомню, что для такой проверки подходит операция IN. Дополнив её циклом со счетчиком, соорудим несложную процедуру распечатки числового множества. Вот она вместе с программой для её проверки.


{ P_37_1 – вывод множества в файл }


type TSet = set of 1..255;       { объявление типа «множество» }


      {----- Процедура вывода множества в файл -----}

procedure WriteSet(var aFile: text; const aSet : TSet);

var k : integer;

begin

      for k:=1 to 255 do       { цикл по всем элементам множества}

      if k in aSet       { если K входит в множество }

      then Write(aFile, k:4);       { печатаем в строке }

      Writeln(aFile); { по окончании – переход на следующую строку }

end;

      {----- Программа для проверки процедуры WriteSet -----}

var S1 : TSet;       F: text;

begin

      Assign(F, '') ; Rewrite(F); { связываем файл с экраном! }

      S1:= [3, 10, 25];       { значение множества }

      WriteSet(F, S1);             { печатаем }

      Readln;

      Close(F);

end.


В первой строке объявлен тип данных TSet, он может содержать целые числа от 1 до 255. Процедура распечатки WriteSet принимает по ссылке два параметра: файловую переменную и множество, которое надо распечатать. Внутри процедуры работает цикл FOR, перебирающий все возможные элементы множества. Те из них, что содержатся в нём, печатаются в текущей строке. По завершении цикла оператор Writeln переводит позицию записи на следующую строку файла.

Обратите внимание: множество передано в процедуру по ссылке CONST. Передача в процедуры множеств, строк и других сложных типов данных по ссылкам CONST и VAR — это обычная практика. Так повышается скорость работы программ и уменьшается объём памяти, занимаемый параметрами.

Теперь взгляните на оператор Assign(F,''), который назначает файловой переменной пустое имя файла. Так файловая переменная связывается с экраном дисплея (при выводе данных), либо с клавиатурой (при вводе). А когда вам потребуется вывести результаты в дисковый файл, достаточно будет задать нужное имя файла, не меняя процедуры WriteSet (этот прием – подстановка пустого имени – не работает в Pascal ABCNet).

Примечание.  В современные версии Паскаля (Delphi) для обработки множеств введён вариант цикла FOR-IN-DO. С ним распечатка множества станет ещё проще:


      for k in aSet do Write(aFile, k:4);



Ввод множества из текстового файла.

Разобравшись с распечаткой множества, перейдем к вводу его из файла. Есть соображения на этот счет? Здесь пригодится опыт чтения чисел из строки текстового файла, – вспомните обработку классного журнала. Добавить число к множеству мы тоже умеем: для этого надо объединить его с множеством, состоящим из добавляемого числа. На этих идеях построена процедура ввода, показанная ниже вместе с тестирующей её программой.


{ P_37_2 – ввод и вывод числового множества }

type TSet = set of 1..255; { объявление типа «множество» }

      {----- Процедура чтения множества из файла -----}

procedure ReadSet(var aFile: text; var aSet : TSet);

var k : integer;

begin

aSet:= [];

      While not Eoln(aFile) do begin { пока не конец строки }

      Read(aFile, K);       { читаем очередное число }

      aSet:= aSet+[K];        { и добавляем к множеству }

      end;      

      Readln (aFile);       { переход на следующую строку }

end;

      {----- Процедура распечатки множества в файл -----}

procedure WriteSet(var aFile: text; const aSet : TSet);

var k : integer;

begin

      for k:=1 to 255 do       { цикл по всем элементам множества}

      if k in aSet       { если входит в множество }

      then Write(aFile, k:4); { печатаем в строке }

      Writeln(aFile);       { по окончании переход на следующую строку }

end;


      {----- Программа для проверки процедуры ввода -----}

var S1 : TSet;       F, D: text;

begin

      Assign(F, ''); Rewrite(F); { вывод на экран }

      Assign(D, '') ; Reset(D); { ввод с клавиатуры }

      S1:= [] ;       { перед вводом опустошаем множество }

      ReadSet(D, S1);       { вводим множество из файла }

      WriteSet(F, S1); Readln; { распечатаем для проверки }

      Close(F); Close(D);

end.


Полагаю, что комментарии поясняют все. Обязательно проверьте работу этой программы. Учтите, что вводить данные вы будете с клавиатуры: напечатайте в одной строке несколько чисел, разделяя их пробелами, а затем нажмите клавишу Enter.


Директорская задача, первый вариант

Освоив ввод и вывод множеств, мы вплотную подошли к полному решению директорской задачи. Напомню, что суть решения заключается всего в одном операторе.


      R:= [1..250] – (S1 + S2 + S3);


Теперь добавим ввод и вывод множеств. Чтобы не занимать место повторами показанных ранее процедур, я представлю решение в целом.


{ P_37_3 – решение директорской задачи, вариант 1 }


const CMax = 20;       { мощность множества, реально 250 }

type TSet = set of 1..CMax; { объявление типа «множество» }


procedure WriteSet(var aFile: text; const aSet : TSet);

{ взять из P_37_2 }


procedure ReadSet(var aFile: text; var aSet : TSet);

{ взять из P_37_2 }


var R, S1, S2, S3 : TSet;

      FileIn, FileOut: text;


begin {----- Главная программа -----}

      { Открытие входного файла }

      Assign(FileIn, 'P_37_3.in'); Reset(FileIn);

      { Создание выходного файла }

      Assign(FileOut, 'P_37_3.out'); Rewrite(FileOut);

      { Ввод множеств из входного файла }

      S1:=[]; ReadSet(FileIn, S1);

      S2:=[]; ReadSet(FileIn, S2);

      S3:=[]; ReadSet(FileIn, S3);

      R:= [1..CMax] – (S1+S2+S3); { Решение }

      WriteSet(FileOut, R);       { Вывод решения в выходной файл }

      Close(FileIn); Close(FileOut);

end.


Для ввода и вывода множеств используем дисковые файлы, поэтому оператор Readln в конце программы не нужен. Для облегчения проверки я уменьшил число учеников – константу CMax – с 250 до 20. При тестировании программы входной файл содержал следующие строки.


2 11 4 13

9 17 12 11 3 5 18

14 2 13 15 20


А в выходной файл попали следующие числа.


1 6 7 8 10 16 19


Легко убедиться в том, что никто из этих учеников не состоит в кружках.


Директорская задача, второй вариант

Итак, задача решена, но директор не вполне доволен. Сейчас возможности программы ограничены тремя кружками и двадцатью учениками. При изменении этих данных надо менять и программу, – мы избавимся от этого недостатка.

Во-первых, слегка изменим входной файл. Пусть первая его строка содержит количество учеников в школе; и тогда файл станет таким.


20

2 11 4 13

9 17 12 11 3 5 18

14 2 13 15 20


Во-вторых, отведем для участников кружков не три, а лишь одну переменную типа множество. Затем, по мере чтения строк файла, будем накапливать в этой переменной всех, кто состоит в кружках. Цикл чтения завершится по достижении конца входного файла. Вот и все изменения, посмотрите на второй вариант (процедуры ввода и вывода множеств только обозначены).


{ P_37_4 – решение директорской задачи, вариант 2 }


type TSet = set of byte; { объявление типа «множество» }


{ Здесь надо поместить процедуры ввода и вывода множеств }

procedure WriteSet(var aFile: text; const aSet : TSet);

{ взять из P_37_2 }


procedure ReadSet(var aFile: text; var aSet : TSet);

{ взять из P_37_2 }

var R, S : TSet;

      FileIn, FileOut: text;

      N: integer ; { общее число учеников }

begin

      Assign(FileIn, ' P_37_4.in'); Reset(FileIn);

      Assign(FileOut, ' P_37_4,out'); Rewrite(FileOut);

      Readln(FileIn, N) ;       { читаем общее число учеников }

      S:= []; { очищаем перед вводом }

      { пока не конец файла, объединяем участников всех кружков }

      while not Eof (FileIn) do ReadSet(FileIn, S);

      R:= [1..N] – S ;       { Решение }

      WriteSet(FileOut, R);

      Close(FileIn); Close(FileOut);

end.


Согласитесь, программа стала и гибче, и проще. Однако к первому её варианту мы ещё вернемся.


Итоги

• Стандартные процедуры ввода и вывода не способны вводить и выводить множества, для этого создают специальные процедуры.

• Вывод (распечатка) множества выполняется циклом со счетчиком, внутри которого проверяется вхождение каждого элемента в множество.

• Ввод множества из текстового файла основан на операции объединения по отдельности прочитанных элементов.


А слабо?

А) Напишите процедуры для ввода и вывода множества символов. Можно ли здесь для счетчика цикла применить символьную переменную?

Б) Напишите функцию, принимающую числовое множество и возвращающую количество содержащихся в нём элементов.

В) На основе первого варианта директорской программы придумайте способ поиска учеников, записавшихся более чем в один кружок. Или слабо?

Г) Напишите две функции, принимающие строку и возвращающие:

• строку, в которой символы исходной строки встречаются лишь по разу и следуют в алфавитном порядке, например «PASCAL» –> «ACLPS»;

• то же, но порядок следования символов такой же, как в исходной строке, например «PASCAL» –> «PASCL».

Глава 38

Множества в «бою»

 Сделать закладку на этом месте книги




Множества, множества… – заполучив столь острое оружие, удержимся ли не пустить его в ход? Вот ещё несколько задач, – мы изрубим их в капусту!


Активисты, шаг вперед!

Прежде всего, отдадим долги Семену Семеновичу. Мы обещали директору выявить разгильдяев, что отлынивают от кружков, и сдержали слово. Теперь найдем активистов, состоящих в нескольких кружках. Откуда подступиться к этой задаче?

Положим для простоты, что в школе лишь три кружка, их списки представлены множествами S1, S2 и S3. Выявить тех, кто состоит одновременно в кружках S1 и S2 легко, – достаточно найти пересечение S1*S2. Точно так же поступим с другими парами: S1 и S3, S2 и S3. Объединив все три пересечения, мы выявим интересующих нас школяров. Итак, решение задачи выразится формулой.


      R := S1*S2 + S1*S3 + S2*S3;


Попадут ли в это множество ученики, состоящие во всех трех кружках? Если да, то, как их отделить от прочих? Придумайте, как выявить тех, кто состоит:

• в трех кружках:

• в двух кружках и не более;

• только в одном из кружков.

Надеюсь, что с этим проектом, назовем его «P_38_1», вы справитесь сами, желаю успеха!


Подвиг контрразведчика

Контрразведка некоторого государства обнаружила утечку информации из лабораторий секретного учреждения. Для поимки шпиона позвали сыщика Шерлока Ивановича Холмского. Первым делом, он попросил списки сотрудников лабораторий. Лаборатории именовались латинскими буквами: «A», «B», «C» и так далее, причем некоторые сотрудники допускались в несколько лабораторий. Шерлок Иванович оцифровал списки, заменив фамилии сотрудников их табельными номерами, то есть, уникальными числами. Затем сгруппировал эти числа по лабораториям и составил табл. 6.

Табл. 6 – Исходные данные для «вычисления» завербованного сотрудника

Лабо–ратория Номера сотрудников, допущенных в лабораторию
A 1 2 4 5 9 11 13 15 22 23 24 25 27 30 31 37 41 42 43 44 45 46 48 50 51 56 64 70 72 73 74 75 76 77 82 84 86 87 89 92 95 97 98 101 102 103 104 105 106 107 108 111 113 116 117 118 124 125 127 130 132 133 134 138 143 144 145 147 149 150
B 16 21 22 23 24 25 26 27 28 29 31 33 35 37 39 41 44 47 49 50 51 52 54 55 56 57 59 61 62 65 66 69 70 71 72 77 78 79 81 83 84 85 91 92 93 94 95 96 98 100 101 103 107 108 109 112 113 115 117 118 119 121 122 124 129
C 1 3 5 9 12 19 22 25 33 34 41 42 46 50 52 55 56 57 58 59 61 66 69 72 80 81 82 84 87 88 94 97 99 100 101 102 112 119 121 123 125 129 134 137 138 139 149 152 153 154 155 157 158 165 166 168 171 172 180 184 185 190 193 194 198 199 205 213 216 220
D 5 6 7 8 9 10 11 12 13 14 16 18 21 22 23 24 27 28 29 30 31 32 34 35 38 40 41 42 43 44 45 46 47 48 51 52 53 54 55 57 58 59 60 61 62 63 64 65 66 67 70 71 73 74 75 76 78 79 80 81 82 84 85 86 88 89 91 92 93 94 95 96 97 98 99 100 104 105 106 107 108 111 112 113 115 116 117 118 119 120
E 10 15 16 26 33 40 42 44 50 53 65 67 74 79 82 83 85 87 90 91 93 99 106 108 110 120 121 124 125 132 135 146 148 149 151 156 157 158 163 166 168 169 171 175 183 184 189 195 197 205 206 207 216 220 221 225 226 227 241 244
F 8 12 21 25 26 29 30 31 34 48 49 50 52 55 59 60 62 70 71 73 83 85 90 91 92 93 94 96 97 99 100 102 103 104 105 106 108 119 121 122 124 127 128 130 132 141 142 144 156 160 165 166 169 171 173 176 179 191 192 195 199 200 207 209 220 221 222 224 226 229 233 234 236 239 240
G 23 24 26 27 29 30 35 36 41 42 44 45 46 49 52 55 56 58 60 61 63 64 65 68 72 74 76 77 81 82 86 87 88 90 93 94 95 96 97 98 100 101 102 107 108 109 112 113 114 115 117 120 123 127 132 133 135 137 138 143 145 146 147 150 152 155 156 159 161 162 163 164 165 168 170 172 177 178 179 180
H 15 17 19 20 21 22 23 26 28 29 30 32 33 34 36 38 41 42 44 45 46 48 49 52 57 60 62 65 66 68 73 74 77 78 83 84 85 88 89 90 91 92 95 96 97 98 99 100 101 102 103 104 107 108 115 116 118 127 128 129 130 131 134 135 136 137 139 145 146 150 151 152 154 157 160 161 164 166 167 172 173 177 178 179 180 182 185 188 189 190 193 195 197 204 207

Дальнейшее разбирательство показало, что утечка секретов случалась только из лабораторий «A», «D», «G» и «H» (в таблице они выделены серым цветом). При этом секреты остальных лабораторий («B», «C», «E» и «F») остались нетронутыми. Это направило дедуктивную мысль в правильное русло.

«Очевидно, – рассуждал Шерлок Иванович, – шпионить может тот, кто допущен в «дырявые» лаборатории. Из этого круга исключим тех, кто работает в нетронутых лабораториях, иначе их секреты тоже стали бы известны». Рассудив так, Шерлок Иванович достал ноутбук, и через 30 минут агент был вычислен, – подозреваемым оказался сотрудник с номером 45. Установленная за ним слежка подтвердила подозрение, и шпион был задержан.

Слабо ли вам повторить подвиг контрразведчика? Воспроизведите программу, написанную Шерлоком Ивановичем, я подскажу вам только её первую строку.


{ P_38_2 – подвиг контрразведчика }



В тридевятом царстве

Это случилось на затерянном в океане материке, что носил на себе несколько царств-государств. Жители материка – те ещё скряги – тратили для названий своих стран всего по одной букве: «A», «B», «C» и так далее. И мы будем их так называть. Границами стран служили каналы, специально для того прорытые; каналы были пронумерованы. Некоторые страны выходили к океану, берега которого тоже были пронумерованы и служили границами.

Самым могущественным было царство «A». Однако, ввиду его обширности и частых политических перемен, тамошний государь никак не мог уяснить точные границы своей страны. Он толком не знал даже ближайших соседей, – сведения были самыми разноречивыми. Когда терпение монарха лопнуло, он повелел своим инженерам запустить спутник, который бы исследовал границы и внес ясность в этот вопрос.

Слово царя – закон, и вскоре спутник кружился на орбите. С высоты ясно наблюдались берега океана и каналы, составлявшие границы царств. Рис. 87 показывает то, что «увидел» спутник. Буквами обозначены названия стран, а числами – участки границ. В центре континента темным цветом выделено обширное царство «A». К нему примыкают несколько стран, отмеченные серым, – это его соседи. Страны, примыкающие к царству «A» уголками своих границ, соседями не считаются. Они и все прочие «не соседи» отмечены белым цветом, а вокруг – океан.

К сожалению, примитивная техника тех лет не смогла отправить на землю эту фотографию. Спутник передал лишь номера границ каждого государства в виде текстового файла, содержащего строчки чисел.






Рис.87 – Вид на материк из космоса

Выдернув из принтера ещё теплую распечатку файла, первый министр примчался во дворец, протянул листок монарху и покорно припал к подножию трона. Царь встрепенулся, стал разглядывать бумажку, вертеть её так и сяк, и даже на зуб попробовал. Наконец терпение государя иссякло: «Болван, – обратился он к министру, – покажи тут наших соседей. Что? Не можешь? Так проваливай с глаз долой!». И смятая распечатка угодила в лицо министра. «А ведь хотел, как лучше…» — стучало в башке убегающего премьера. «А получилось, как всегда!» — догнал его вопль взбешённого монарха.

Куда податься бедолаге? Разумеется, к самому умному, – к придворному программисту. «Выручай, браток, я тебе премию выпишу!». Инженеры, создавшие спутник, тоже не остались в стороне и растолковали программисту суть проблемы. Расправив скомканную царской рукой бумагу, Ник – так звали придворного программиста – увидел вот что.


29 21 30 31 32

17 18 19 29 28

3 4 5 20 19 18

6 7 22 21 20

8 9 25 24 23 22

10 11 26 30 23 24 25

12 13 15 27 26

14 1 2 17 16 15

16 28 32 31 27


Каждая строка этого файла, – объяснили инженеры, – перечисляет границы некоторого царства: первая строка – царства «A», вторая – царства «B» и так далее. Имена стран в файле не указаны, но подразумевается их алфавитный порядок. Надо составить список стран, которые соседствуют с нашей страной «A» – первой в этом списке.

Друзья, отложите книгу и попытайтесь решить эту интересную задачу. В случае успеха, я похлопочу за вас при дворе!

А пока вы раздумываете, я исполню свой долг перед историей и покажу решение заморского коллеги. Ник сразу понял, что имеет дело с двумя видами множеств: множеством границ, обозначенных числами, и множеством стран, обозначенных буквами (вы помните, что страны именовались буквами?). Парень смекнул, что две страны соседствуют тогда, когда пересечение множеств их границ не пусто (это значит, что у них есть общие границы). Дальше его мысли устремились так быстро, что пальцы едва успевали тыкать по клавишам. Вот плод его труда.


{ P_38_3 – поиск стран–соседей }


type TBoundSet = set of byte;       { множество границ }

      TStateSet = set of Char;       { множество стран }


      {––––– Распечатка множества стран (символов) –––––}

procedure WriteCharSet(var aFile: text; const aSet : TStateSet);

var c : char;

begin

      for c:='A' to 'Z' do if c in aSet then Write(aFile, c:2);

      Writeln(aFile);

end;

      {––––– Ввод множества границ (чисел) –––––}

procedure ReadSet(var aFile: text; var aSet : TBoundSet);

var k : integer;

begin

      While not Eoln(aFile) do begin

      Read(aFile, K); aSet:= aSet+[K];

      end;

      Readln (aFile);

end;


var FileIn, FileOut: text;

      R: TStateSet;       { множество соседей (результат) }

      SA, S : TBoundSet;       { границы царства «A» и прочих }

      State: char;       { буква с названием очередной страны }


begin       {––––– Главная программа –––––}

      Assign(FileIn, 'P_38_3.in'); Reset(FileIn);

      Assign(FileOut, ''); Rewrite(FileOut);

      R:= []; SA:=[]; State:='A'; { начнем с царства «A» }

      ReadSet(FileIn, SA); { из первой строки читаем границы для «A»}

      while not Eof (FileIn) do begin { цикл по странам }

      State:= Succ(State);       { буква следующей страны }

      S:=[]; ReadSet(FileIn, S); { читаем границы страны }

убрать рекламу






code>

      { если граничит с царством «A», добавляем к результату }

      if S*SA <> [] then R:= R + [State];

      end;

      WriteCharSet(FileOut, R); Readln; { вывод результата }

      Close(FileIn); Close(FileOut);

end.


Программа Ника вычислила, что царство «A» соседствует с царствами «B», «D», «F», «I». Со временем проверка на местности это подтвердила.

Царь щедро наградил программиста, но история на этом не закончилась. О великом научном успехе скоро знала и последняя собака на материке. Но больше других этот успех заинтересовал купцов, плативших пошлины при пересечении границ. Они явились к Нику с предложением, от которого тот не смог отказаться. Хотите продолжения сказки? – оно ждёт вас в главах 49, 57 и 58.


Решето Эратосфена

Древние греки не знали, что они древние. И компьютеров тоже не знали, зато дышали бодрящим морским воздухом, коротая досуг в философских и математических размышлениях. Греческий досуг оказался не таким уж пустым, – иные задачки, придуманные под ласковый шепот волн, не решены по сию пору! Одна из них – вычисление простых чисел.

Прежде всего, выясним, что это за числа? Простым называют число, которое делится без остатка лишь на само себя и единицу. Все прочие числа являются составными. Возьмем, к примеру, числа от 1 до 10 и выделим среди них составные.


1 2 3 4  5 6  7 8 9 10 


Здесь отмечены составные числа 4, 6, 8, 9 и 10, – они делятся без остатка либо на 2, либо на 3. Оставшиеся числа 1, 2, 3, 5 и 7 являются простыми.

Кто-то из греков задался вопросом: можно ли вычислить очередное простое число, если известны все предыдущие? Например, исходя из того, что числа 1, 2, 3 и 5 простые, определить следующее простое число (7). Как ни мудрили мудрецы, такой формулы или алгоритма пока не придумали! Но усилия в этом направлении породили целые отрасли математики, – вот такой полезный неуспех!

Размышлял над задачей и грек Эратосфен. Он тоже не решил её, однако нашел остроумный способ отсеивать простые числа, не превышающие некоторого числа N. Вот суть его идеи.

Положим, мы ищем простые числа не превышающие 20. Выпишем на морском песочке в ряд числа с 1 до 20. Первые два числа – 1 и 2 – простые, их не тронем, а среди остальных сотрем каждое второе, то есть 4, 6, 8 и так далее.

Затем находим первое нестертое число – это три. Сотрем каждое третье после тройки: 6, 9, 12, 15 и 18 (хотя часть из них уже стерта, лишний раз это сделать не повредит). Повторяя процедуру, находим следующее нестертое число – это пять. Стираем каждое пятое после пятерки: 10, 15, 20 (хотя все они уже стерты). Достигнув середины этого списка – числа 11, остановимся. Дальше двигаться нет смысла, поскольку на песке остались лишь простые числа.

Примечание.  Если говорить точнее, лучше остановиться на числе, которое составляет корень квадратный из числа N, в данном случае это 5. Но для упрощения задачи мы будем обрабатывать больше чисел – половину ряда.

Вот результат этой пляжной математики, где стираемые числа выделены, а стертые обозначены звездочками. Здесь хватило всего двух просевов.


1-й отсев чисел, кратных 2:

1 2 3 4 5 6 7 8 9 10  11 12  13 14  15 16  17 18  19 20 

2-й отсев чисел, кратных 3:

1 2 3 * 5 * 7 * 9 * 11 * 13 * 15  * 17 * 19 *

Результат – простые числа:

1 2 3 * 5 * 7 * * * 11 * 13 * * * 17 * 19 *


А если бы Эратосфен жил в наше время? Стал бы он царапать на песке? Конечно, нет, – на что ж тогда компьютеры? Программа «P_38_4» находит все простые числа, не превышающие 255, – роль песка исполняет множество чисел.


program P_38_4; { Решето Эратосфена }

var Simples : set of byte; { множество чисел }

n, m : integer;

F : text;

begin

Assign(F, 'P_38_4.out'); Rewrite(F);

Simples:= [2..255]; { Сначала множество полное }

{ Цикл вычеркивания составных чисел }

for n:=2 to (255 div 2) do begin

      { если число ещё не вычеркнуто }

      if n in Simples then

      { проверяем на кратность ему все последующие }

      for m:=2*n to 255 do

      { если остаток(m/n) равен нулю, то m – составное }

      if (m mod n)=0

      { и его надо вычеркнуть из множества}

      then Simples:= Simples – [m];

end;

{ Распечатка множества простых чисел }

for n:=2 to 255 do if n in Simples then Writeln(F,n);

Close(F); Readln;

end.



Мелочь, а приятно

Одну из первых своих программ мы снабдили разумом попугая, научив повторять имя пользователя. После ввода имени в переменную S программа печатала.


      Writeln (’Здравствуй, ’+ S);


Сделаем её чуть умнее, научив отличать мальчиков от девочек. По крайней мере, для русских имен. Русские женские имена оканчиваются на буквы «а» или «я» (Анна, Светлана, Мария и так далее), чего не скажешь о мужских. Последнюю букву имени можно «выдернуть» в символьную переменную C таким оператором.


      C:= S[Length(S)];


И теперь приветствовать пользователя можно так:


      if (C=’А’) or (C=’а’) or (C=’Я’) or (C=’я’)

      then Writeln (’Здравствуй, девочка ’+ S)

      else Writeln (’Здравствуй, мальчик ’+ S);


Здесь проверяется совпадение переменной C с буквами верхнего и нижнего регистров, поскольку нельзя предсказать, в каком регистре будет введено имя. Условный оператор выглядит громоздко, но, призвав на помощь множество, мы упростим его.


      if C in [’А’, ’а’, ’Я’, ’я’]

      then Writeln (’Здравствуй, девочка ’+ S)

      else Writeln (’Здравствуй, мальчик ’+ S);


Переменную C проверяем на попадание в множество символов. Согласитесь, этот вариант читается приятней.


Итоги

Если вовремя смекнуть, что имеете дело с множествами, сложные задачи, как по волшебству, превратятся в простые!


А слабо?

А) Напишите программу для решения директорских задач и повторите подвиг контрразведчика. Или слабо?

Б) На острове действовали забавные законы по части транспортных средств – автобусов, грузовиков и легковушек. Во-первых, общее количество автомобилей на острове не должно было превышать 256. Автомобилям назначались номера с 0 до 255, при этом соблюдались следующие правила.

Номера, делившиеся без остатка на 7, назначались автобусам. Те, что делились без остатка на 5, назначались грузовикам, а все прочие – легковушкам. Например, номера 35 и 70 (они делятся и на 7, и на 5) доставались автобусам, а не грузовикам.

Схожие правила применялись и к окраске автомобилей, а именно: если номер авто делился на 4, его красили красным, если на 3 – желтым, если на 2 – белым, а остальные автомобили красили черным.

• Сформируйте три множества по классам автомобилей – автобусы, грузовики и легковушки. Вычислите количество машин каждого класса (Ответ: 37, 44, 175).

• Сформируйте четыре множества по цвету автомобилей – красные, желтые, белые и черные. Определите количество машин каждого цвета (Ответ: 64, 64, 43, 85).

• Столица того государства – деревня Кокосовка – страдала от пробок. Для их устранения ввели ограничение на въезд транспорта. Так, в один из дней недели в столицу пускали только красные легковушки, белые грузовики и все автобусы. Найдите номера всех этих машин. Сколько всего автомобилей могло въехать в столицу в тот день?

В) Полицейская база островного государства содержала номера угнанных автомобилей – числа от 1 до 255. Это был текстовый файл такого, например, вида:


120 31 16 25


То есть, номера перечислялись через пробел и следовали в произвольном порядке, что неудобно при поиске вручную. Ваша программа должна создать файл с номерами, упорядоченными по возрастанию. Подсказка: примените множество чисел.

Г) Генерация пароля длиной не менее восьми символов. В пароль входят символы трёх сортов: цифры, маленькие и большие латинские буквы, например: «7UpJ7rsT», «PasCal701». Сделайте четыре варианта так, чтобы соблюдались следующие условия:

• символ каждого сорта входит в пароль не менее двух раз, некоторые символы могут повторяться;

• все символы пароля уникальны (примените множество);

• символы одного сорта не соседствуют, например: «Pa7sCaL5», уникальность символов не требуется;

• символы одного сорта не соседствуют и все символы уникальны.

Д) Напишите четыре булевы функции, проверяющие, является ли введенная пользователем строка правильно сформированным паролем согласно условиям предыдущей задачи.

Глава 39

Командная игра (массивы)

 Сделать закладку на этом месте книги




В чём сила компьютеров? В умении стремительно перемалывать огромные объёмы данных: сотни, тысячи, миллионы элементов! Под элементами данных мы разумеем числа, строки и тому подобное. Обратимся и мы к этой способности компьютера. Нет, с миллионом элементов погодим, начнем всего с нескольких: рассмотрим, к примеру, турнирную таблицу чемпионата.


Снежная лавина

Вот задача для болельщика: отсортировать команды в турнирной таблице чемпионата по убыванию набранных ими очков. Команд немного, всего 16. После каждого тура количество очков меняется, и таблица сортируется заново. Корпеть над этим вручную? – это не для нас! Итак, будущая программа должна принимать с клавиатуры очки, набранные командами, и распечатывать команды в порядке убывания этих чисел. При этом набранные очки мы будем вводить всегда в одном и том же порядке.

Сделаем это сначала для двух команд, пусть ими будут «Динамо» и «Спартак». Сортировка двух команд – что может быть проще?


{ ввод и сортировка двух команд (в программе 14 строк) }

var T1, T2 : integer;

begin

      Readln (T1, T2);       { Ввод очков для «Динамо» и «Спартак» }

      if T1>T2

      then begin

      Writeln('1.Динамо');

      Writeln('2.Спартак');

      end

      else begin

      Writeln('1.Спартак');

      Writeln('2.Динамо');

      end;

      Readln;

end.


Здесь для каждой из команд отведена переменная, хранящая набранные очки: T1 – для «Динамо» и T2 – для «Спартака». Вариантов расстановки всего два, поэтому и программа очень проста – всего 14 строк, не считая комментария.

Теперь добавим в чемпионат команду «Зенит». Вариантов расстановки стало втрое больше – шесть, и программа заметно усложнилась, вот она.


{ сортировка трех команд (в этой программе 45 строк) }

var T1, T2, T3 : integer;

begin

Readln (T1, T2, T3);       { «Динамо», «Спартак», «Зенит» }

if (T1>T2) and (T1>T3)

then begin

      Writeln('1.Динамо');

      if T2>T3

      then begin

      Writeln('2.Спартак');

      Writeln('3.Зенит');

      end

      else begin

      Writeln('2.Зенит');

      Writeln('3.Спартак');

      end

      end

else begin

      if (T2>T1) and (T2>T3)

      then begin

      Writeln('1.Спартак');

      if T1>T3

      then begin

      Writeln('2.Динамо');

      Writeln('3.Зенит');

      end

      else begin

      Writeln('2.Зенит');

      Writeln('3.Динамо');

      end

      end

      else begin

      Writeln('1.Зенит');

      if T1>T2

      then begin

      Writeln('2.Динамо');

      Writeln('3.Спартак');

      end

      else begin

      Writeln('2.Спартак');

      Writeln('3.Динамо');

      end

      end

      end;

Readln;

end.


Здесь уже 45 строк, что втрое больше, чем для двух команд. С добавлением последующих команд программа продолжит разбухать, как снежный ком. Для четырех команд она станет длиннее ещё в 4 раза (180 строк), для пяти – ещё в 5 раз (900 строк) и так далее. Дойдя до шестнадцати команд, мы насчитаем в программе триллионы строк. А ведь триллион – это «всего лишь» миллион миллионов! Скорей свернем с этой гибельной тропы, пока снежная лавина не накрыла нас с головой!


А где же волшебная палочка?

Вы ощущаете причину трудностей? В моих решениях нет циклов, способных выполнять огромное количество однообразных действий. Так, например, одним оператором цикла печатается хоть тысяча, хоть миллион чисел. Увы! Применить цикл к переменным с именами T1, T2 и T3 не получится. Хотя цифры в этих именах означают для нас порядковые номера команд, для компилятора они – всего лишь часть имени переменной, и не более. Как же втолковать компилятору то, чего мы добиваемся нумерацией переменных?

Для этого есть особый тип данных – массив переменных или, проще – массив. Вот она, спасительная волшебная палочка!


Массивы вокруг нас

Массив объединяет несколько однотипных переменных под одним общим именем. Отдельные переменные в массиве называют его элементами, и доступ к ним возможен по их номерам. Массивы придумали отнюдь не программисты. Возьмите любую спортивную команду – футбольную или хоккейную. Здесь, кроме фамилии, игрок снабжен номером, который лучше виден на поле. И это не единственный пример массива. Если отдельную переменную уподобить ящику с хранящейся в нём информацией, то массив переменных будет комодом с пронумерованными ящиками (рис. 88).






Рис.88 – Примеры простых переменных (слева) и массивов (справа)

Итак, массив – это собранные в одну команду переменные. Они получают общее на всех имя – имя своей команды. А внутри команды каждая переменная – элемент массива – обладает своим номером. Ну, чем не игроки?


Объявление массивов

Прежде, чем пользоваться массивом, его надо объявить: либо в секции VAR, либо через объявление пользовательского типа в секции TYPE.

Рассмотрим сначала первый способ, – объявим массив в секции VAR.


VAR Имя_Массива : ARRAY  [<MIN>..<MAX>] OF  <Тип элемента>


Здесь использована пара ключевых слов ARRAY… OF…, что переводится как «массив… из…». Имя массива – это обычный идентификатор, его программист придумывает сам; будем считать это имя названием команды переменных.

Справа, после двоеточия, указывают две характеристики массива: 1) диапазон для индексов и 2) тип элементов массива. Рассмотрим эти атрибуты массива подробней.

Диапазон для индексов определяет допустимые номера элементов внутри массива. Диапазон указывают в квадратных скобках после слова ARRAY, – это два выражения порядкового типа, условно обозначенные мною как MIN и MAX, они разделяются двумя точками. Говоря спортивным языком, здесь назначается диапазон номеров для «игроков команды».

После ключевого слова OF следует второй атрибут массива – тип данных для всех его элементов. Прибегнув вновь к спортивному языку, скажем, что здесь объявляют «вид спорта» для команды.

Вот пример объявления трех массивов: Names (фамилии), Ratings (оценки) и ChampShip (чемпионат).


VAR { объявления переменных-массивов }


      { 30 строковых переменных с фамилиями учеников класса }

      Names : ARRAY [1..30] OF string;


      { 30 байтовых переменных с оценками учеников этого класса }

      Ratings : ARRAY [1..30] OF byte;


      { 16 чисел с очками, набранными командами в чемпионате }

      ChampShip : ARRAY [1..16] OF integer;


Как видите, массив можно составить из элементов любого типа. Так, массив Names содержит внутри себя 30 переменных строкового типа: Names[1], Names[2] и так далее (номера переменных указывают в квадратных скобках).

Объявление массивов в секции VAR не слишком удобно. Почему? Рассмотрим следующий пример.


var A : array [1..5] of integer;

      B : array [1..5] of integer;

begin

      A:= B; { здесь компилятор видит ошибку несовместимости типов}

end.


Мы объявили массивы A и B; на первый взгляд, это массивы одного типа, поскольку каждый из них содержит по пять целых чисел. Для однотипных переменных, включая массивы, Паскаль допускает операцию копирования. Например, оператором


      A:=B


все элементы массива B копируются в элементы массива A. Увы, компилятор увидит здесь ошибку несовместимости типов. В чем дело? А в том, что он считает разнотипными массивы, объявленные в разных операторах. Даже если массивы совершенно одинаковы! Скажете, компилятор недостаточно умен? Может быть, но нам придётся как-то выкручиваться, и для этого есть два пути.

Во-первых, переменные A и B можно объявить в одном операторе.


var A, B : array [1..5] of integer;


Это устраняет проблему несовместимости типов.

Но есть и лучший способ – сначала объявить для массива пользовательский тип данных. Это делается в секции TYPE так:


TYPE Имя_Типа = ARRAY  [<MIN>..<MAX>] OF  <Тип элемента>


В сравнении с объявлением переменной разница мизерная: вместо двоеточия видим знак равенства, а вместо имени переменной – имя типа. Но каковы последствия! Объявите лишь однажды нужный вам тип, и тогда применяйте его, где угодно. Вот объявления типов для указанных выше переменных.


TYPE { примеры объявления типов-массивов }

      { тип для 30 строковых переменных с фамилиями учеников класса }

      TNames = ARRAY [1..30] OF string;


      { тип для 30 байтовых переменных с оценками учеников }

      TRatings = ARRAY [1..30] OF byte;


      { тип для 16 целых переменных с очками, набранными в чемпионате }

      TChampionShip = ARRAY [1..16] OF integer;


Здесь буква «T» в имени типа напоминает о назначении этого идентификатора (помните наше добровольное соглашение об именах?). Теперь учрежденные типы данных можно употребить для объявления переменных и параметров в любом месте программы, вот пример.


TYPE { тип для 30 байтовых переменных с оценками учеников }

      TRatings = ARRAY [1..30] OF byte;


VAR { 30 байтовых переменных с оценками учеников }

      Ratings : TRatings; 


procedure ABC (var arg: TRatings ); { параметр процедуры }

var A, B, C : TRatings ;       { локальные переменные }

begin

      ...

end;


Здесь тип TRatings служит для объявления переменных и параметров в трех местах программы. В будущем мы всегда будем объявлять типы – как для массивов, так и для других сложных наборов данных.


Доступ к элементам (индексация)

Переменной-массивом можно ворочать как единым целым, например, при копировании одного массива в другой. Но чаще приходится работать с отдельными его элементами, как «выдернуть» их из массива?

Очень просто: воспользуйтесь индексацией, – она знакома вам по работе со строками. Как и для доступа к отдельному символу строки, для доступа к элементу массива надо указать его индекс, то есть порядковый номер в массиве. Индекс указывают в квадратных скобках, стоящих после имени массива, он представляет собой выражение порядкового типа. Кстати, сходство со строками не случайно, ведь строка – это особый род массива, составленного из отдельных символов.

Рассмотрим примеры доступа к элементам объявленных выше массивов.

Пример 1. Трем элементам массива Names присваиваем фамилии хоккеистов.


      Names[1]:= ’Петров’;

      Names[2]:= ’Михайлов’;

      Names[3]:= ’Харламов’;


Пример 2. Сравниваем третий и четвертый элементы массива Ratings. Здесь индексы заданы через целочисленную переменную n.


      …

      Ratings[3]:= 12;

      Ratings[4]:= 8;

      n:=3;

      if Ratings[n] > Ratings [n+1] then … else …;


Как видите, индекс в массиве можно вычислять, а это открывает дорогу к циклам. И мы двинемся ею немедленно!


Ввод и вывод массивов

Ввод и вывод – это те задачи, не решив которые, не стоит помышлять о применении массивов. Ни то, ни другое не сделать одним махом. Здесь, как и для множеств, нужны циклы, обрабатывающие отдельные элементы массива.

Взять, к примеру, массив Names, ввести который можно так:


      for i:=1 to 30 do Readln(F, Names[i]);


Здесь F – это открытый для чтения текстовый файл, каждая строка которого содержит фамилию.

На первый взгляд все просто. Просто, да не гладко, – это будет работать лишь с файлом, в котором не менее 30 строк (по числу циклов). А иначе случится ошибка: противозаконное чтение за пределами файла. Как избежать её? Внимательней присматривайте за концом файла, вот так:


      i:=1;

      { пока не конец файла и не введены все элементы }

      while not Eof(F) and (i<=30) do begin

      Readln(F, Names[i]);

      i:= i+1;

      end;


А вот ещё один хороший вариант.


      for i:=1 to 30 do begin

      if Eof(F) then break; { если конец файла, прервать цикл }

      Readln(F, Names[i]);

      end;


Вывод массива в файл не представляет труда, вот пример.


      for i:=1 to 30 do Writeln(F, Names[i]);


Разумеется, что файловая переменная F должна быть открыта для записи.


Ошибки индексации

Объявление массива, как сказано, содержит границы для индексов: MIN – номер первого элемента, и MAX – номер последнего. А что случится при попытке обратиться к элементу с меньшим, чем MIN номером? Или наоборот – с большим, чем MAX? Иначе говоря, что случится при попытке доступа к несуществующему элементу массива? Такие ошибки преследуют даже опытных программистов, а последствия зависят от способа, которым вы совершите сей проступок.

Предположим, в программу вкрался такой оператор:


      Names[200]:= ’Синичкин’;


Поскольку в массиве Names нет элемента с индексом 200, здесь вас остановит компилятор, – ошибка слишком явна, чтобы он промолчал. Вам не останется ничего иного, как исправить индекс, иначе программа не откомпилируется.

Но, когда индекс вычисляется при исполнении программы, нарушение границ проявляется и обрабатывается иначе, например:


      Readln(N);

      Writeln(Names[N]);


Нам не угадать, что введет пользователь в переменную N, – здесь ошибка нарушения границ может возникнуть при выполнении программы. В главе 27 мы рассматривали ошибки времени исполнения, – это как раз такой случай. Если указать индекс, выходящий за границы массива, то реакция программы будет зависеть от настройки компилятора, точнее, от опции контроля диапазонов. Напомню, что эта опция управляется директивой $R, а также доступна через меню по цепочке:

Options –> Compiler… –> Runtime Errors –> Range checking

Рассмотрим вариант компиляции при включенном контроле границ ($R+). Тогда, при нарушении границ индекса, программа выдаст аварийное сообщение «Range check error». То есть, она заметила нарушение границ индекса, «крикнула» об этом и прервала работу.

Теперь отключим контроль диапазонов ($R-) и перекомпилируем программу. Она станет «легче» и быстрее, и по ходу выполнения проверять границы не станет. Но ошибки не пройдут бесследно. Наоборот, последствия будут тяжелыми и непредсказуемыми! Отключать проверку диапазонов позволительно только в тщательно проверенной программе.

Лучший способ избежать нарушения границ индексов – взять проверку на себя. В данном случае это можно сделать так:


      repeat

      Readln(N);

      if N in [1..30]

      then Writeln(Names[N])

      else Writeln(’Ошибка! Введите индекс от 1 до 30’);

      until N in [1..30]


Этот цикл будет терзать пользователя, пока тот не введет допустимое значение индекса, или не выключит компьютер.


Итоги

• Массив – это сложный тип данных, объединяющий в себе несколько однотипных переменных – элементов массива.

• Все элементы массива носят одно общее имя – это имя самого массива. Внутри массива элементы различаются своими порядковыми номерами – индексами.

• В объявлении массива указывают две его характеристики: диапазон индексов и тип элементов.

• Индекс элемента может быть задан числом или выражением порядкового типа.

• Указание неверного индекса порождает ошибки либо при компиляции, либо при выполнении программы.

• Ввод массива из текстового файла и вывод в него возможен только поэлементно, для чего организуют цикл.


А слабо?

А) Массив A и переменная C объявлены так:


var A : array [’a’..’z’] of integer;

      C: char;


Допустимо ли такое объявление массива и почему? Сколько элементов содержит массив? Какие из указанных ниже операторов будут (или могут) вызывать ошибки нарушения диапазонов?


      A[’s’]:= 10;

      A[’R’]:= 10;

      C:=’d’; A[C]:= 10;

      Readln(C); A[C]:= 10;


Проверьте свои решения на практике.

Глава 40

Пристрелка на знакомых мишенях

 Сделать закладку на этом месте книги




Итак, из арсенала Паскаля мы извлекли ещё одно мощное оружие – массивы. Опробуем его на знакомых мишенях, – некоторые наши программы можно улучшить, например, программу «вопрос-ответ» или полицейскую базу данных.


Вопрос-ответ – добиваемся гибкости

В 16-й главе мы смастерили шуточную программку, невпопад отвечающую на вопросы пользователей. Жаль только, что ответы намертво вбиты в саму программу. Скоро пользователям надоест смеяться над одним и тем же, и они забросят игрушку. Так пусть ваши приятели сами сочиняют смешные ответы и помещают их в текстовый файл, и тогда программа при запуске будет загружать их оттуда.

Прежде всего, подумаем над размещением вводимых из файла строк, где поселить их? «В массиве строк», – скажете, и будете правы. А сколько элементов запасти в этом массиве? Чем больше, тем лучше? Некоторые компиляторы накладывают ограничение на размер массива, но сотню строк они позволят, и этого пока достаточно. Итак, для хранения ответов объявим массив из 100 строковых переменных.

Перейдем к процедуре ввода этих строк. Техника ввода массива рассмотрена в предыдущей главе. Но теперь надо ещё и подсчитать введенные строки, иначе в дальнейшем мы не всегда сможем правильно индексировать массив, — ведь фактическое количество строк в файле может быть и меньше ста. С этой целью объявим переменную Fact, в которой и сделаем нужный нам подсчёт.

Обсудив эти моменты, обратимся к программе «P_40_1».


{ P_40_1 – Программа "вопрос-о


убрать рекламу






твет" с применением массива }


const CAnswers = 100; { размер массива с ответами }

      { объявление типа для массива ответов }

type TAnswers = array[1..CAnswers] of string;


var Answers : TAnswers; { объявление массива ответов }

      Fact : integer;       { фактическое количество ответов }

      F : text;       { файл с ответами }

      S : string;       { строка с вопросом }

{ Процедура ввода ответов из файла с подсчетом введенных строк }

procedure ReadFromFile(var aFile: text);

var i: integer;

begin

Fact:=0; { для начала подсчета строк обнуляем счетчик }

{ цикл по массиву строк }

for i:=1 to CAnswers do begin

      if Eof(aFile) then Break; { если конец файла – выход}

      Readln(aFile, Answers[i]); { читаем строку в элемент массива }

      Fact:= Fact+1;       { наращиваем счетчик строк }

end;

end;


begin {--- Главная программа ---}

      Assign(F, 'P_40_1.in'); Reset(F);

      ReadFromFile(F);

      Close(F);

      Randomize; { чтобы порядок вопросов не повторялся }

      { Начало главного цикла }

      repeat

      Write('Введите вопрос: '); Readln(S);

      if S<>'' then Writeln(Answers[Random(Fact)+1] );

      until S='';

end.


Открыв файл ответов «P_40_1.IN», мы вызываем процедуру ReadFromFile (читать из файла), которая загружает строки в массив Answers (ответы). Она же подсчитывает введенные строки в переменной Fact. Таким образом, если файл содержит больше сотни строк, то в массив попадёт первая сотня, а иначе — столько, сколько там есть фактически, и это количество покажет переменная Fact. Дальше всё работает, как в прежнем варианте: после ввода вопроса ответ случайным образом выбирается из массива. Индекс элемента с ответом определяется выражением Random(Fact)+1. Если помните, функция Random(Fact) возвращает значения в диапазоне от 0 до Fact-1, а индексы нашего массива начинаются с единицы.


Полицейская база данных – ускоряем поиск

А теперь освежите в памяти другое наше творение – программу поиска угнанных автомобилей в полицейской базе данных (глава 29). Её слабость в том, что поиск номеров выполняется в текстовом файле. Ах, если б вы знали, как «тормозит» такой поиск! Вы не заметили? Да, на десятках строк этого не ощутить, иное дело – сотни тысяч, или миллионы. Итак, перенесем список номеров из текстового файла в массив, и тогда поиск ускорится многократно!

В программе «P_40_2» обратите внимание на пропуск пустых строк в процедуре ReadFromFile. Если этого не сделать, счётчик Fact может оказаться на 1 больше, чем должно, – так случится, если за последним числом будут пустые строки. Следующий далее оператор чтения числа пренебрегает границами между строками, поэтому в одной строке допустимы несколько чисел.


{ P_40_2 – Полицейская база данных с применением массива }


const CNumbers = 1000; { размер массива с номерами автомобилей }

      { объявление типа для массива номеров }

type TNumbers = array[1..CNumbers] of integer;

var Numbers : TNumbers; { объявление массива номеров }

      Fact : integer;       { фактическое количество номеров в файле }

      F : text;       { файл с номерами }

      Num : integer;       { номер проверяемого автомобиля }


      { Процедура ввода номеров из файла }

procedure ReadFromFile(var aFile: text);

var i: integer;

begin

Fact:=0; { для начала подсчета номеров обнуляем счетчик }

for i:=1 to CNumbers do begin { цикл по массиву номеров }

while Eoln(aFile) do  { Пропуск пустых строк }

      if Eof(aFile) then Break else Readln(aFile); 

if Eof(aFile) then Break; { если конец файла – выход из цикла }

Read(aFile, Numbers[i]) ; { читаем номер в элемент массива }

Fact:= Fact+1;       { наращиваем счетчик номеров }

end;

end;


{ Функция поиска в массиве номеров автомобилей }

function FindNumber(aNum: integer): boolean;

var i: integer;

begin

      FindNumber:= false;

      for i:=1 to Fact do

      if aNum=Numbers[i] then begin

      FindNumber:= true;       { нашли ! }

      Break;       { выход из цикла }

      end

end;

begin       {--- Главная программа ---}

      { открываем файл и читаем номера автомобилей }

      Assign(F, 'P_38_2.in'); Reset(F);

      ReadFromFile(F);       { ввод номеров из файла }

      Close(F);

      repeat       { Главный цикл }

      Write('Укажите номер автомобиля: '); Readln(Num);

      if FindNumber(Num)

      then Writeln('Эта машина в розыске, хватайте его!')

      else Writeln('Пропустите его');

      until Num=0; { 0 – признак завершения программы}

end.



Ещё раз о статистике

Следующая программка будет маленькой, да удаленькой. Вернемся к статистике, с которой познакомились при обработке классного журнала. Напомню, что статистика – это наука, изучающая массовые явления. В текстах наших программ полным-полно разных букв, – давайте посчитаем их. Результатом работы программы будет таблица, похожая на эту.


a 119

b 45

c 72

...


Здесь левый столбец составляют буквы, а правый – количество этих букв в некотором файле. Упростим себе задачу, ограничившись подсчетом лишь маленьких латинских букв от «a» до «z».

Для подсчета общего количества символов в файле хватило бы одного счетчика. Но здесь 26 букв, а значит и счетчиков надо столько же. Массив счетчиков напрашивается сам собой, его тип можно объявить так:


type TCounts = array [1..26] of integer;


Однако не спешите этого делать. Вспомните о том, что индексом массива может быть любой порядковый тип данных. А к ним, наряду с числами, относятся символьный и даже булев тип. Стало быть, допустимы такие массивы.


type TA = array ['A'..'F'] of integer;

      TB = array [false..true] of integer;


Первый из них содержит 6 элементов, а индексируется символьным выражением. Второй содержит всего два элемента, индексы которого имеют булев тип. В решаемой задаче напрашивается символьная индексация, а потому объявим тип для массива счетчиков так:


type TCounts = array ['a'..'z'] of integer;


Теперь символ, прочитанный из файла, можно использовать как индекс в массиве счетчиков, надо лишь предварительно проверить его на попадание в нужный диапазон.

Входным файлом программы будет текст её самой же. Вот она, простая и красивая.


{ P_40_3 – Подсчет количества различных букв в файле }

      { Тип массива из целых чисел, индекс – символьный }

type TCounts = array ['a'..'z'] of integer;


var Counts : TCounts; { массив из счетчиков букв }

      c: char; { текущий символ файла, он же – индекс счетчика }

      F : text; { файл с текстом программы }


begin       {--- главная программа ---}

{ Перед началом подсчета все счетчики обнуляем }

for c:='a' to 'z' do Counts[c]:=0;

{ Открываем входной файл для чтения }

Assign(F, 'P_40_3.pas'); Reset(F);

while not Eof(F) do begin { Цикл чтения и подсчета букв }

Read(F, c);       { чтение одного символа из файла }

if c in ['a'..'z']       { если символ в нужном диапазоне }

      then Counts[c]:= Counts[c]+1; { наращиваем его счетчик }

end;

Close(F);

{ После подсчета распечатаем все счетчики }

for c:='a' to 'z' do Writeln (c, Counts[c]:6);

Write('Нажмите Enter'); Readln;

end.


Здесь осталась лишь одна шероховатость – при печати результатов часть строк не поместится на экране. Так направьте вывод в текстовый файл. Или слабо?


Итоги

• Массивы, как любые переменные, «живут» в оперативной памяти. Переместив данные из файлов в массивы, мы многократно ускорим их обработку.

• Для индексации массивов допустимы любые порядковые типы данных. Выбор подходящего типа для индекса упрощает и украшает программу.

• При чтении чисел из текстового файла в «боевых» программах необходимо учитывать возможное наличие в файле пустых строк. Такие строки могут привести к чтению оператором Read несуществующего пустого числа (см. процедуру ReadFromFile в программе «P_40_2»).


А слабо?

А) Напишите программу для подсчета различных цифр в файле полицейской базы данных (считать надо именно цифры, а не числа!).

Б) Объявите массив из сотни целых чисел, заполните его случайными числами в диапазоне от 0 до 255 и распечатайте этот массив.

В) Найдите в массиве (задание Б) все элементы, хранящие число 7 (если таковые найдутся). Напечатайте индексы элементов, которые содержат это число.

Г) Заполните массив (задание Б) случайными числами в диапазоне от 0 до 255 так, чтобы ни одно из них не повторялось. Воспользуйтесь вспомогательным множеством чисел, где будут запоминаться сгенерированные ранее числа.

Д) Найдите в массиве (задание Г) наименьшее и наибольшее числа, напечатайте их, а также соответствующие им индексы элементов массива.

Е) Вращение массива вправо. Объявите массив из 10 чисел и заполните его случайным образом. Напишите процедуру, перемещающую 1-й элемент на 2-е место, 2-й – на 3-е место и т.д. Последний элемент должен занять 1-е место.

Ж) Вращение массива влево. Напишите процедуру для перемещения 2-го элемента на 1-е место, 3-го – на 2-е место и т.д. При этом первый элемент должен стать последним.

И) Напишите функцию для подсчета количества номеров в полицейской БД при условии, что одна строка может содержать несколько номеров, а некоторые строки (в т.ч. в конце файла) могут быть пустыми.

Глава 41

По порядку, становись!

 Сделать закладку на этом месте книги




В 39-й главе, где состоялось наше знакомство с массивами, мы намерились отсортировать футбольные команды в порядке набранных ими очков. Следуя к этой цели, перенесемся ненадолго в прошлое, – лет на триста назад.


Пиратская справедливость

Тогда в морях разбойничали «джентльмены», которых мы зовем пиратами. Одной из таких бригад повелевал некто Райт. Пиратские команды не отличались дисциплиной, но Райт добился порядка на корабле, избегая жестокостей. Отважный в бою, Райт давал пример и в мирных обстоятельствах, деля добычу если не поровну, то хотя бы по справедливости. Вожак брал равную со всеми долю, потому команда чтила его и подчинялась беспрекословно.

Однажды джентльменам удачи достался сундук с золотыми слитками. Пересчитав их, пираты выяснили, что каждому из них полагается ровно по два. Казалось бы, о чем тут думать? – садись и дели. Однако слитки существенно отличались формой и размерами. Пираты не могли распилить или переплавить их, сделав одинаковыми. Как быть? – с таким вопросом Райт обратился к экипажу.

После недолгих споров разбойники уже готовы были бросить жребий (на случайную дележку никто не обижался). Но тут голос подал бывший аптекарь, а ныне корабельный лекарь по кличке Нашатырь.

– Я предлагаю, – молвил Нашатырь, – разложить слитки в порядке их веса. Затем кто-то из нас возьмет самый легкий и самый тяжелый из них. Другой – самый легкий и самый тяжелый из оставшихся, и так далее.

Свою мысль он сопроводил рисунком с шестью слитками разного веса и размера (рис. 89).

– Отлично, – согласился Райт, – но как взвесить слитки? У нас нет ни гирь, ни весов.

– Зачем мне гири? Для сравнения слитков годится вот это, – и лекарь достал из своего сундука самодельные чашечные весы.

– Ну что ж, – сказал Райт, – ты придумал, тебе и делить.

И под пристальными взглядами всей команды лекарь принялся за дело.

Вначале ряд слитков он выложил, как попало. Затем стал по очереди сравнивать соседние куски. Если первый из них был тяжелее второго, аптекарь менял их местами. Так он сравнил первый и второй слитки, второй и третий, третий и четвертый и так далее до последнего слитка. В конце концов, самый тяжелый слиток оказался на последнем месте. Затем он повторил все это ещё раз, – и тогда второй по величине слиток оказался на предпоследнем месте. Проделав это N-1 раз, где N – количество слитков, лекарь выложил слитки в нужном порядке: первым лежал самый легкий, а последним – самый тяжелый.






Рис.89 – Пример справедливого дележа шести слитков между тремя пиратами

«А теперь бросайте жребий, – подытожил Нашатырь, скромно отходя в сторону, – пусть он определит порядок взятия долей». Пираты остались довольны.


Пузырьковая сортировка

Вернемся в наше время. О пиратской истории программист сказал бы так: разложив куски золота в нужном порядке, лекарь отсортировал массив слитков. Его метод известен как «пузырьковая сортировка» – Bubble Sort. Откуда взялось это название? Проследите за пузырьками в стакане газировки: по мере всплытия они объединяются с другими и становятся крупнее.

Воспользуемся методом лекаря-аптекаря для сортировки массива из 10 целых чисел – это будут наши золотые слитки. А для испытания алгоритма напишем программу «P_41_1», которая вначале заполнит массив случайным образом и распечатает его. Затем отсортирует этот массив и снова распечатает. Работу по сортировке выделим в отдельную процедуру по имени BubbleSort, – она ещё пригодится нам в последующих проектах.

Исследуйте процедуру сортировки по шагам. Здесь «крутятся» два цикла FOR-TO-DO, вложенные друг в друга. Внутренний цикл со счетчиком J сравнивает соседние числа и, при необходимости, меняет их местами. Переменная T нужна для перестановки соседних элементов. По завершении одного внутреннего цикла очередное крупное число оказывается на своем месте. Но, поскольку сортируются CSize чисел, то внутренний цикл надо повторить CSize-1 раз, – это делает внешний цикл со счетчиком I.


      { P_41_1 – Сортировка массива целых чисел }

const CSize = 10; { размер массива }


      { объявление типа для массива }

type TGolds = array [1..CSize] of integer;


var Golds : TGolds; { массив кусков золота }

      { Процедура "пузырьковой" сортировки }

      { Внимание! Параметр-массив передается по ссылке! }

procedure BubbleSort (var arg: TGolds);

var i, j, t: Integer;

begin

for i:= 1 to CSize-1 do { внешний цикл }

      for j:= 1 to CSize-1 do { внутренний цикл }

      { если текущий элемент больше следующего …}

      if arg[j] > arg[j+1] then begin

      { то меняем местами соседние элементы }

      t:= arg[j];       { временно запоминаем }

      arg[j]:= arg[j+1];       { следующий -> в текущий }

      arg[j+1]:= t;       { текущий -> в следующий }

      end;

end;

var i:integer; { для индекса в главной программе }

begin {--- Главная программа ---}

      { заполняем массив случайным образом }

      Randomize;

      for i:=1 to CSize do Golds [i]:= 1+Random(1000);

      { распечатаем до сортировки }

      Writeln('До сортировки:');

      for i:=1 to CSize do Writeln(Golds [i]:3);

      { сортируем }

      BubbleSort(Golds);

      { распечатаем после сортировки }

      Writeln('После сортировки:');

      for i:=1 to CSize do Writeln(Golds [i]:3);

      Readln;

end.


Обратите внимание: сортируемый массив передан в процедуру по ссылке VAR. Передача в процедуры массивов, множеств, строк и других сложных типов данных по ссылкам CONST и VAR — обычная практика. Это повышает скорость работы программ и уменьшает объём памяти, занимаемый параматрами.

При должном внимании вы обнаружите в этой сортировке небольшой изъян, суть которого такова. После отработки первого внутреннего цикла самый большой элемент окажется на последнем месте. А значит, на втором внутреннем цикле нет смысла сравнивать два последних элемента. На третьем проходе соответственно нет смысла сравнивать три последних элемента, – они уже лежат в нужном порядке. На этих сравнениях мы зря теряем время. Порок этот легко устранить, если поправить внутренний цикл так:


      for j:= 1 to CSize – i do { внутренний цикл }


Теперь каждый следующий внутренний цикл будет на единицу короче предыдущего (ведь счетчик внешнего цикла I растет). В следующей программе мы так и сделаем.


Электронная делёжка

Рассмотрев хитрости пузырьковой сортировки, поможем теперь морским романтикам. Напишем программу для справедливой дележки золотых слитков. Основная работа уже проделана, – мы смогли отсортировать массив. Осталось лишь распечатать веса тех кусков, что достанутся каждому из пиратов. Известно, что первому пирату достанется первый и последний слитки, второму – второй и предпоследний и так далее. Иначе говоря, I–му пирату достанутся слитки с номерами I и CSize+1-I. Программа «P_41_2» «делит слитки», распечатывая после сортировки веса соответствующих пар.


{ P_41_2 – Пиратская делёжка по справедливости }


const CSize = 16; { размер массива слитков }

      { объявление типа для массива слитков }

type TGolds = array [1..CSize] of integer;

var Golds : TGolds; { массив кусков золота }

      { Процедура "пузырьковой" сортировки }

procedure BubbleSort (var arg: TGolds);

var i, j, t: Integer;

begin

for i:= 1 to CSize-1 do { внешний цикл }

      for j:= 1 to CSize-i do { внутренний цикл }

      { если текущий элемент больше следующего …}

      if arg[j] > arg[j+1] then begin

      { то меняем местами соседние элементы }

      t:= arg[j];       { временно запоминаем }

      arg[j]:= arg[j+1];       { следующий -> в текущий }

      arg[j+1]:= t;       { текущий -> в следующий }

      end;

end;


var i:integer; { используется в качестве индекса в главной программе }

begin

      { заполняем массив случайным образом }

      Randomize;

      for i:=1 to CSize do Golds[i]:= 500 + Random(500);

      { сортируем }

      BubbleSort(Golds);

      Writeln('По справедливости:');

      for i:=1 to (CSize div 2) do begin

      { два куска по отдельности }

      Write(i:2, Golds[i]:5,' + ',Golds[CSize+1-i]:3,' = ');

      { сумма двух кусков }

      Writeln(Golds[i]+Golds[CSize+1-i] :4);

      end;

      Readln;

end.


Вот результат одной из таких делёжек:


По справедливости:

1 506 + 975 = 1481

2 556 + 967 = 1523

3 587 + 954 = 1541

4 629 + 916 = 1545

5 691 + 876 = 1567

6 694 + 872 = 1566

7 749 + 845 = 1594

8 751 + 800 = 1551


Здесь самый легкий и самый тяжелый слитки отличаются почти вдвое: 506 и 975 граммов. Но пары слитков, доставшихся пиратам, отличаются по весу незначительно.


Возвращение на футбольное поле

Закаленные морскими приключениями, вернемся к сортировке футбольных клубов (задача поставлена в главе 39, помните?). Что мы будем сортировать? Набранные очки? Да, но их надо как-то привязать к названиям команд.

Поступим так. Объявим два массива: один (числовой) – для набранных очков, другой (строковый) – для названий клубов. При вводе данных элементы двух массивов будут соответствовать друг другу, поскольку имена команд и набранные ими очки вводятся одновременно. Затем, в ходе сортировки, переставляя элементы с очками, будем менять местами и соответствующие им элементы с названиями команд. Так имена команд последуют за очками, заработанными командами. Все это потребует небольших переделок в процедуре сортировки.

Впрочем, потребуется ещё одно мелкое изменение. Если при сортировке золотых слитков мы добивались возрастающего порядка, то теперь нужен противоположный, убывающий порядок сортировки. Как его добиться? Очень просто: изменим условие сравнения соседних элементов на противоположное. Вот собственно и все, осталось лишь показать программу «P_41_3».


{P_41_3 – Футбольный чемпионат }

const CSize = 16; { количество команд }

      { объявление типов для массивов }

type TAces = array [1..CSize] of integer; { тип для очков }

      TNames = array [1..CSize] of string; { тип для названий }

var Aces : TAces; { набранные очки }

      Names: TNames; { названия команд }

      { Процедура "пузырьковой" сортировки очков с именами команд }

procedure BubbleSort2(var arg1: TAces; var arg2: TNames);

var i, j, t: Integer;

      s: string;

begin

for i:= 1 to CSize-1 do { внешний цикл }

      for j:= 1 to CSize-i do { внутренний цикл }

      { если текущий элемент меньше следующего …}

      if arg1[j] < arg1[j+1] then begin

      { то меняем местами соседние элементы }

      t:= arg1[j];       { временно запоминаем }

      arg1[j]:= arg1[j+1]; { следующий -> в текущий }

      arg1[j+1]:= t;       { текущий -> в следующий }

      { меняем местами и названия команд }

      s:= arg2[j];        { временно запоминаем }

      arg2[j]:= arg2[j+1];  { следующий -> в текущий }

      arg2[j+1]:= s;        { текущий -> в следующий }

      end;

end;

var i: integer;

begin       { главная программа }

{ Вводим названия команд и набранные очки }

for i:=1 to CSize do begin

      Write('Название команды: '); Readln(Names[i]);

      Write('Набранные очки: '); Readln(Aces[i]);

end;

BubbleSort2(Aces, Names); { сортируем }

Writeln('Итоги чемпионата:');

Writeln('Место       Команда       Очки');

for i:=1 to CSize do

      Writeln(i:3,' ':3, Names[i], Aces[i]:20-Length(Names[i]));

Readln;

end.


Спецификатор ширины поля в операторе печати задан выражением.


      20 – Length(Names[i])


Здесь перед колонкой с очками будет тем больше пробелов, чем короче название команды, – так выравниваются колонки таблицы.

Для проверки программы я ввел наобум имена четырех команд нашего чемпионата и очки, якобы заработанные ими (количество команд CSize установил равным 4), и вот что у меня вышло.


Итоги чемпионата:

Место Команда       Очки

1 Локомотив       55

2 Крылья Советов 54

3 Спартак       47

4 Зенит       43


Болельщики вправе оспорить результат, но я им доволен.


Итоги

• Расположение данных в порядке возрастания или убывания называется сортировкой.

• Простейший алгоритм сортировки массива – «пузырьковая» сортировка. Она состоит в сравнении и перестановке соседних элементов массива, при этом организуются два вложенных цикла.


А слабо?

А) Напишите программу для сортировки фамилий учеников в алфавитном порядке (фамилии берутся из файла). Программа должна сортировать их как по возрастанию, так и по убыванию фамилий, – на выбор пользователя.

Б) Придумайте самый несправедливый способ пиратской дележки по два слитка и напишите программу для неё.

В) Напишите программу для дележки случайным образом (как это собирались сделать пираты). Насколько отличаются ваши результаты от справедливого способа?

Г) Напишите функцию, проверяющую, упорядочен ли числовой массив. Функция должна вернуть TRUE, если массив упорядочен по возрастанию. Массив внутрь функции передайте параметром по ссылке.

Глава 42

Кто ищет, тот всегда найдет

 Сделать закладку на этом месте книги




Все кругом ищут что-то: Карабас-Барабас – золотой ключик, Лиса с Котом – дураков, а Буратино – Страну Дураков. И я ищу: то ключи в карманах, то тапочки под диваном. А сколько всего таится в Интернете! Благо, искать информацию там помогают компьютеры.


Где эта улица, где этот дом?

В 40-й главе мы смастерили программу для поиска угнанных автомобилей. Испытаем её вон на той легковушке. Вводим номер машины и… оп! Вот так удача! Автомобильчик-то в розыске, – надо вернуть его владельцу. Однако, кто он? Где живет? А телефончик не подскажете? К сожалению, в нашей базе данных этих сведений нет, – её следует дополнить.

Добавим в программу поиска автомобилей массив строк, где будем хранить сведения о владельце: его имя, фамилию и телефон.


const CNumbers = 100; { размер массивов }

type TNumbers = array[1..CNumbers] of integer;

      TNames = array[1..CNumbers] of string;

var Numbers : TNumbers; { массив номеров автомобилей }

      Names : TNames;       { массив сведений о владельце }


Здесь добавлен массив Names (имена), содержащий столько же строк, сколько номеров в базе данных. Эти строки соответствуют элементам массива номеров Numbers. Так, если элемент Numbers[7] содержит число 123, а элемент Names[7] – строку «Горбунков С.С., тел. 11-22-33», то значит, гражданин Горбунков владеет автомобилем с номером 123.

Что связывает массивы Names и Numbers? Ответ очевиден – общий индекс. Определив индекс автомобиля в массиве номеров, мы получим доступ и к сведениям о его владельце в строковом массиве.


Последовательный поиск

Напомню, что в полицейской базе данных из 40-й главы заголовок функции поиска был таким.


function FindNumber(aNum: integer): boolean;


Функция FindNumber выясняет, существует ли искомый номер в массиве Numbers, то есть она дает булев результат. Теперь этого мало, – хочется получить индекс элемента, где хранится искомый номер. А если такого номера в массиве нет? Пусть тогда функция вернет некоторое условное значение, например, минус единицу.

С учетом этих пожеланий, напишем новую функцию поиска и дадим ей имя FindSeq (от слов Find – «искать», Sequence – «последовательно»).


      { Функция поиска в массиве Numbers позиции числа


убрать рекламу






aNum }

function FindSeq (aNum: integer): integer;

var i: integer;

begin

      FindSeq:= -1;       { если не найдем, то результат будет -1 }

      for i:=1 to Fact do

      if aNum=Numbers[i] then begin

      FindSeq:= i;       { нашли, возвращаем индекс }

      Break;       { выход из цикла }

      end

end;


Новая функция сравнивает искомое число с элементами массива, перебирая их последовательно до тех пор, пока не найдет подходящий элемент или не уткнется в конец массива. В случае успеха она вернет индекс элемента в массиве, а иначе – минус единицу.

Этот способ называют поиском прямым перебором или линейным поиском. Линейный поиск прост, но крайне медлителен. Если бы библиотекарь искал заказанную книгу прямым перебором, клиент дремал бы в ожидании заказа месяцами! Но библиотекарь справляется с поиском, живо находя нужное среди сотен тысяч томов. Как ему удается это?

Все дело в порядке. Там, где порядок, искать проще и быстрей. Вы ищите ложку в кухонном шкафу, а ботинки – на обувной полке, но не обшариваете весь дом. Есть свой порядок и в библиотеке, потому персонал и справляется с работой. Компьютер ищет куда быстрее человека, и все же понуждать его к линейному поиску – проявление крайней жестокости. Впрочем, пострадает не столько компьютер, сколько уснувший в томлении пользователь.


Двоичный поиск

Один удачливый зверолов в минуту откровенности поделился секретом своих успехов. «Вначале я делю лес своей огромной сетью примерно пополам, и выясняю, в которой из двух половин очутился нужный мне зверь – пояснил охотник. – Затем половину со зверем опять делю пополам и гляжу, где он теперь. И так поступаю, пока животное не окажется в тесном загоне». И зверолов нацарапал на песке рис. 90.






Рис.90 – Поимка зайца шестью сетями

Здесь показано, как шестью сетями (они обозначены цифрами) был изловлен несчастный заяц. Обратите внимание на нумерацию сетей, – они расставлялись в этом порядке.

Не воспользоваться ли уловкой зверолова для поиска в массиве? Ускорит ли это дело? Конечно! Но массив должен быть заранее отсортирован. На рис. 91 показан отсортированный по возрастанию массив, содержащий 12 чисел. Для наглядности числа изображены столбиками. Среди них я выбрал наугад число 32, и прямым перебором нашел его позицию (индекс) в массиве. Очевидно, что я выполнил 8 шагов поиска, поскольку число 32 хранится в 8-м элементе массива.

А теперь применим метод зверолова. Обратимся к среднему элементу массива, индекс которого равен полу-сумме первого и последнего индексов, то есть:

(1+12)/2 = 6






Рис.91 – Двоичный поиск в отсортированном массиве

Поскольку индекс – это целое число, дробную часть при делении отбросим. Итак, в позиции 6 оказалось число 21, которое меньше искомого числа 32. Это значит, что «зверь притаился» где-то правее. Раз так, элементы массива, расположенные левее, нас уже не интересуют, – мысленно отбросим их.

С оставшейся частью массива поступим точно так же, то есть, исследуем средний его элемент с индексом

(7+12)/2 = 9

Сравним «живущее» там число 40 с искомым числом 32. На этот раз оно оказалось больше искомого, а значит, искать надо левее, а все, что справа, отбросить. Так, на третьем шаге поиска из 12 элементов массива остались лишь два. Рассуждая тем же порядком, выделяем элемент с индексом

(7+8)/2 = 7

и отбрасываем на этот раз число 27. И вот на последнем четвертом шаге остался лишь один элемент с искомым числом 32.

Подведем итог: вместо 8 шагов последовательного поиска, метод зверолова сделал то же самое за 4 шага. Скажете: всего-то? Восемь шагов или четыре – разница невелика. Так проверим оба метода на большом наборе данных, – поищем в массиве из тысячи чисел. Только избавьте меня от ручной работы, – этот эксперимент поручим компьютеру, для чего соорудим несложную программу.


Исследование двоичного поиска

Частью этой программы будет функция двоичного поиска, алгоритм которой раскрыл зверолов. Но не худо привести и блок-схему этого чудесного изобретения. На блок-схеме (рис. 92), как и в программе, индексы элементов обозначены начальными буквами соответствующих английских слов: L – левый индекс (Left), R – правый индекс (Right), и M – средний индекс (Middle).






Рис.92 – Блок-схема алгоритма двоичного поиска

Функцию, работающую по этому алгоритму, я назвал FindBin (Find – «поиск», Binary – «двоичный»), она показана ниже. Полагаю, что приведенных в ней комментариев будет достаточно.


      { Функция двоичного поиска }

function FindBin (aNum: integer): integer;

var L, M, R : integer; { левый, правый и средний индексы }

begin

      FindBin:= -1;       { результат на случай неудачи }

      L:= 1; R:= CSize;       { начальные значения индексов }

      repeat

      M:= (L+R) div 2;       { индекс среднего элемента }

      if aNum= ArrSort[M] then begin

      FindBin:= M;       { нашли ! }

      Break;       { успешный выход из цикла }

      end;

      if aNum > ArrSort[M] { где искать дальше? }

      then L:= M+1       { ищем правее }

      else R:= M–1; { ищем левее }

      until L > R;       { выход при неудачном поиске }

end;


Теперь мы готовы создать исследовательскую программу, которая будет сравнивать два способа поиска.

Поступим так. Объявим два массива по 1000 чисел в каждом. Заполним их случайным образом и один из них отсортируем. Затем сделаем ряд экспериментов, каждый из которых состоит в следующем. Выбрав наугад одно из чисел массива, программа вызовет по очереди две функции: сначала последовательно найдет число в несортированном массиве, а затем двоичным поиском – в сортированном. Поскольку искомое число выбрано из массива, то поиск всегда будет успешным. Затраченные на поиск шаги подсчитаем, и результаты запишем в текстовый файл. После каждого такого эксперимента программа будет ожидать команды пользователя: приняв число ноль, она завершится, а иначе повторит эксперимент.

Подсчет шагов будем вести в глобальной переменной Steps (шаги). Перед вызовом функций поиска она обнуляется, а внутри функций наращивается (эти операторы внутри функций выделены курсивом). Вот и все, полюбуйтесь на эту «экспериментальную установку», введите в компьютер и запустите на выполнение.


      { P_42_1 – Исследование методов поиска }

const CSize = 1000; { размер массива }

      { объявление типа для массива }

Type TNumbers = array [1..CSize] of integer;

Var ArrRand : TNumbers; { несортированный массив }

      ArrSort : TNumbers; { сортированный массив }

      Steps : integer; { для подсчета числа шагов поиска }

{ Процедура "пузырьковой" сортировки чисел в порядке возрастания }

procedure BubbleSort(var arg: TNumbers);

var i, j, t: Integer;

begin

for i:= 1 to CSize-1 do       { внешний цикл }

      for j:= 1 to CSize-i do { внутренний цикл }

      if arg[j] > arg[j+1] then begin { обмен местами }

      t:= arg[j]; arg[j]:= arg[j+1]; arg[j+1]:= t;

      end;

end;

      { Функция последовательного поиска (Find Sequence) }

function FindSeq (aNum: integer): integer;

var i: integer;

begin

      FindSeq:= -1;       { если не найдем, результат будет -1 }

      for i:=1 to CSize do begin

      Steps:= Steps+1; { подсчет шагов поиска }

      if aNum= ArrRand[i] then begin

      FindSeq:= i;       { нашли, возвращаем позицию }

      Break;       { выход из цикла }

      end;

      end;

end;

      { Функция двоичного поиска (Find Binary) }

function FindBin (aNum: integer): integer;

var L, M, R : integer;

begin

      FindBin:= -1;

      L:= 1; R:= CSize;

      repeat

      Steps:= Steps+1;       { подсчет шагов поиска }

      M:= (L+R) div 2;

      if aNum= ArrSort[M] then begin

      FindBin:= M;       { нашли ! }

      Break;       { выход из цикла }

      end;

      if aNum > ArrSort[M]

      then L:= M+1

      else R:= M-1;

      until L > R;

end;

      {--- Главная программа ---}

Var i, n, p : integer;       { вспомогательные переменные }

      F: text;       { файл результатов }

begin

      Assign(F,'P_42_1.OUT'); Rewrite(F);

      { Заполняем массив случайными числами }

      for i:=1 to CSize do ArrRand[i]:=1+Random(10000);

      ArrSort:= ArrRand;       { копируем один массив в другой }

      BubbleSort(ArrSort); { сортируем второй массив }


      repeat       { цикл с экспериментами }

      i:= 1+ Random(CSize); { индекс в пределах массива }

      n:= ArrRand[i];       { случайное число из массива }


      Writeln(F,'Искомое число= ', n);

      Steps:=0;       { обнуляем счетчик шагов поиска }

      p:= FindSeq(n);       { последовательный поиск }

      Writeln(F,'Последовательный: ', 'Позиция= ',

      p:3, ' Шагов= ', Steps);

      Steps:=0;       { обнуляем счетчик шагов поиска }

      p:= FindBin(n);       { двоичный поиск }

      Writeln(F,'Двоичный поиск: ', 'Позиция= ',

      p:3, ' Шагов= ', Steps);

      Write('Введите 0 для выхода из цикла '); Readln(n);

      until n=0;

      Close(F);

end.


Вот результаты трех экспериментов.


Искомое число= 5026

Последовательный: Позиция= 544 Шагов= 544

Двоичный поиск: Позиция= 518 Шагов= 10

Искомое число= 8528

Последовательный: Позиция= 828 Шагов= 828

Двоичный поиск: Позиция= 854 Шагов= 10

Искомое число= 7397

Последовательный: Позиция= 100 Шагов= 100

Двоичный поиск: Позиция= 748 Шагов= 9


Я не поленился проделать 20 опытов, результаты которых занес в табл. 7. Среднее число шагов поиска для каждого из методов посчитано мною на калькуляторе и внесено в последнюю строку таблицы.

Табл. 7- Результаты исследования алгоритмов поиска

Экспе-римент Искомое число Количество шагов поиска
Последовательный поиск Двоичный поиск
1 5026 544 10
2 8528 828 10
3 7397 100 9
4 2061 52 9
5 8227 634 9
6 9043 177 10
7 4257 10 10
8 3397 704 5
9 4021 887 10
10 8715 815 9
11 6811 53 9
12 5959 141 10
13 928 859 7
14 3295 26 10
15 9534 935 10
16 1618 8 6
17 1066 105 8
18 7081 989 10
19 218 290 9
20 6927 952 10
Среднее количество шагов 455 9

Что вы скажете об этом? Двоичный поиск дал превосходный результат, – любое число находится не более чем за 10 шагов! Это любопытно, и побуждает разобраться в алгоритме глубже.


Ах, время, время!

Принимаясь за что-либо, мы прикидываем, сколько времени займет то или иное дело. Поиск может отнять уйму времени, вот почему важно оценить его трудоемкость. Сравним алгоритмы поиска по затратам времени. Только время будем измерять не секундами, а особыми единицами – шагами поиска. Почему? Да потому, что у нас с вами разные компьютеры. Поскольку ваш «станок» мощнее, ту же работу он выполнит быстрее моего, а это нечестно! Мы ведь алгоритмы сравниваем, а не процессоры.

Если улыбнется удача, поиск завершится на первом шаге. Иногда – по закону подлости – тратится максимальное число шагов. Но эти крайние случаи – редкость; обычно поиск занимает какое-то промежуточное время, и наш эксперимент подтвердил это. Программистов интересует время поиска в двух случаях: в худшем, и в среднем (то есть, усредненное по многим случаям).

Начнем с линейного поиска. Очевидно, что в массиве из N элементов худшее время поиска составит N шагов. Что касается среднего времени, то чутье подсказывает, что оно составит половину максимального времени, то есть N/2. Судите сами: искомое число с равной вероятностью может оказаться и ближе и дальше середины массива. Табл. 7 подтверждает эту догадку, – среднее количество шагов там составило 455, что очень близко к значению 1000/2.

Теперь рассмотрим двоичный поиск. Вначале оценим худшее время. Рассудим так. Сколько шагов поиска нужно в массиве из одного элемента? Правильно, один. А теперь вспомним, что при двоичном поиске всякий раз отбрасывается половина оставшегося массива. Значит, посчитав, сколько раз число N делится пополам для получения единицы, мы определим максимальное число шагов. Так и поступим; следите, честно ли я «распилил» нашу тысячу.

1. 1000 / 2 = 500

2. 500 / 2 = 250

3. 250 / 2 = 125

4. 125 / 2 = 62

5. 62 / 2 = 31

6. 31 / 2 = 15

7. 15 / 2 = 7

8. 7 / 2 = 3

9. 3 / 2 = 1

При делении я отбрасывал дробную часть, поскольку в двоичном алгоритме так и делается. Всего потребовалось 9 операций деления. Это значит, что максимальное число шагов поиска равно 10 (с учетом поиска в одном оставшемся элементе). Удивительная прозорливость, – ведь наш эксперимент (табл. 7) показал то же самое!

Теперь оценим среднее время двоичного поиска. Думаете, что оно составит 10/2 = 5 шагов? Как бы ни так! Дело в том, что любой алгоритм поиска в среднем исследует половину массива. Двоичный поиск отбрасывает половину массива на первом же шаге. А это значит, что в среднем число шагов будет всего лишь на единицу меньше худшего, то есть 9. Смотрим в табл. 7, – точно! Наша догадка подтвердилась! Таким образом, двоичный поиск не только быстрее линейного, но и более предсказуем: его худшее время почти не отличается от среднего.


Логарифмы? Это просто!

Разобравшись с тысячей элементов, оценим трудоемкость двоичного поиска при других размерах массива. Метод оценки остается тем же: делим размер массива пополам до получения единицы.

Для таких вычислений математики придумали особую функцию – логарифм (не путайте её с рифмой, ритмом и алгоритмом!). Логарифмы бывают разные: десятичные, натуральные и прочие. Нам интересен двоичный логарифм, который по-научному называется так: «логарифм числа N по основанию два». Математики записывают его следующим образом:

Log2 N

Связь между числом N и его двоичным логарифмом легко проследить на следующих примерах. Слева представлено разложение на множители нескольких чисел, а справа – двоичные логарифмы этих же чисел.

4 = 2 • 2 Log2 4 = 2

16 = 2 • 2 • 2 • 2 Log2 16 = 4

64 = 2 • 2 • 2 • 2 • 2 • 2 Log2 64 = 6

Итак, двоичный логарифм числа равен количеству двоек (ой, нехорошее слово!), перемножаемых для получения этого числа. Например, для получения числа 8 надо перемножить три двойки, и его логарифм равен трем. Кстати, для получения единицы из восьмерки, её тоже «пилят» пополам трижды. Значит, оба способа вычисления логарифма – через умножение, и через деление – равноценны.

Если вы завтра же не забросите программирование, то табл. 8 с логарифмами нескольких чисел ещё пригодится вам.

Табл. 8 – двоичные логарифмы некоторых чисел

N Log2 N N Log2 N N Log2 N N Log2 N
2 1 32 5 512 9 8192 13
4 2 64 6 1024 10 16384 14
8 3 128 7 2048 11 32768 15
16 4 256 8 4096 12 65536 16

По таблице можно оценить как среднее, так и худшее время двоичного поиска: среднее время равно двоичному логарифму от размера массива, а худшее – на единицу больше.

А как определить логарифмы других чисел, например, числа 50? Поскольку оно лежит между 32 и 64, его логарифм должен быть где-то между 5 и 6? Так оно и есть: логарифм 50 равен приблизительно 5,64 (это я на калькуляторе посчитал). Но, поскольку мы применяем логарифмы для подсчета шагов поиска, то погрешностью в доли шага можно пренебречь. К чему мелочиться? Будем считать, что логарифм числа 50 тоже равен 6. Мало того, назначим это значение логарифма всем числам в промежутке от 33 до 64.

На рис. 93 сопоставлен рост числа с ростом его логарифма. Когда число увеличивается вдвое, его логарифм возрастает лишь на единицу. Вот почему с ростом размера массива время двоичного поиска растет так медленно (что очень радует нас!).






Рис.93 – Сравнение времени линейного и двоичного поиска

Итоги

• Компьютерные базы данных (БД) содержат разнородную информацию, отдельные элементы которой связаны общим индексом.

• Поиск в массиве состоит в определении индекса искомого элемента; зная индекс, можно извлечь всю прочую информацию о нужном объекте.

• Для поиска применяют два способа: последовательный перебор и двоичный поиск.

• Последовательный перебор (линейный поиск) очень прост, но время поиска пропорционально размеру массива, что для больших объёмов данных бывает неприемлемо.

• Двоичный поиск очень быстр, – с ростом размера массива затраты времени на поиск растут по логарифмическому закону. Однако, двоичный поиск работает только в отсортированных массивах.


А слабо?

А). Будет ли линейный поиск работать быстрее в сортированном массиве? Проверьте на практике.

Б) Сколько шагов двоичного поиска потребуется в массиве из миллиона элементов? А из миллиарда? Сравните с трудоемкостью линейного поиска.

В) Напишите полицейскую базу данных, содержащую номера автомобилей и сведения о владельцах. Данные должны вводиться из файла, каждая строка которого содержит номер автомобиля и сведения о владельце, например:


123 Горбунков С.С., ул. Тепличная, д. 21, тел. 11-22-33

35 Стелькин И.Н., ул. Тенистая, д. 5, тел. 33-22-11


Примените массивы и учтите опыт обработки классного журнала.

Г) Отсортируйте полицейскую базу данных и напишите программу для двоичного поиска в ней.

Д) Папа Карло опасался Буратино, и прятал спички в сейфе. Код замка из четырех цифр он доверил лишь своему приятелю – честному малому Джузеппе, который не поддавался ни на какие уговоры деревянного мальчишки. Тогда тот пустился на хитрость. Ладно, – предложил Буратино, – не можешь открыть мне код, – не надо. Давай тогда в игру сыграем: я буду спрашивать, а ты отвечай только «да» или «нет». Первый вопрос был таким: код замка больше 5000? Через несколько минут Буратино уже рылся в папином сейфе. Сделайте программу для быстрого угадывания числа методом Буратино. Роль Буратино (угадывающего) должен исполнять компьютер.

Глава 43

Сортировка по-взрослому

 Сделать закладку на этом месте книги








Наше новейшее открытие – быстрый, как ракета, двоичный поиск. Но работает он лишь в сортированном массиве. Так в чем вопрос? Разве сортировка «пузырьком» нам не покорилась? Увы! «Пузырек» насколько же нетороплив, насколько и прост. Много ли проку от быстрого поиска, если выигрыш времени съест сортировка? Так ускорим её!


"Фермерская" сортировка

Отчего так медленно «всплывают пузырьки»? Не оттого ли, что мы сравниваем и обмениваем соседние элементы? Уяснить тонкости сортировки нам поможет правдивая история из жизни двух друзей.

Некий фермер — левша по имени Лефт — удостоился чести поставлять арбузы к столу Его Величества. Желая превзойти конкурентов и сохранить за собой королевский заказ, Лефт решил отбирать из урожая самые крупные ягоды (арбуз — это ягода). Выложив арбузы в длинный ряд, Лефт занялся их сортировкой. Работая в одиночку, он применил единственный доступный ему способ — «пузырёк». После трёх дней мучительных сравнений и перестановок Лефт понял, что без помощника ему не обойтись.

Сортировать урожай следующего года он позвал своего соседа и приятеля по имени Райт. Вдвоем они стали работать новым, придуманным Лефтом способом. Лефт стал у первого арбуза, а его приятель Райт побежал в конец ряда. Оттуда Райт стал продвигаться навстречу Лефту, сравнивая арбузы с тем, у которого прохлаждался Лефт (арбузы взвесили заранее, а вес нацарапали на кожуре). Когда Райт находил арбуз легче того, у которого стоял Лефт, их меняли местами: друзья просто швыряли арбузы друг другу.

Наконец Райт вплотную подошел к Лефту, и тогда на месте, где стоял Лефт, оказался самый легкий арбуз. Лефт шагнул ко второму арбузу, а Райт снова побежал в конец ряда, и всё повторилось. По окончании второго цикла на втором месте в ряду, где стоял Лефт, очутился второй по величине арбуз. Теперь первые два арбуза были отсортированы, и Лефт соизволил шагнуть к третьему. К сумеркам, совершив N-1 таких циклов, друзья закончили работу. Лефт, свежий как огурчик, ступил, наконец, к последнему арбузу, недоумевая, отчего его приятель Райт едва волочит ноги?






Рис. 94 – Сортировка массива с встречным движением индексов

Пусть друзья отдыхают, а мы поразмыслим, много ли толку в изобретении Лефта? Поскольку при каждом обмене арбузы перемещались на большое расстояние, то возможно, что таких обменов потребовалось меньше, чем при «пузырьке». Пока это лишь догадка, которую предстоит проверить. А пока соорудим и испытаем процедуру сортировки, придуманную Лефтом, назовём её FarmSort — «фермерская» сортировка.

Программа с процедурой перед вами. Введите её и проверьте, действительно ли процедура Лефта сортирует массив, не ошибся ли фермер?


{ P_43_1 проверка "фермерской" сортировки }


const

      CSize=10; { размер массива }

type

      TNumbers = array [1..CSize] of Integer; { тип для массива }

var

      Arr : TNumbers;       { сортируемый массив }


      { Процедура "фермерской" сортировки }

procedure FarmSort(var arg: TNumbers);

var L, R, T: Integer;

begin

for L := 1 to CSize-1 do

      { Сдвигаем правый индекс влево }

      for R := CSize downto L+1 do begin

      { Если левый элемент оказался больше правого,

      то меняем элементы местами }

      if arg[L] > arg[R] then begin

      { Перестановка элементов массива }

      T:= arg[L]; arg[L]:= arg[R]; arg[R]:= T;

      end;

      end;

end;


      { Процедура распечатки массива, arg – строка сообщения }

procedure ShowArray(const arg: string);

var i: integer;

begin

      Writeln(arg);

      for i:=1 to CSize do Writeln(Arr[i]);

      Readln;

end;

var i: integer;

begin

      { Заполняем массив случайными числами }

      for i:=1 to CSize do Arr[i]:=1+Random(1000);

      ShowArray('До сортировки:');

      FarmSort(Arr);

      ShowArray('После сортировки:');

end.



Быстрая сортировка

«Здесь что-то не так, – стучало в голове Райта, пока он челноком мотался из конца в конец ряда, – почему я бегаю, а он стоит? Это несправедливо! К следующему урожаю я придумаю лучший способ сортировки!».

Через год Лефт опять позвал Райта на помощь.

Хорошо, – согласился Райт, – но теперь командовать буду я.

Пройдясь вдоль ряда, Райт прикинул на глазок вес среднего по величине арбуза. «Запомни этот вес, – сказал он Лефту, – и ступай к началу ряда», – а сам отправился в другой конец. «Теперь иди ко мне, пока не найдешь арбуз тяжелее указанного мною». Лефт так и сделал, – найдя первый такой арбуз, он остановился и крикнул об этом Райту. «Теперь моя очередь!» – отозвался Райт и стал двигаться навстречу Лефту, попутно отыскивая арбуз, легче среднего. Дойдя до такого арбуза, Райт остановился и скомандовал: «Меняем арбузы местами!», – и друзья швырнули арбузы друг другу.

– Снова твоя очередь! – крикнул Райт, – продолжай двигаться ко мне! – а сам присел отдохнуть.

Так поочередно друзья шли навстречу друг другу, время от времени обмениваясь арбузами. Где то в середине ряда они встретились.

– Ну и чем обернулась твоя идея со средним арбузом? – ядовито осведомился Лефт, – мы уже встретились, не отсортировав ни единого!

– Да, – согласился Райт, – зато любой арбуз на твоей левой половине ряда легче любого на моей правой половине.

– Откуда ты знаешь?

– Оттуда! Ведь все твои арбузы легче среднего, а все мои – тяжелее!

– Да, пожалуй, так, но что нам это даёт? – не унимался Лефт.

– А то, что теперь эти две половинки ряда можно сортировать отдельно. Смекнул? Нам меньше бегать придется, ведь расстояния вдвое короче!

– И как же мы будем сортировать эти половинки?

– Тем же порядком, но по очереди, – сначала твою половину, потом мою.

И Райт стал прикидывать средний вес арбузов в левой половине ряда. Этот средний вес был, разумеется, меньше того, что в первом случае. Переведя дух, друзья повторили те же действия с левой половиной ряда. В серединке этой половинки они встретились вновь.

– Видишь, как быстро мы сошлись, – отметил Райт, – а все потому, что ряд стал вдвое короче. Теперь все арбузы в левой четвертинке легче тех, чт


убрать рекламу






о в правой четвертинке. Продолжим действовать так же, и отсортируем четвертинки по отдельности.

И фермеры продолжили дележку ряда: первую четвертинку разбили на две осьмушки, первую осьмушку – на две шестнадцатых и так далее, пока кусочек ряда не съежился до одного-двух арбузов. Этот кусочек они отсортировали моментально и пружина стала раскручиваться в обратную сторону. В конце концов, они вернулись к оставленным ранее частям ряда и отсортировали вторую осьмушку, вторую четвертинку и вторую половинку.

– Готово! – радостно выдохнул Райт. – Гляди-ка, ещё утренняя роса не просохла!

– Нич-ч-чо не понимаю, – сдался Лефт, – но ты, похоже, гений!

И приятели отправились завтракать.


Процедура быстрой сортировки

Друзья заслужили отдых, и теперь наш черед. Возьмем алгоритм Райта и проверим, так ли он хорош?

В целом алгоритм ясен, неясно лишь, как выбрать средний арбуз? В идеале его вес должен быть таким, чтобы половина арбузов в сортируемой части массива была легче среднего, а другая половина – тяжелее. Только тогда массив будет разрублен строго пополам. Увы! У нас нет простого способа найти вес такого арбуза! Даже усреднив веса арбузов в сортируемой части, мы можем не угадать это число.

К счастью, все не так уж плохо. Опыт показал, что делить массив строго пополам совсем не обязательно. Например, при делении ряда в пропорции 1/3 и 2/3 сортировка почти не ухудшится. Значит, можно оценивать вес среднего арбуза «на глазок» (как это делал Райт). Будем вычислять его как среднее арифметическое для трех арбузов: двух крайних и того, что лежит в середине сортируемой части массива.

Тогда формула для определения веса среднего арбуза будет такой:


      Средний вес := (Вес[L] + Вес[(L + R)/2] + Вес [R]) / 3;


Здесь L и R – индексы элементов для начала и конца сортируемой части массива. Повторяю, – это лишь один из возможных вариантов определения среднего веса.






Рис. 95 – Изменения массива при «быстрой» сортировке

Вы принимаете эту формулу? Тогда перейдем к процедуре быстрой сортировки по имени QuickSort (Quickly – «быстро», Sort – «сортировка»). Вот она вместе с проверяющей её программой.


{ P_43_2 QuickSort – Быстрая сортировка }


const CSize=10; { размер массива }

type TNumbers = array [1..CSize] of Integer;

var Arr : TNumbers;


      { Процедура быстрой сортировки }

procedure QuickSort(var arg: TNumbers; aL, aR: Integer);

var

      L, R : integer; { левый и правый индексы }

      M, T : Integer; { среднее значение и временное хранилище }

begin

      { Начальные значения левого и правого индексов }

      L:= aL; R:= aR;

      { Вычисляем среднее по трём (порог для сравнения ) }

      M:= (arg[L] + arg[(L + R) div 2] + arg[R]) div 3;

      repeat       { Цикл встречного движения }

      { Пока левый элемент меньше среднего,

      двигаем левый индекс вправо }

      while arg[L] < M do L:=L+1;

      { Пока правый элемент больше среднего,

      двигаем правый индекс влево }

      while arg[R] > M do R:=R–1;

      { После остановки сравниваем индексы }

      if L <= R then begin

      { Здесь индексы ещё не "встретились", поэтому,

      если левый элемент оказался больше правого,

      меняем их местами }

      if arg[L]>arg[R] then begin

      t:= arg[L]; arg[L]:= arg[R]; arg[R]:= t;

      end;

      { Индексы «делают шаг» навстречу друг другу }

      L:=L+1; R:=R-1;

      end;

      until L > R; { пока индексы не "встретятся" }

      { если левая часть не отсортирована, то сортируем её }

      if R > aL then QuickSort(arg, aL, R);

      { если правая часть не отсортирована, то её тоже сортируем }

      if L < aR then QuickSort(arg, L, aR);

      { выход после сортировки обеих частей }

end;

      { Процедура распечатки массива, arg – строка сообщения }

procedure ShowArray(const arg: string);

var i: integer;

begin

      Writeln(arg);

      for i:=1 to CSize do Writeln(Arr[i]);

      Readln;

end;

var i: integer;

begin       {--- Главная программа ---}

      { Заполняем массив случайными числами }

      for i:=1 to CSize do Arr[i]:=1+Random(1000);

      ShowArray('До сортировки:');

      QuickSort(Arr, 1, CSize);

      ShowArray('После сортировки:');

end.


Взгляните на параметры процедуры QuickSort. Вместе со ссылкой на массив, в процедуру передаются левая (aL) и правая (aR) границы сортируемой части массива (индексы). В процедуре вычисляется вес среднего арбуза по выбранной нами формуле и организуется поочередное встречное движение левого и правого индексов.

Самое интересное происходит после «встречи» индексов, когда массив разбит на две части. Удивительно, что теперь снова дважды вызывается та же самая процедура QuickSort: сначала для левой части массива, а затем – для правой (эти операторы выделены курсивом). Вспомните, – точно так же поступали и фермеры при сортировке арбузов.

«Так там фермеры, а здесь Паскаль! Позволено ль процедуре вызывать саму себя?» – слышу недоверчивый вопрос. Мы свыклись с тем, что из одной процедуры вызывают другую, из второй, – третью и так далее. Но чтобы саму себя? Это ж змея, глотающая свой хвост! Не оттого ли запутался фермер Лефт?


О рекурсии и стеке

Такой самовызов процедур называют рекурсией. «У попа была собака…» – помните? Это рекурсия, познакомимся с нею ближе (с рекурсией, а не собакой).

Легко заметить, что повторные вызовы процедуры QuickSort выполняются с другими значениями левой и правой границ. Чем глубже вызов, тем уже эти границы. С некоторого момента условия (R > aL) и (L < aR) перестают выполняться, и происходит выход из процедуры, – здесь фермеры возвращаются к несортированным частям массива. Таким образом, при выходе мы снова попадаем в эту же процедуру, но в другое место – следующее за вызовом. Окончательный выход из процедуры в главную программу случится только по завершении сортировки всего массива!

Напрашивается вопрос: какова судьба локальных переменных и параметров при повторных входах в процедуру? Ведь они изменятся, а это должно нарушить работу процедуры. Параметры и локальные переменные действительно изменяются, но это не путает алгоритм. Почему?

Разгадка в том, что при каждом входе в процедуру для её параметров и локальных переменных выделяется новый участок памяти. Теперь это будут уже другие параметры и локальные переменные, но с прежними названиями. Однако предыдущие их значения не теряются, а сохраняются в памяти, называемой стеком (Stack).

Что такое стек и как он работает? Случалось ли вам паковать рюкзак или глубокую сумку? Тогда вы знакомы со стеком. Все, что уложено в рюкзак, будет извлекаться из него в обратном порядке. Так же устроен и стек: при каждом вызове процедуры память для параметров и локальных переменных выделяется на его вершине. Эти новые значения временно закрывают предыдущие значения параметров, и так происходит при каждом входе в процедуру.

При выходе из неё последние значения параметров и локальных переменных удаляются с вершины стека, и тогда вновь открываются ранее скрытые. Так процедура «вспоминает» о неоконченной работе, и продолжает действия с параметрами, сохраненными в стеке ранее. В некоторый момент стек пустеет (когда все вещи из рюкзака вынуты), и тогда происходит окончательный выход из процедуры в главную программу.

Механизм стековой памяти заложен в конструкцию процессора, и он не требует участия программиста. Стек используется для любых процедур и функций, а не только рекурсивных.

Но стоп! О стеке поговорим позже, а сейчас займемся делом. Введите программу «P_43_2» и убедитесь в её правильной работе.


Алгоритмы, на старт!

Теперь в нашем распоряжении есть три процедуры сортировки, не устроить ли состязание между ними? На старт вызываются:

• BubbleSort – «пузырьковая» сортировка,

• FarmSort – «фермерская» сортировка,

• QuickSort – быстрая сортировка.

Время «спортсменов» мы будем засекать не по часам. И вы знаете, почему: мы сравниваем алгоритмы, а не компьютеры. В 42-й главе, где сравнивались алгоритмы поиска, мы оценивали время по количеству выполненных шагов. Поступим и здесь похожим образом. Вспомним, в чем состоит сортировка? – в сравнениях и перестановках. И много-много раз… Значит, трудоемкость сортировки можно оценить количеством этих двух операций – сравнений и перестановок, надо их только посчитать.

Что ж, дело нехитрое, сейчас посчитаем, – перед вами программа для наших опытов («P_43_3»). Количество сравнений и перестановок будем накапливать в переменных C1 и C2. Обратите внимание на их тип – EXTENDED, – это переменные действительного типа. Почему не длинное целое? При сортировке больших массивов может потребоваться столь много операций, что не хватит целочисленной переменной, – она переполнится, «лопнет», и результат исказится. Потому выбран тип EXTENDED.

Далее в программе следуют знакомые вам процедуры сортировки, – это наши «спортсмены». В их тела «вживлены» дополнительные операторы для подсчета сравнений (C1) и перестановок (C2), – они выделены курсивом. Наконец, главная программа, – она вызывает по очереди каждую из процедур и печатает количество сравнений и перестановок. Здесь равные условия для соревнующихся создаются загодя сформированным случайным массивом Arr0, который копируется в массив Arr перед каждой сортировкой.

Вам осталось лишь задать размер массива константой CSize, скомпилировать и запустить программу.


{ P_43_3 – Сравнение алгоритмов сортировки }

const CSize=100; { размер массивов }


type TNumbers = array [1..CSize] of Integer;

var Arr0 : TNumbers; { несортированный массив-заготовка }

      Arr : TNumbers; { сортируемый массив }

      C1, C2 : extended; { счетчики сравнений и перестановок }


{ BubbleSort "пузырьковая" сортировка }

procedure BubbleSort(var arg: TNumbers);

var i, j, t: Integer;

begin

      for i:= 1 to CSize-1 do

      for j:= 1 to CSize-i do begin

      C1:=C1+1;  { подсчет сравнений }

      if arg[j] > arg[j+1] then begin

      C2:=C2+1;  { подсчет перестановок }

      t:= arg[j]; arg[j]:= arg[j+1]; arg[j+1]:= t;

      end;

      end;

end;


{ FarmSort – «Фермерская» сортировка }

procedure FarmSort(var arg: TNumbers);

var L, R, T: Integer;

begin

      for L := 1 to CSize-1 do

      for R := CSize downto L+1 do begin

      C1:=C1+1;  { подсчет сравнений }

      if arg[L] > arg[R] then begin

      C2:=C2+1;  { подсчет перестановок }

      T:= arg[L]; arg[L]:= arg[R]; arg[R]:= T;

      end;

      end;

end;

      { QuickSort – Быстрая сортировка }

procedure QuickSort(var arg: TNumbers; aL, aR: Integer);

var

L, R, Mid, T: Integer;

begin

L:= aL; R:= aR;

Mid:= (arg[L] + arg[(L + R) div 2] + arg[R]) div 3;

repeat

      while arg[L] < Mid do begin L:=L+1; C1:=C1+1  end;

      while arg[R] > Mid do begin R:=R-1; C1:=C1+1  end;

      if L <= R then begin

      if arg[L]>arg[R] then begin

      C2:=C2+1;  { подсчет перестановок }

      t:= arg[L]; arg[L]:= arg[R]; arg[R]:= t;

      end;

      L:=L+1; R:=R-1;

      end;

      until L > R;

      if R > aL then QuickSort(arg, aL, R);

      if L < aR then QuickSort(arg, L, aR);

end;

const CFName = 'P_43_3.out';


var i: integer;

F: text;

begin

Assign(F,CFName); Rewrite(F);

for i:=1 to CSize do Arr0[i]:=1+Random(10000);

Writeln(F, 'Размер массива = ', CSize);

Writeln(F, 'Алгоритм       Количество Количество');

Writeln(F, 'сортировки сравнений перестановок');

C1:=0; C2:=0;        { очистить счетчики }

Arr:= Arr0;       { заполнить сортируемый массив }

BubbleSort(Arr);

Writeln(F, 'Пузырьковая:', C1:12:0, C2:12:0);

C1:=0; C2:=0;        { очистить счетчики }

Arr:= Arr0;       { заполнить сортируемый массив }

FarmSort(Arr);

Writeln(F, 'Фермерская :', C1:12:0, C2:12:0);

C1:=0; C2:=0;        { очистить счетчики }

Arr:= Arr0;       { заполнить сортируемый массив }

QuickSort(Arr, 1, CSize);

Writeln(F, 'Быстрая :', C1:12:0, C2:12:0);

Writeln('OK !'); Readln;

Close(F);

end.


Вот что получилось для массива из 1000 элементов.


Размер массива = 1000

Алгоритм       Количество Количество

сортировки сравнений перестановок

Пузырьковая: 499500       248061

Фермерская : 499500       80887

Быстрая :       5871       2417


Я провел три опыта с массивами из 100, 1000 и 10000 элементов, а результаты занес в две таблички. Что сказать по этому поводу?

Табл. 9 – Количество сравнений в разных методах сортировки

Размер массива «Пузырьковая» сортировка «Фермерская» сортировка Быстрая сортировка
100 4 950 4 950 417
1 000 499 500 499 500 5 871
10 000 49 995 000 49 995 000 79 839

Из табл. 9 следует, что по количеству сравнений «Фермерская» сортировка не лучше «пузырька». Зато быстрая сортировка оправдывает свое название, – выигрыш составляет от 10 до 600 раз! И чем больше массив, тем заметней этот разрыв.

Табл. 10 – Количество перестановок в разных методах сортировки

Размер массива Пузырьковая сортировка Фермерская сортировка Быстрая сортировка
100 2 305 805 141
1 000 248 061 80 887 2 417
10 000 24 903 994 6 154 077 31 011

А что с количеством перестановок (табл. 2)? Здесь «фермерская» сортировка всё же в 3—4 раза обгоняет «пузырёк». Так что фермеру Лефту в сметливости не откажешь. И всё же этому «спортсмену» далеко до изобретения Райта! В сравнении с «пузырьком» выигрыш стократный, и стремительно растёт с ростом размера массива. Слава, слава фермеру Райту! Кстати, историки выяснили его настоящее имя: это англичанин Чарльз Хоар.






Рис.96 – Кто здесь чемпион?

Итак, с чемпионом все ясно (рис. 96), но в чем секрет его успеха? Сравним чемпиона с отставшими. Чем больше массив, тем дольше он сортируется, – это справедливо для любого алгоритма. Долгие методы обрабатывают весь массив N раз, где N – размер массива. Поэтому их трудоемкость пропорциональна произведению N•N. По этой формуле вычисляют площадь квадрата, и такую зависимость называют квадратичной.

Иное дело – чемпион. Дробя массив на мелкие участки, быстрый алгоритм уменьшает число прохождений всего массива до величины Log2N. Поэтому его трудоемкость растёт пропорционально произведению N•Log2N. Опять логарифм? Да, мы помним его по двоичному поиску. Поскольку логарифм числа растёт очень медленно, это объясняет чемпионство QuickSort (рис. 97).






Рис.97 – Рост трудоемкости сортировки с ростом размера массива

Итоги

• Двоичный поиск – это самый быстрый способ поиска, но он требует предварительной сортировки массива.

• Простые методы сортировки – BubbleSort и FarmSort – работают очень медленно, съедая всю экономию от двоичного поиска.

• QuickSort – это быстрый способ сортировки, который в сочетании с резвым двоичным поиском ускорит работу ваших программ.


А слабо?

А) Исследуйте процедуру быстрой сортировки в пошаговом режиме (задайте небольшой размер сортируемого массива). Обратите внимание на изменение границ сортируемой части.

Б) Определите количество повторных входов в процедуру QuickSort и выходов из нее. Объявите глобальную переменную, назовем её Level – «уровень». В главной программе, перед вызовом процедуры QuickSort, эту переменную надо обнулить, а внутри процедуры добавить следующие операторы.

В начале процедуры QuickSort:


begin

      Inc(Level); Writeln('Уровень на входе = ', Level);


В конце процедуры QuickSort:


      Dec(Level); Writeln('Уровень на выходе = ', Level);

end;


В) Если каждый вызов QuickSort делит массив примерно пополам, то наибольшее значение переменной Level должно составить приблизительно Log2N (у нас размер массива задан константой CSize). Проверьте эту догадку компиляцией и запуском программы для нескольких значений CSize.

Г) В одном ряду вперемежку лежат дыни и арбузы. Могут ли фермеры отсортировать их за один проход ряда так, чтобы в начале оказались все дыни, а в конце ряда – все арбузы? Напишите такую программу, обозначив арбузы единицами, а дыни – нулями.

Глава 44

Строки

 Сделать закладку на этом месте книги




Строковый тип STRING известен нам с первых глав книги, без него компьютер не общался бы с нами на «человечьем» языке. Так изучим строки получше. В современных версиях Паскаля применяют несколько строковых типов, сейчас мы рассмотрим только короткие строки, введенные ещё в Borland Pascal (в новых версиях Паскаля этот тип называется ShortString).


Строка – особый род массива

С первого взгляда строка похожа на массив символов. Так ли это? – проверим. Известно, что строка может вместить до 255 символов. Объявим массив из 255 символов и сравним его размер с размером строки. Напомню, что функция SizeOf возвращает размер памяти, занимаемой переменной.


var S1 : array [1..255] of CHAR; { это массив из 255 символов }

      S2 : String;       { это строка длиной 255 символов }

begin

      Writeln (SizeOf(S1)); { печатает 255 }

      Writeln (SizeOf(S2)); { печатает 256 }

      Readln;

end.


Запустили программку? И что? Странно, но размер строки S2 оказался равным 256 байтам, что на единицу больше размера массива. Почему? Где прячется ещё один байтик? Ответ представлен на рис. 98.






Рис.98 – Размещение слова «PASCAL» в строковой переменной

Здесь показана внутренность строковой переменной со словом «PASCAL». Байты с 1-го по 6-й содержат буквы этого слова, а остальные байты не заняты. Но в начале массива обнаружен ещё один байт – с нулевым индексом. Он содержит число 6 – это длина слова «PASCAL». Значит, строковый тип – это массив со скрытым нулевым байтом, хранящим фактическую длину строки (эту длину возвращает функция Length).


Укороченные строки

Память – жилище переменных – всегда чем-нибудь занята. Даже пустая строка (нулевой длины) занимает 256 байтов памяти, и содержит что либо. Это «что либо» программисты называют мусором, а мусор никому не интересен. Так разумно ли отводить 256 байтов для строки, если большая её часть забита всяким вздором? Ведь память – ценный ресурс, и профессионал бережет её. К примеру, для строки, хранящей фамилию, вполне хватило бы и 20 байтов.

Это понимали и создатели Паскаля, они позаботились об экономии памяти. Строковые типы можно объявлять с указанием длины. Для этого после слова STRING в квадратных скобках указывают нужный размер строки, например:


type TStrA = string[11]; { строка для 11 символов }

      TStrB = string[31]; { строка для 31 символа }

var A : TStrA;       B : TStrB;


Здесь объявлены два строковых типа данных; первый из них вмещает до 11 символов, а второй – до 31. Соответственно переменная A будет занимать в памяти 12 байтов, а переменная B – 32 байта (с учетом нулевого байта). Согласитесь, – экономия солидная, особенно для массива из таких строк. Во всем остальном, кроме размера, короткие строки ничем не отличаются от переменных типа STRING.

А что случится при копировании длинной строки в короткую? А ничего, – не вместившиеся символы будут «отрублены». Следующая ниже программа «P_44_1» подтверждает это, испытайте её.


{ P_44_1 – укороченные строки }

var S1 : string;       { размер строки по умолчанию = 255 }

      S2 : string[5]; { размер укороченной строки = 5 символов }

begin

S1:='abc';       S2:='abcdefgh';


Writeln('Строка S1: Размер =', SizeOf(S1):4,' Длина = ', Length(S1):4,' Значение= '+S1);

Writeln('Строка S2: Размер =', SizeOf(S2):4,' Длина = ', Length(S2):4,' Значение= '+S2);


Writeln('Нулевой байт строки S1 = ', Byte(S1[0]));

Writeln('Нулевой байт строки S2 = ', Byte(S2[0]));

Readln;

end.



Операции со строками

Итак, уяснив внутреннее устройство строк, обратимся к связанным с ними операциям. Что мы умеем делать со строками сейчас? А вот что:

• вводить и выводить строки процедурами ввода и вывода;

• объединять несколько строк в одну (складывать);

• определять длину строки функцией Length;

• проверять строки на равенство и неравенство;

• обращаться к отдельным символам строки (доступ по индексу).

Учитывая важность строкового типа, разработчики Паскаля предусмотрели для строк ещё несколько процедур и функций, позволяющих:

• искать одну строку внутри другой;

• копировать часть строки в другую строку;

• вставлять одну строку внутрь другой;

• удалять часть символов из строки;

• сравнивать две строки в смысле алфавитного порядка.

Рассмотрим всё это подробней. Представленные далее объявления процедур и функций даны мною лишь для пояснений, их не надо вставлять в программы.

Поиск в строке (Pos)

Функция Pos ищет одну строку внутри другой, её объявление выглядит так:


      function Pos(SubS: string; S: string): Integer;


Функция принимает два параметра:

• SubS – подстрока, которую ищут (то есть фрагмент строки);

• S – строка, в которой ищут.

Если искомый фрагмент SubS найден, функция возвращает его позицию – индекс первого символа SubS внутри строки S, а иначе возвращает ноль. Если строка S содержит несколько искомых фрагментов, возвращается индекс первого из них. Вот примеры.


      S:= 'BORLAND PASCAL';

      p:= Pos('LA', S);       { 4 }

      p:= Pos('PAS', S);       { 9 }

      p:= Pos('pas', S);       { 0 – подстрока не найдена }

      p:= Pos('A', S);       { 5 – первая из трех букв "A" }


Искомым фрагментом может быть и отдельный символ. Поиск ведется с учетом регистра; это значит, что заглавная и строчная буквы «P» считаются разными буквами.

Копирование части строки (Copy)

Функция Copy возвращает часть заданной строки.


      function Copy(S: string; Index, Count: Integer): string;


Входных параметров три:

• S – строка, из которой копируются символы;

• Index – индекс первого копируемого символа;

• Count – количество копируемых символов.

А вот примеры её применения.


      S:= ’Free Pascal forever!’;

      T:= Copy(S, 6, 6);       { ’Pascal’ }

      T:= Copy(S, 6, 255); { ’Pascal forever!’ }


Если копируемых символов затребовано больше, чем содержится в исходной строке, то скопируются все символы до конца строки (как в последнем примере).

Вставка в строку (Insert)

Объединять строки сложением просто. А если надо вставить строку в середину другой? Тогда обратитесь к процедуре Insert.


      procedure Insert(S1: string; var S2: string; Index: Integer);


Входные параметры:

• S1 – вставляемая строка;

• S2 – ссылка на принимающую строку;

• Index – позиция вставки.

Вот один пример.


      S:='Спартакчемпион!';

      { В позицию 8 вставляются три символа: тире и два пробела }

      Insert(' – ', S, 8);       { Спартак – чемпион! }


Если позиция вставки превышает длину строки S2, то строка S1 добавится в конец S2. Если длина итоговой строки S2 превысит допустимый размер, лишние символы будут отброшены.

Удаление символов из строки (Delete)

Говорят: ломать – не строить. Попытайтесь, однако, удалить часть символов из строки. Слабо? А процедура Delete справляется с этим играючи.


      procedure Delete(var S: string; Index, Count : Integer);


Параметры таковы:

• S – ссылка на строку;

• Index – индекс первого удаляемого символа;

• Count – количество удаляемых символов.

Вот пример её применения.


      S:= ’Free Pascal forever!’;

      Delete(S, 6, 7);       { ’Free forever!’ }


Сравнение строк

Мы уже сравнивали строки на равенство (вспомните проверку пароля). Но строки сравнивают и на больше–меньше — лексикографически. При этом сравниваются слева направо коды символов двух строк в смысле их алфавитного порядка. Если длины строк разные и короткая совпадает с началом длинной, то большей считается длинная строка. Вот примеры:


      Writeln (’Borland’ > ’Pascal’); { false }

      Writeln (’ABC’ > ’AB’);   { true }

      Writeln (’ABC’ > ’abc’);  { false }

      Writeln (’45’ > ’1000’);  { true, поскольку ’4’ > ’1’ }


В первом примере код буквы «B» меньше кода буквы «P», поэтому левая строка меньше правой. Во втором случае первые символы совпадают, но левая строка длиннее, а значит больше. В третьем примере левая строка меньше, — тоже в соответствии с таблицей кодировки. Обратите внимание на неожиданный результат сравнения строк, составленных из цифр, — это вам не числа!

Сравнивая строки, можно отсортировать их в лексикографическом порядке (как если бы они располагались в словаре). К сожалению, такое сравнение работает только для латинских букв, для русских оно не всегда верно, приходится изобретать свою функцию сравнения (в DELPHI этой проблемы нет).

Перевод символов в верхний регистр (UpСase)

Функция UpСase меняет код латинской буквы, переводя её из нижнего в верхний регистр. Иными словами, она превращает строчную (малень


убрать рекламу






кую) латинскую букву в заглавную (большую). Объявление функции таково.


      function UpCase(Ch: Char): Char;


Входной параметр – символ, а возвращается почти тот же символ, только «подросший», вот примеры.


      c:= UpCase(’r’);       { ’R’ }

      c:= ’n’;

      c:= UpCase( c );       { ’N’ }


Подсунув этой функции большую латинскую букву, цифру или знак препинания, вы получите назад свой символ неизменным. То же будет и с русскими буквами – они не обрабатываются функцией UpСase.


      c:= UpCase(’R’);       { ’R’ }

      c:= UpCase(’8’);       { ’8’ }

      c:= UpCase(’ы’);       { ’ы’ }


Функцией UpСase обычно приводят введенные строки к определенному виду. Ведь пользователь может ввести данные как заглавными, так и строчными буквами, а это иногда мешает правильной обработке строки.

Ознакомившись со строковой теорией, применим её, что называется, «в бою».


Подсчет слов в строке

Вот вам строка, посчитайте в ней количество слов «Pascal». Чуть подумав, вы остановитесь на функции Pos, – ведь она возвращает позицию искомого слова. Но функция обнаруживает лишь первое вхождение фрагмента, а как быть с остальными? Я предлагаю постепенно разрушать исходную строку. То есть, найдя искомый фрагмент, будем удалять его из строки и снова повторять поиск. На этом и построена программа «P_44_2».


{ P_44_2 - Подсчет слов «PASCAL» в строке }

var S : string; { исходная строка }

      p : integer; { позиция в строке }

      c : integer; { счетчик слов }

begin

S:='Лучший язык программирования – это PASCAL!'+

      'Изучите PASCAL! PASCAL не подведет!';

c:=0;

repeat

      p:= Pos('PASCAL', S); { ищем слово «PASCAL» }

      if p>0 then begin       { если нашли }

      Inc(c);       { то наращиваем счетчик }

      { и удаляем это слово из строки }

      Delete(S, p, Length('PASCAL'));

      end

until p=0;       { выход, если слов «PASCAL» больше нет }

Writeln('Найдено слов PASCAL: ',c); Readln;

end.



Контекстная замена

Любой текстовый редактор умеет заменять одну подстроку на другую, – это называется контекстной заменой. Устроим такую замену в строковой переменной. Итак, дана строка, содержащая несколько слов «Pascal». Заменим все вхождения слова «Pascal» словом «Паскаль» (чем не англо-русский переводчик?).

Разобравшись с предыдущей задачей, вы легко одолеете и эту. Для проверки вашего решения сравните его с моим («P_44_3»).


{ P_44_3 - Замена слов «Pascal» на «Паскаль» }

var S : string; { исходная строка }

      p : integer; { позиция в строке }

begin

S:='Лучший язык программирования – Pascal! '+

      'Изучите Pascal! Pascal не подведет!';

Writeln(S); { исходная строка }

repeat

      p:= Pos('Pascal', S);       { ищем слово 'Pascal' }

      if p>0 then begin       { если нашли }

      { удаляем это слово из строки }

      Delete(S, p, Length('Pascal'));

      { и вставляем в этом месте слово 'Паскаль'}

      Insert('Паскаль', S, p);

      end

until p=0; { выход, если слов 'Pascal' больше нет }

Writeln(S); { строка результата }

Readln;

end.



Итоги

• Строка родственна массиву символов. Дополнительный нулевой элемент этого массива содержит длину строки.

• Строка, объявленная без указания размера, по умолчанию занимает 256 байтов памяти и может содержать до 255 символов.

• Для экономии памяти используют строки меньшего размера. При объявлении таких строк размер указывают внутри квадратных скобок после слова STRING.

• В Паскале предусмотрен ряд встроенных процедур и функций, облегчающих обработку строк.


А слабо?

А) Напишите процедуру, переводящую все символы строки (латинские буквы) к верхнему регистру.

Б) Напишите функцию для приведения любой буквы к верхнему регистру (включая и русские). Подсказка: вспомните о таблице кодировки.

В) Напишите функцию для приведения любой буквы к нижнему регистру.

Г) Напишите собственные процедуры и функции обработки строк, повторяющие те, что встроены в Паскаль. Дайте им названия, похожие на стандартные, например: MyCopy, MyDelete и так далее.

Д) Вращение строки вправо. Напишите процедуру, перемещающую 1-й символ строки на место 2-го, 2-й – на место 3-го и т.д. Последний символ должен занять 1-е место. Примените средства обработки строк.

Е) Вращение строки влево. Напишите процедуру для перемещения 2-го символа на место 1-го, 3-го – на место 2-го и т.д. Первый символ должен стать последним.

Ж) Строка содержит несколько слов – предложение. Напишите программы для решения следующих задач.

• Напечатать в столбик отдельные слова введённого предложения.

• Определить количество слов в строке.

• Равномерно расставить пробелы между словами так, чтобы удлинить строку до 80 символов (исходная строка короче 80).

З) Напишите булеву функцию, определяющую, является ли строка (параметр) палиндромом. Палиндром читается одинаково в обоих направлениях.

И) Напишите булеву функцию, определяющую, можно ли из букв первого слова составить второе (например, «клавиша» и «вилка» – TRUE). Учитывается только набор букв, а не их количество. Подсказка: примените множества.

К) Дана строка, содержащая не менее трёх символов. Найти в ней три стоящих подряд символа, дающих максимальную сумму своих кодов.

Л) В строке найти возрастающую последовательность символов наибольшей длины (сравнивайте коды символов).

М) Напишите булеву функцию, проверяющую, следуют ли символы строки по неубыванию своих кодов.

Н) Напишите функцию для шифрования строки путём перестановки её символов, расположенных на нечётных позициях: первый символ обменивается с последним, третий – с третьим от конца и т.д.

Глава 45

Очереди и стеки

 Сделать закладку на этом месте книги




Хорошей вещи найдется уйма применений. Взять хотя бы строки, из которых мы построим сейчас инструменты системных программистов – очереди и стеки.

Для меня системные программисты – это боги, ступившие на землю (не путайте их с системными администраторами!). Операционные системы, компиляторы, вирусы и антивирусы – это их мозгов дело. Настоящего системщика я видел лишь разок, да и то издали. Таинственное системное программирование! – дерзнем ли коснуться его? Почему нет? Надо же когда-то начинать! Ведь стеки и очереди отчасти вам знакомы.


Вовочка в потоке событий

Переживайте неприятности по мере их поступления – эта житейская мудрость касается любого из нас. Жизнь – это поток событий, барахтаясь в котором, мы поминутно решаем: прервать ли начатое дело и хвататься за другую проблему? Или отложить эту новую проблему «на потом»?

Смотрите: вот компьютер и Вовочка, мирно играющий в «звездные войны». Входит мама: «Вова, ты уроки сделал?». Вова неохотно откладывает игру и приступает к урокам. Через полчаса мама снова беспокоит его: «Вовочка, я не могу отойти от плиты. Сгоняй-ка быстро за луком». Уроки откладываются, и Вова отправляется в магазин. По пути он видит гоняющих мяч приятелей, – им не хватает вратаря. Как не помочь друзьям? Поход в магазин откладывается, и Вовочка на страже ворот. Делу время, а потехе час. Закончилась игра, и можно выполнить мамино поручение. Купив луку, Вова доделывает отложенные уроки и возвращается к первому занятию – «звездным войнам».

Вовочка обрабатывал события по принципу стека, – скажет об этом системный программист. Другое название стека – дисциплина обслуживания LIFO, что значит «Last-In, First-Out», или по-русски: «последним пришел – первым ушел». Мы соприкоснулись со стеком, разбирая рекурсивную процедуру быстрой сортировки. Помните пример с укладкой рюкзака? А вот ещё пример: магазин для патронов. Патрон, вставленный в магазин последним, выстрелит первым, и наоборот.

Итак, пример с Вовочкой показал, что важные события мы обслуживаем по принципу стека.

А очередь? Какое отношение к нам имеет этот символ потерянного времени? Заметив, как «тормозит» порой ваш компьютер, вспомните о ней. Иногда компьютер реагирует на мышку и клавиатуру с заметным опозданием, но не забывает о нажатиях и щелчках. Они накапливаются в очереди, а затем извлекаются оттуда и обрабатываются.

Или другой пример – печатание документов на сетевом принтере. Когда принтер занят, операционная система ставит запросы на печать в очередь. А затем – по мере готовности принтера – выбирает файлы из этой очереди и отправляет принтеру.

За очередью тоже закрепилось свое сокращение – FIFO, что значит «First-In, First-Out» – «первым пришел, первым ушел». В отличие от стека, в очередь попадают маловажные события.

Обратите внимание, что элементами очередей и стеков может быть что угодно: события, предметы и даже люди. Рассмотрим два примера: запись в танцевальный кружок и сортировочную горку.


Танцевальный кружок

В городе набирали детей в кружок бального танца. Запись в кружок вела преподающая в нём дама. Приходящих мальчишек и девчонок она стремилась объединять в пары при первой возможности с тем, чтобы они сразу приступали к занятиям. Однако на запись дети приходили поодиночке в разное время и в случайном порядке, – то несколько мальчиков подряд, то несколько девочек. Дама не слыхала о системном программировании, а потому прибегла к здравому смыслу. Взяв пару записных книжек, она поступала так.

Если к ней являлось больше мальчиков, дама заносила их в мальчишечью записную книжку, то есть, ставила в очередь. Приняв девочку, она выбирала из этой очереди первого мальчика и составляла пару. Если же являлось больше девочек, то дама ставила их в девчоночью очередь (в другой записной книжке), а с приходом очередного мальчика составляла новую пару. Так, в порядке поступления, составлялись пары мальчиков и девочек.

Пусть наша новая программа повторит действия танцевального тренера, – инженеры называют это моделированием. Работать будем, конечно, не с живыми детьми, мы представим их как-то иначе. Условимся обозначать их латинскими буквами: девочек – строчными, а мальчиков – заглавными (только потому, что они выше ростом).






Рис. 99 – Запись в танцевальный кружок

Теперь станьте на место учителя: к вам приходят то мальчик, то девочка, но вы не знаете, кто будет следующим, – это поток, и в нём доступен только первый его элемент. Организовать входной поток можно посимвольным вводом «мальчиков» и «девочек». Но мы сделаем ещё проще: представим поток детишек строкой, и будем считать, что к преподавателю они являются слева направо по одному. Например, строка


      ZHJKqwertASDyuiopQWERTYUIOPasdf


означает, что первым явится мальчик по имени Z, а последней – девочка по имени f. Первая пара составится из мальчика Z и девочки q. Это упрощение не меняет сути нашей модели, но избавляет её от второстепенных деталей.

Итак, с учетом всех договоренностей, явим задачу в окончательном виде. Дана строка, состоящая из больших и маленьких букв латинского алфавита – «мальчиков» и «девочек». Мы должны сформировать другую строку, состоящую из тех же символов, но следующих попарно: сначала большая буква – «мальчик», затем маленькая – «девочка». Пары разделяются пробелом. Например, для указанной выше строки, пары должны быть составлены так:


      Zq Hw Je Kr At Sy Du Qi Wo Ep Ra Ts Yd Uf


А напоследок программа должна напечатать имена тех, кто временно остался без пары. Здесь это будут пришедшие в числе последних мальчики I, O и P.

Если логика программы вам ясна, разрешим теперь главный вопрос: как организовать очередь символов? Ведь очередь – это не просто массив данных, а механизм, содержащий и хранилище данных и процедуры для работы с ними.

Сделаем так. Элементы очереди – символы – будем хранить в строковых переменных. К ним добавим ещё две процедуры: одну – для установки элемента в очередь, другую (это будет функция) – для извлечения из очереди первого элемента. Назовем их соответственно PutInQue – «поставить в очередь» и GetFromQue – «извлечь из очереди» (Queue – «очередь» или «хвост»). Всё это представлено в программе «P_45_1».


{ P_45_1 – Запись в танцевальный кружок }


{ Постановка символа arg в очередь Que }


procedure PutInQue(var Que: string; arg: char);

begin

Que:= Que + arg; { добавляем в конец строки }

end;


{ Выбор из очереди Que элемента в параметр arg }


function GetFromQue(var Que: string; var arg: char): boolean;

begin

if Length(Que) = 0       { если очередь пуста }

      then GetFromQue:= false

      else begin

      GetFromQue:= true;       { если не пуста }

      arg:= Que[1];       { запоминаем первый элемент }

      Delete (Que, 1, 1); { и удаляем его из очереди }

      end

end;


      { Глобальные переменные }

var S_IN : string; { входной поток – символы }

      S_OUT : string; { выходной поток (пары) }

      Boys : string; { очередь мальчиков }

      Girls : string; { очередь девочек }

      c1,c2 : char; { очередная пара – символы строки }

      i : integer;       { индекс во входном потоке }


begin {--- Главная программа ---}


{ задаем (вводим) входной поток: A..Z – мальчики, a..z – девочки }

S_IN:='ZHJKqwertASDyuiopQWERTYUIOPasdf';

S_OUT:='';       { выходной поток пока пуст }

Boys:=''; Girls:=''; { Очищаем очереди мальчиков и девочек }


{ Цикл обработки входного потока }

for i:=1 to Length(S_IN) do begin

      c1:= S_IN[i]; { выбираем из входного потока }

      if c1 in ['A'..'Z']

      then begin { если это мальчик…}

      { если в очереди есть девочка }

      if GetFromQue(Girls, c2)

      { добавляем пару в выходной поток }

      then S_OUT:= S_OUT+c1+c2+’ ’

      { а иначе помещаем мальчика в очередь }

      else PutInQue(Boys, c1);

      end

      else begin { а если это девочка…}

      { если в очереди есть мальчик }

      if GetFromQue(Boys, c2)

      { добавляем пару в выходной поток }

      then S_OUT:= S_OUT+c2+c1+’ ’

      { а иначе помещаем девочку в очередь }

      else PutInQue(Girls, c1);

      end

end;

Writeln('Входной поток:' );

Writeln(S_IN);

Writeln('Выходной поток:' );

Writeln(S_OUT);


if Length(Boys)>0 then begin

      Writeln('В очереди мальчиков остались:' );

      Writeln(Boys);

end;


if Length(Girls)>0 then begin

      Writeln('В очереди девочек остались:' );

      Writeln(Girls);

end;

Readln;

end.


Процедура PutInQue просто добавляет символ в конец строки. Строго говоря, если длина строки достигнет 255, то новый символ не попадет в очередь. Но мы не станем усложнять программу дополнительными проверками, – считаем, что емкости очереди нам достаточно.

Но для функции GetFromQue, выбирающей из очереди первый символ, контроль строки на пустоту необходим, иначе работа модели нарушится. Функция возвращает состояние очереди, бывшее до извлечения символа (TRUE, если очередь не была пуста). А сам извлекаемый символ возвращается через параметр arg, – это ссылка на символьную переменную. Вот, пожалуй, и вся премудрость. Испытайте эту программу. Добавьте операторы печати для наблюдения за очередями.


Скитания товарного вагона

Прежде, чем углубиться в стек, вникнем в работу железной дороги. Вы знаете, как железнодорожники доставляют товарный вагон из пункта «А» в пункт «Б»? «Очень просто, – скажете, – цепляют к составу и тащат!» Тогда взгляните на рис. 100.






Рис.100 – Доставка вагонов между несколькими станциями

Здесь показаны пять железнодорожных станций, четыре из которых обозначены цифрами, а пятая – узловая станция – буквой «У». Предположим, что со станции «1» надо доставить несколько десятков вагонов на другие станции (по направлению стрелок). С этих станций тоже везут вагоны, но соответствующие стрелки я не показал. Тащить вагоны поодиночке разорительно! Поэтому их собирают в составы по нескольку десятков вагонов. Накопив такой состав на станции «1», железнодорожники доставляют его на узловую станцию; сюда же стекаются составы с других направлений. На узловой творится самое интересное, – здесь из одних составов формируют другие с тем, чтобы тащить их далее в нужном направлении. Эта работа называется сортировкой состава. В нашей стране сотни товарных станций, многие из которых узловые. Прежде чем попасть по назначению, вагон кочует между узловыми станциями, проходя через несколько сортировок. А вы говорите: просто, просто!

Но это ещё присказка, – сказка впереди.


Сортировочная горка

Итак, на узловых станциях формируют новые составы с тем, чтобы каждый вагон следовал далее в нужном направлении. Для сортировки устроены так называемые сортировочные горки. Горка – это слегка наклоненный участок пути; если отцепить от стоящего на нём состава вагон, последний покатится под горку. Но укатится недалеко, – под горкой устроено несколько тупиков. Тупик – это обычное состояние программиста, но здесь я говорю о других тупиках, железнодорожных. Это участки пути, ограниченные с одной стороны земляным валом. Уткнувшись в этот вал, вагон остановится. Горка соединяется с тупиками железнодорожными стрелками, переключая которые можно направить катящийся с горки вагон в тот или иной тупик (рис. 101).






Рис.101 – Схема сортировочной горки

Как сортируют состав? Основную работу выполняют двое: сцепщик и стрелочник (который всегда виноват!). От стоящего на горке состава сцепщик отсоединяет по очереди вагон за вагоном и сообщает стрелочнику по рации, в который из тупиков направить очередной вагон, – тому остается лишь переводить свои стрелки. Вкатившись в тупик, вагон тормозится земляным валом или слегка соударяется с уже стоящим там вагоном и автоматически сцепляется с ним. «Разбросав» по тупикам один состав, на горку выкатывают другой и продолжают сортировку, пока в тупиках не сформируются новые составы, готовые к дальнейшему пути.

Наша цель: смоделировать сортировочную горку, то есть создать программу, ведущую себя подобно такой горке. Вагоны заменим символами; следовательно, и состав и стоящие в тупиках вагоны мы представим строками. Будем считать первый символ строки первым вагоном состава, – он прицеплен к локомотиву. В тупике первым будет вагон, стоящий у земляного вала. Легко догадаться, что обрабатывать вагоны будем по принципу стека, поскольку сцепщику всегда доступен только последний вагон.

Договорившись об этом, сформулируем задачу окончательно. Дана строка символов (состав), из которой надо сформировать три других. Вагоны, обозначенные большими буквами ’A’…’Z’, отправим на станцию «A»; другие, обозначенные маленькими буквами ’a’…’z’, – поедут к станции «B», а третьи, обозначенные цифрами ’0’…’9’, – к станции «C». Программа должна сформировать три строки – это вновь собранные составы. Первый символ в них, – это вагон, прицепленный непосредственно к локомотиву.

Для решения задачи надо всего лишь в точности повторить действия сцепщика и стрелочника. Будем «отцеплять» символы от строки и «заталкивать» их в стеки – это наши тупики. Значит, надо построить механизм для стеков. Он будет похож на механизм для очереди: элементы храним в строковых переменных, а для занесения и извлечения элементов из стека учредим две процедуры. По традиции программисты называют эти процедуры так: Push – затолкнуть в стек, и Pop – вытолкнуть из стека.

Процедура заталкивания в стек Push присоединяет символ к концу строки. Она точь-в-точь повторяет процедуру установки в очередь, только называется иначе.

А функция выталкивания из стека Pop возвращает последний символ строки, одновременно удаляя его оттуда. Если же стек окажется пуст, функция сообщит об этом. Сходство с функцией извлечения из очереди очевидно, разница лишь в позиции извлекаемого символа: для очереди это первый символ, а для стека – последний.

Теперь вам не составит труда разобраться в показанной ниже программе «P_45_2». Обратите внимание на отцепку вагонов от исходного состава: она тоже выполняется функцией выталкивания Pop, поскольку исходный состав трактуется как непустой стек.


{ P_45_2 – Сортировочная станция }


{ Помещение элемента в стек }

procedure Push(var aStack: string; arg: char);

begin

      aStack:= aStack + arg; { добавляем в конец строки }

end;


{ Извлечение элемента из стека }

function Pop(var aStack: string; var arg: char): boolean;

begin

if Length(aStack) = 0 { если стек пуст }

      then Pop:= false       { сообщаем об этом }

      else begin

      { возвращаем последний элемент }

      arg:= aStack[Length(aStack)];

      { и удаляем его из стека }

      Delete(aStack, Length(aStack), 1);

      Pop:= true; { признак того, что стек не был пуст }

      end;

end;


var S : string;       { исходный состав }

      SA, SB, SC : string; { три сортировочных тупика A,B,C}

      c : char;       { очередной вагон }

begin

S:= 'HEjd31kDJK62px912se3BKdwL9'; { Исходный состав }

Writeln('Исходный состав: '+S);

SA:=’’; SB:=’’; SC:=’’; { очистка тупиков }

{ Отцепляем вагоны от исходного состава и заталкиваем в тупики }

while Pop(S, c) do begin

      if c in ['A'..'Z'] then Push(SA, c);

      if c in ['a'..'z'] then Push(SB, c);

      if c in ['0'..'9'] then Push(SC, c);

end;

{ Теперь исходный состав пуст, то есть S='' }

{ Выкатываем вагоны из тупика A и цепляем к первому составу }

while Pop(SA, c) do Push(S, c);

Writeln('На станцию A : '+S);

S:=''; { Освобождаем пути }

{ Выкатываем вагоны из тупика B и цепляем ко второму составу }

while Pop(SB, c) do Push(S, c);

Writeln('На станцию B : '+S);

S:=''; { Освобождаем пути }

{ Выкатываем вагоны из тупика C и цепляем к третьему составу }

while Pop(SC, c) do Push(S, c);

Writeln('На станцию C : '+S);

Readln;

end.


Вы познакомились с механизмами очередей и стеков. Мы построили их на основе символьных строк, но в системном программировании это делается иначе, и скоро вы узнаете об этом больше.


Итоги

• Очереди и стеки – это механизмы, применяемые в системных программах. Элементами очередей и стеков могут быть любые объекты.

• Очередь обслуживает элементы по принципу «первый пришел – первый ушел» или сокращенно FIFO (First-In, First-Out).

• Стек обслуживает элементы по принципу «последний пришел – первый ушел» или сокращенно LIFO (Last-In, First-Out).


А слабо?

А) Исследуя модель танцевального кружка, можно заметить, что в любой момент одна из двух очередей обязательно пуста. В самом деле, если приходит больше мальчиков, то будет пуста девчоночья очередь и наоборот. Можно ли обойтись одной очередью? Придумайте, как это сделать.

Подсказка: добавьте функцию для тестирования очереди с тем, чтобы выяснить, не пуста ли она. И, если не пуста, то кто томится в ней – мальчик или девочка? Эта функция не должна изменять состояние очереди.

Б) На реальных станциях на горку последовательно загоняют несколько составов, а уж потом освобождают тупики. Добавьте в модель сортировочной горки возможность такой обработки. Исходные составы (строки) должны вводиться с клавиатуры, признак окончания ввода – пустая строка. Совет: выделите действия по сортировке одного состава в отдельную процедуру.

В) Постройте механизмы очереди и стека на базе массива символов, а не на базе строки. Какие дополнительные переменные здесь понадобятся?

Глава 46

Огромные числа

 Сделать закладку на этом месте книги




Давно минули времена, когда для счета всем хватало своих пальцев – первого «калькулятора» человечества, а наши потребности в счете все растут и растут…


Сколько звезд на небе?

Некий король – любитель науки, порядка и немножко чудак – распорядился пересчитать все, что ни есть, в своих владениях. Ладно бы, его интересовали крупные предметы вроде домов, машин и всего такого… Но нет, король велел пересчитать и капли в морях, и песчинки на берегах, и травинки в степях! Пока ученые придумывали способы подсчета, программисты возились с другой задачей – обработкой всего этого на компьютере. Они искали подходящий тип данных для хранения тех огромных чисел, что нужны ученым! Обратившись к описанию языка Паскаль, программисты заинтересовались двумя числовыми типами, которые на первый взгляд подходили для такого случая.

Первый из них – тип LongInt – длинное целое число. Наибольшее значение для этого типа чисел составляет 2'147’483’647, то есть несколько больше двух миллиардов. Маловато будет, – рассудили мудрецы, и продолжили поиск.

Вскоре они наткнулись на другой тип чисел – Extended, который мог вмещать сказочные значения – вплоть до 104932! Иначе говоря, эти числа могли содержать почти пять тысяч цифр! Но радость математиков была недолгой; рассмотрев тип Extended пристальней, они отвергли его. Оказалось, что из этих пяти тысяч цифр только первые двадцать – точные (их называют значащими), а остальные не внушают доверия, и могут быть замены чем угодно, хоть нулями.

Есть ли толк от этих неточных чисел? Есть. Дело в том, что в инженерных и научных расчетах этой точности вполне хватает. Но здесь был иной случай, – требовался абсолютно точный подсчет, государь не терпел огрехов. «Точность – вежливость королей!» – говаривал он. И программисты ткнулись, как обычно, в тупик.


Сложение «в столбик» никто не отменял

Выход из тупика нашелся случайно. Один из королевских программистов помогал сынишке справиться со школьными уроками – складывали числа «в столбик». Тут его и осенило: почему бы и нам, – смекнул папаша, – не складывать числа тем же способом? Так тряхнем стариной и вспомним это сложение «в столбик»? Рис. 102 освежит вашу память.






Рис.102 – Пример сложения в столбик

Итак, сложение чисел начинаем с младшего, то есть крайнего правого разряда. Если сумма двух цифр превысит девять, то в разряд результата записываем остаток от деления этой суммы на 10 (то есть цифры от 0 до 9), а к следующему разряду добавляем перенос.

Если обозначить складываемые цифры буквами A и B, то алгоритм сложения «в столбик» для одного разряд


убрать рекламу






а с учетом предыдущего переноса запишется так:


      цифра := (A + B + перенос) mod 10

      перенос := (A + B + перенос) div 10


Напомню, что операция MOD вычисляет остаток от деления одного целого числа на другое, а операция DIV – частное с отбрасыванием остатка. Перед сложением самого младшего разряда перенос берётся равным нулю. Обратите внимание, что условный оператор здесь излишен.


Великая стройка

Уловив основную идею – действия «в столбик», – программисты задумались над хранением цифр огромного числа. Они рассмотрели два равно подходящих средства: либо массив байтов, каждый из которых будет содержать числа от 0 до 9, либо массив символов «0»…«9». Ученые остановились на символах, но от строки отказались, поскольку строка вмещает лишь 255 символов, а им требовалось больше.

В итоге объявление сверхбольшого числа получилось таким, как показано в программе «P_46_1», – она была написана для отладки процедуры распечатки сверхбольшого числа.


{ P_46_1 – Распечатка сверхбольших чисел }

      { объявления для сверхбольшого числа }

const CSize = 500; { размер массива для цифр }

type TBigNumber = array [1..CSize] of char;

var BN : TBigNumber; { очень большое число! }

      { Процедура распечатки сверхбольшого числа

      Младшие цифры числа располагаются в младших элементах массива.

      Но распечатывать надо, начиная со старших цифр.

      Поэтому обработку массива ведем от конца к началу.

      При этом старшие позиции, заполненные пробелами, не печатаем.}

procedure WriteBigNumber(var F: text; const aNum: TBigNumber);

var i : integer;

begin

i:= SizeOf(aNum); { печать начинаем со старших цифр }

{ Пока встречаются незначащие цифры, пропускаем их }

while (i>0) and not (aNum[i] in ['1'..'9']) do Dec(i) ;

{ Если весь массив заполнен пробелами, то печатаем ноль }

if i=0 then Write(F, '0');

{ Теперь печатаем оставшиеся цифры }

while i>0 do begin

      Write(F, aNum[i]);

      Dec(i);

end;

{ Добавляем ещё одну пустую строчку для удобства созерцания }

Writeln(F); Writeln(F);

end;

var i : integer;

begin       { === Главная программа === }

FillChar(BN, SizeOf(BN), ' ') ; { заполняем пробелами }

WriteBigNumber(Output , BN);

FillChar(BN, SizeOf(BN), '7') ; { заполняем семерками }

WriteBigNumber(Output , BN);

{ заполняем случайными цифрами }

for i:=1 to CSize-1 do BN[i]:= Char(Random(100) mod 10 + Ord('0'));

WriteBigNumber(Output , BN);

Readln;

end.


Итак, тип данных TBigNumber – это сверхбольшое число в виде массива из 500 цифр. Процедура WriteBigNumber – печать сверхбольшого числа – выполняет то, о чем говорит её название. Напомню, что примененная здесь процедура Dec(i) выполняет быстрое вычитание единицы.

В главной программе вы найдете процедуру FillChar – «заполнить символом». Для заполнения массива можно организовать цикл, но процедура FillChar делает это проще и быстрее, она объявлена в Паскале так:


      procedure FillChar(var X; Count: Integer; Value: Byte);


Обратите внимание, что тип первого параметра X не указан, что крайне редко для Паскаля! По сути это ссылка на переменную любого типа. Второй параметр – Count – задает количество байтов, помещаемых в переменную X. Обычно значение Count совпадает с размером этой переменной и задается равным SizeOf(X). И, наконец, третий параметр Value – «значение», тоже не совсем обычен. Его тип объявлен как байт (то есть число), но в действительности может принимать любой однобайтовый тип данных, например, символ или булево значение. Вот несколько примеров.


var A : array 1..100 of char;

      B : array 1..200 of byte;

      С : array 1..50 of boolean;

...

      FillChar(A, SizeOf(A), ’*’);       { заполнение массива звездочками }

      FillChar(B, SizeOf(B), 0);       { заполнение массива нулем }

      FillChar(C, SizeOf(C), false); { заполнение массива «ложью» }


Согласитесь, нелегко отказаться от применения столь удобной процедуры.

И последнее. В нашу процедуру WriteBigNumber передается ссылка на выходной файл, что придает ей универсальность. Вызывая её из главной программы, мы передаём туда файловую переменную Output, – это файл, связанный с экраном. Напомню, что файл Output не требует ни объявления, ни открытия, ни закрытия – он в