À. Â. Ìîãèëåâ 

Ë. Â. Ëèñòðîâà 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Ñàíêò-Ïåòåðáóðã

«ÁÕÂ-Ïåòåðáóðã»

2008

УДК 681.3.06(075.3)

ББК     32.973.26-018.2я721

             М74

 

                          Могилев, А. В.

             М74          Методы программирования. Компьютерные вычисления / 

                             А. В. Могилев, Л. В. Листрова. — СПб.: БХВ-Петербург, 2008. — 

                           320 с.: ил. — (ИиИКТ)

ISBN 978-5-9775-0151-4

Книга является частью комплекта учебников по курсу информатики и информационно-коммуникационных технологий (ИКТ) в старших классах общеобразовательной школы на профильном уровне. Она охватывает 5-й и 6-й из 10-ти модулей курса и является продолжением пособий "Информация и информационные процессы. Социальная информатика", "Средства информатизации. Телекоммуникационные технологии".

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

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

Для учащихся старших классов физико-математического, информационно-технологического и других профилей

УДК 681.3.06(075.3)

ББК 32.973.26-018.2я721 Группа подготовки издания:

Главный редактор	Екатерина Кондукова
Зам. главного редактора	Антонина Панюшева
Зав. редакцией	Григорий Добин
Редактор	Екатерина Капалыгина
Компьютерная верстка	Ольги Сергиенко
Корректор	Людмила Минина
Дизайн серии	Инны Тачиной
Оформление обложки	Елены Беляевой
Зав. производством	Николай Тверских

 

 

Ëèöåíçèÿ ÈÄ ¹ 02429 îò 24.07.00. Ïîäïèñàíî â ïå÷àòü 22.07.08.

Ôîðìàò 70×100¹/16.  Ïå÷àòü îôñåòíàÿ. Óñë. ïå÷. ë. 25,8.

Òèðàæ 1500 ýêç. Çàêàç ¹    

"ÁÕÂ-Ïåòåðáóðã", 194354, Ñàíêò-Ïåòåðáóðã, óë. Åñåíèíà, 5Á.

Ñàíèòàðíî-ýïèäåìèîëîãè÷åñêîå çàêëþ÷åíèå íà ïðîäóêöèþ 

¹ 77.99.60.953.Ä.003650.04.08 îò 14.04.2008 ã. âûäàíî Ôåäåðàëüíîé ñëóæáîé  ïî íàäçîðó â ñôåðå çàùèòû ïðàâ ïîòðåáèòåëåé è áëàãîïîëó÷èÿ ÷åëîâåêà.

Îòïå÷àòàíî ñ ãîòîâûõ äèàïîçèòèâîâ  â ÃÓÏ "Òèïîãðàôèÿ "Íàóêà"

199034, Ñàíêò-Ïåòåðáóðã, 9 ëèíèÿ, 12

 

ISBN 978-5-9775-0151-4                                                     © Могилев А. В., Листрова Л. В., 2008

© Оформление, издательство "БХВ-Петербург", 2008

 

                 

                                                

 

 

 

 

 

Оглавление

 

Предисловие ........................................................................................................... 7

МОДУЛЬ 5. ЯЗЫКИ И МЕТОДЫ ПРОГРАММИРОВАНИЯ ..................... 9 5.1. История развития языков программирования и парадигмы

программирования ............................................................................................. 11

Учебный материал ............................................................................................................. 11 Контрольные вопросы ....................................................................................................... 17 Темы для рефератов и докладов ....................................................................................... 17 Вопросы для обсуждения .................................................................................................. 18 Задачи и упражнения ......................................................................................................... 18

Лабораторные работы ........................................................................................................ 18

5.2. Языки программирования высокого уровня. Метаязыки для описания синтаксических конструкций языка высокого уровня ..... 19

Учебный материал ............................................................................................................. 19 Контрольные вопросы ....................................................................................................... 27 Темы для рефератов и докладов ....................................................................................... 28 Вопросы для обсуждения .................................................................................................. 28 Задачи и упражнения ......................................................................................................... 28

Лабораторные работы ........................................................................................................ 29

5.3. Паскаль как язык структурно-ориентированного

программирования ............................................................................................. 30

Учебный материал ............................................................................................................. 30 Введение в Паскаль .................................................................................................... 30 Основные конструкции языка Паскаль .................................................................... 37 Структуры данных ..................................................................................................... 42 Процедуры и функции ............................................................................................... 53 Обработка файлов ...................................................................................................... 58 Динамические информационные структуры ........................................................... 64

Оглавление

Работа с графикой ...................................................................................................... 69

Система программирования на Паскале .................................................................. 77 Контрольные вопросы ....................................................................................................... 78 Темы для рефератов и докладов ....................................................................................... 79 Вопросы для обсуждения .................................................................................................. 79 Задачи и упражнения ......................................................................................................... 79

Лабораторные работы ........................................................................................................ 81

5.4. Методы и искусство программирования ................................................. 83

Учебный материал ............................................................................................................. 83 Основные принципы разработки и анализа алгоритмов ........................................ 92 Методы построения алгоритмов, ориентированные на структуры данных ......... 99

Рекурсивные алгоритмы .......................................................................................... 103

Алгоритмы поиска и сортировки ............................................................................ 105 Контрольные вопросы ..................................................................................................... 120 Темы для рефератов и докладов ..................................................................................... 121 Вопросы для обсуждения ................................................................................................ 122 Задачи и упражнения ....................................................................................................... 122

Лабораторные работы ...................................................................................................... 123

5.5. Введение в язык программирования Си ............................................... 124

Учебный материал ........................................................................................................... 124

Общая характеристика языка и пример программы на Си .................................. 124 Элементы Си: алфавит, идентификаторы, литералы, служебные слова ............. 129 Типы данных и операции в языке Си. Выражения ............................................... 132

Операторы. Управляющие конструкции языка ..................................................... 141 Оператор присваивания ...................................................................................... 141

Оператор if/else .................................................................................................... 142

Оператор-переключатель switch ......................................................................... 144

Оператор цикла for .............................................................................................. 146

Оператор цикла while .......................................................................................... 149

Оператор цикла do/while ..................................................................................... 150

Оператор break ..................................................................................................... 150

Оператор продолжения continue ........................................................................ 151

Оператор безусловного перехода goto ............................................................... 152

Составные операторы и блоки ........................................................................... 152 Структура программы на Си. Понятие о функциях .............................................. 153

Классы памяти .......................................................................................................... 160 Функции ввода/вывода ............................................................................................ 165 Директивы препроцессора ...................................................................................... 171

Сравнение языков программирования Си и Паскаль ........................................... 174

Контрольные вопросы ..................................................................................................... 175 Темы для рефератов и докладов ..................................................................................... 176 Вопросы для обсуждения ................................................................................................ 176 Задачи и упражнения ....................................................................................................... 177 Лабораторные работы ...................................................................................................... 184

Оглавление                                                                                                                                              5

5.6. Элементы объектного программирования ........................................... 186

Учебный материал ........................................................................................................... 186 Контрольные вопросы ..................................................................................................... 204 Темы для рефератов и докладов ..................................................................................... 205 Вопросы для обсуждения ................................................................................................ 205 Задачи и упражнения ....................................................................................................... 205

Лабораторные работы ...................................................................................................... 206

5.7. Основы логического программирования на языке Пролог .............. 207

Учебный материал ........................................................................................................... 207 Общие сведения ....................................................................................................... 207 Алгоритм выполнения программ на Прологе........................................................ 213

Рекурсия .................................................................................................................... 217

Предикат отсечения и управление логическим выводом в программах ............. 220

Обработка списков ................................................................................................... 222

Решение логических задач на Прологе .................................................................. 226 Контрольные вопросы ..................................................................................................... 229 Темы для рефератов и докладов ..................................................................................... 230 Вопросы для обсуждения ................................................................................................ 230 Задачи и упражнения ....................................................................................................... 230

Лабораторные работы ...................................................................................................... 232

МОДУЛЬ 6. КОМПЬЮТЕРНЫЕ ВЫЧИСЛЕНИЯ ................................... 233

6.1. Вычислительные методы ......................................................................... 235

Учебный материал ........................................................................................................... 235 Вычисление значений функций. Интерполяция.................................................... 235 Решение нелинейных уравнений с одной переменной ......................................... 245 Решение систем линейных уравнений ................................................................... 257

Численное интегрирование ..................................................................................... 261 Контрольные вопросы ..................................................................................................... 267 Темы для рефератов и докладов ..................................................................................... 268 Вопросы для обсуждения ................................................................................................ 269 Задачи и упражнения ....................................................................................................... 270 Лабораторные работы ...................................................................................................... 274 Задания для самостоятельных и контрольных работ .................................................... 280

6.2. Понятие о компьютерном моделировании ............................................ 281

Учебный материал ........................................................................................................... 281 Моделирование как метод познания ...................................................................... 281 Этапы и цели компьютерного моделирования ...................................................... 284 Классификация информационных моделей ........................................................... 289

Построение компьютерной модели. Моделирование ........................................... 295 Информационные модели баз данных ............................................................... 297

Информационное моделирование в электронных таблицах ............................ 300

Оглавление

Контрольные вопросы ..................................................................................................... 303 Темы для рефератов и докладов ..................................................................................... 304 Вопросы для обсуждения ................................................................................................ 305 Задачи и упражнения ....................................................................................................... 305 Лабораторные работы ...................................................................................................... 308

Литература ........................................................................................................................ 316

Предметный указатель ..................................................................................... 317

 

 

 

 

 

 

Предисловие

 

 

 

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

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

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

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

1.       Информация и информационные процессы.

2.       Социальная информатика.

3.       Средства информатизации.

4.       Телекоммуникационные технологии.

5.       Методы программирования.

6.       Компьютерные вычисления.

Предисловие

7.       Технологии обработки текстовой информации.

8.       Технологии обработки графической и мультимедийной информации.

9.       Технологии поиска и хранения информации.

10.   Технологии автоматизации управления.

Настоящее пособие охватывает 5-й и 6-й модули курса и является продолжением пособий "Информация и информационные процессы. Социальная информатика", "Средства информатизации. Телекоммуникационные технологии" тех же авторов.

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

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

                     — Учебный материал;

  — Контрольные вопросы;

  — Темы для рефератов и докладов;

  — Вопросы для обсуждения;

  — Задачи и упражнения;

  — Лабораторные работы.

 

 

 

МОДУЛЬ 5

Языки и методы 

программирования

 

5.1.  История развития  языков программирования  и парадигмы программирования

5.2.  Языки программирования  высокого уровня. Метаязыки  для описания синтаксических конструкций языка высокого уровня

5.3.  Паскаль как язык  структурно-ориентированного программирования

5.4.  Методы и искусство программирования

5.5.  Введение в язык программирования Си

5.6.  Элементы объектного программирования

5.7.  Основы логического программирования на языке Пролог

 

 

 

2                                                                       Модуль 1. Информация и информационные процессы

 

 

 

 

 

 

 

 

 

 

 

5.1. История развития  языков программирования  и парадигмы программирования

 

 

Учебный материал

 

Основоположником программирования можно считать английского математика Чарлза Бэббиджа (1791—1871 гг.). В 20-х годах XIX века ему пришла идея создать такую механическую машину для вычислений, что порядок ее действий можно было предварительно записывать и впоследствии выполнять эти действия на машине автоматически. Это была идея, положившая начало программированию. Ч. Бэббидж посвятил реализации этой идеи всю жизнь. Он не добился успеха и признания современников при жизни, но оказал огромное влияние на современное развитие информатики.

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

Рядом с Ч. Бэббиджем у истоков программирования стояла Ада Лавлейс, дочь английского поэта Чарлза Гордона Байрона. Она оказалась одним из немногих современников Чарлза Бэббиджа, кто сумел по достоинству оценить идею "аналитической машины". Она стала ближайшей помощницей и сподвижницей Бэббиджа, разработала некоторые приемы управления последовательностью вычислений, которые используются в программировании и по сей день, описала одну из важнейших конструкций практически любого современного языка программирования — цикл. Аду Лавлейс по праву считают первым в мире программистом.

Дальнейшего прогресса в программировании пришлось ждать почти 100 лет, и связан он был с появлением в середине 1940-х годов электромеханических и электронных вычислительных машин — родителей современных компьютеров.

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

Первым шагом в развитии современных языков программирования стало создание в конце 1940-х годов Джоном Моучли, сотрудником Пенсильванского университета (США), системы кодирования машинных команд этих компьютеров с помощью специальных символов. Достижением создателей языков программирования было то, что они сумели заставить сам компьютер работать переводчиком с этих языков на машинный код. Описываемая система, которую назвали "Short Code", была по существу одним из первых примитивных интерпретаторов. Она использовала примитивный язык программирования высокого уровня. На нем программист записывал решаемую задачу в виде математических формул, а затем сам, используя специальную таблицу, переводил символ за символом, преобразовывая эти формулы в двухлитерные коды. В дальнейшем специальная программа компьютера превращала эти коды в двоичный машинный код.

Система кодирования, предложенная Моучли, увлекла одну из сотрудниц его группы — Грейс Мюррей Хоппер, которая стала третьим в мире програм- мистом.

В 1951 г. Хоппер создала первый в мире компилятор. Именно она ввела сам этот термин. Компилятор Хоппер осуществлял функцию объединения команд и в ходе трансляции производил организацию подпрограмм, выделение памяти компьютера, преобразование команд высокого уровня (в то время псевдокодов) в машинные команды. "Подпрограммы находятся в библиотеке (компьютера), а когда вы подбираете материал из библиотеки — это называется компиляцией", — так она объясняла происхождение введенного ею термина.

В 1954 г. группа под руководством Г. Хоппер разработала систему, включающую язык программирования и компилятор, которая в дальнейшем получила название MATH-MATIC. После удачного завершения работ по созданию MATH-MATIC Г. Хоппер и ее группа принялись за разработку нового языка и компилятора, который позволил бы пользователям программировать на языке, близком к обычному английскому. В 1958 г. появился компилятор FLOW-MATIC. FLOW-MATIC был первым языком для задач обработки коммерческих данных. Работы в этом направлении привели к созданию языка КОБОЛ (COBOL — Common Business Oriented Language). Одним из основных консультантов при его создании была Грейс Мюррей Хоппер.

При работе на компьютере "Maрк-I" Г. Хоппер и ее группе пришлось стать первопроходцами программирования. Они первыми придумали подпрограммы. Сейчас любой программист не задумываясь использует подпрограммы в любом языке программирования. Еще одно фундаментальное понятие техники программирования этой группы — "отладка". Однажды жарким летним днем 1945 г. неожиданно произошла остановка компьютера "Марк-I". Обнаружилась неисправность одного реле, контакты которого были заблокированы мотыльком, залетевшим в помещение вычислительного центра. Г. Хоппер вспоминала: "Когда к нам зашел офицер, чтобы узнать, чем мы занимаемся, мы ответили, что удаляем из компьютера насекомых (debuging)". С тех пор термин "debuging" (отладка) используется в технических процессах тестирования неисправностей в компьютере, а также в системах программирования.

Середина 50-х годов XX века характеризуется стремительным прогрессом в области программирования. Программирование в машинных командах стало вытесняться программированием на языках, выступавших в роли посредника между машинами и программистами. Первым и одним из наиболее распространенных стал Фортран (FORTRAN, от FORmula TRANslator — пере- водчик формул), разработанный группой программистов фирмы IBM в 1954 г. Этот язык получил большое распространение, стал основным языком для научных и технических расчетов, несколько раз усовершенствовался и широко используется до сих пор.

В конце 50-х годов плодом международного сотрудничества в области программирования явился Алгол-60 (ALGOL, от ALGOrithmic Language — алгоритмический язык, версия 1960 г.). Алгол предназначен для записи алгоритмов, которые строятся в виде последовательности процедур, применяемых для решения поставленных задач. Специалисты-практики восприняли этот язык далеко не однозначно, но, тем не менее, его влияние на развитие других языков и теорию программирования оказалось весьма значительным.

Развитие идеи Алгола о структуризации разработки алгоритмов нашло наивысшее отражение при создании в начале 1970-х годов языка Паскаль швейцарским ученым Никлаусом Виртом. Язык Паскаль первоначально разрабатывался как учебный, и, действительно, сейчас он является одним из основных языков обучения программированию в школах и вузах. Однако качества его в совокупности оказались столь высоки, что им охотно пользуются и профессиональные программисты.

В середине 1960-х годов сотрудники математического факультета Дартмутского колледжа Томас Курц и Джон Кемени создали специализированный язык программирования, который состоял из простых слов английского языка. Новый язык назвали "универсальным символическим кодом для начинающих" (Beginners All Purpose Symbolic Instruction Code, или, сокращенно, BASIC, а по-русски — Бейсик). Годом рождения нового языка можно считать 1964 г.

Долгое время универсальный язык Бейсик (имеющий множество версий) имел большую популярность и широкое распространение среди пользователей ЭВМ различных категорий во всем мире. В значительной мере этому способствовало то, что Бейсик начали использовать как встроенный язык персональных компьютеров, широкое распространение которых началось в конце 1970-х годов.

Большой отпечаток на современное программирование наложил язык Си (первая версия — 1972 г.), являющийся очень популярным в среде разработчиков систем программного обеспечения (включая операционные системы). Си сочетает в себе черты как языка высокого уровня, так и машинноориентированного языка, допуская программиста ко всем машинным ресурсам, чего не позволяют такие языки, как Бейсик и Паскаль.

Более специализированным языком является язык ЛОГО (от греческого  logos — слово), созданный для обучения программированию школьников профессором математики и педагогики Сеймуром Пейпертом из Массачусетского технологического института. Обучаясь программированию на ЛОГО, дети задают простые команды и составляют из них программы, которые управляют условной "черепашкой" — объектом, оставляющем при перемещении след на экране монитора.

Отметим язык LISP (LISt Processing — обработка списков), появившийся в США в конце 1950-х годов, и еще один специализированный язык — Пролог (Prolog — PROgramming in LOGic), разработанный в 1970-е годы, как языки программирования для создания систем искусственного интеллекта.

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

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

В конце 1960-х годов были сделаны попытки преодолеть эту "разноголосицу" путем создания универсального языка программирования. Первым детищем этого направления стал PL/1 (Programm Language One), 1967 г. Затем на эту роль претендовал Алгол-68 (1968 г.). Предполагалось, что подобные языки будут развиваться и усовершенствоваться и вытеснят все остальные. Однако ни одна из этих попыток на сегодняшний день не увенчалась успехом (хотя PL/1 в усеченных версиях использовали многие программисты). Стремление к универсальности языка приводило к неоправданной сложности конструкций программы, неэффективности получаемых исполняемых кодов.

Бурный рост числа различных языков программирования в период с конца 1960-х и до начала 1980-х годов сопровождался, как это ни странно, кризисом программного обеспечения. Остро не хватало программ для решения самых разных задач и программистов для их разработки, а написанные программы часто содержали ошибки и работали неустойчиво. Этот кризис особо остро переживало военное ведомство США. В январе 1975 г. Пентагон решил навести порядок в хаосе трансляторов и учредил комитет, которому было предписано разработать один универсальный язык. На конкурсной основе комитет проработал сотни проектов, и когда стало ясно, что ни один из существующих языков не может их удовлетворить, принял два проекта для окончательного рассмотрения. В мае 1979 г. был объявлен победитель — группа ученых во главе с Жаном Ихбиа. Победивший язык окрестили АДА, в честь Ады Лавлейс. Язык АДА — прямой наследник языка Паскаль. Этот язык предназначен для создания и длительного (многолетнего) сопровождения больших программных систем, допускает возможность параллельной обработки, управления процессами в реальном времени и многое другое, чего трудно или невозможно достичь средствами более простых языков.

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

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

Наилучший результат в программировании достигается при индивидуальном выборе языка программирования на основе класса задачи, уровня и интересов программиста. Например, Бейсик широко употребляется при обучении и написании простейших программ; Фортран является классическим языком программирования при решении математических и инженерных задач; Кобол используется как основной язык для массовой обработки данных в сферах управления и бизнеса.

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

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

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

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

Принципиально иные направления в программировании относятся к непроцедурным парадигмам. К ним можно отнести объектно-ориентированное и декларативное программирование. Из языков объектного программирования, имеющих популярность, следует назвать Си++, среды типа Delphi и Visual

Basic.

Рис. 5.1. Классификация языков программирования

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

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

Общая классификация языков программирования в соответствии с парадигмами программирования приведена на рис. 5.1. Изучая этот курс, вы познакомитесь с несколькими языками программирования, относящимися к разным парадигмам.

 

Контрольные вопросы

 

1.    Как зарождалось программирование в докомпьютерную эпоху?

2.    Каков вклад в появление первых языков программирования высокого уровня Дж. Моучли и Г. Хоппер?

3.    Охарактеризуйте назначение языков Фортран, Алгол, Си, Паскаль.

4.    В чем причина неудач универсальных языков PL/1 и Алгол-68?

5.    Какие языки используются для разработки систем искусственного интеллекта?

6.    Какие языки ориентированы на задачи обучения программированию?

7.    Что называется парадигмой программирования?

8.    Приведите примеры языков программирования, относящихся к различным парадигмам.

 

 Темы для рефератов и докладов

1.    Технологии программирования первых компьютеров.

2.    Развитие машинных языков программирования.

3.    Языки для научных вычислений.

4.    Языки обработки символьной информации.

5.    Языки разработки систем искусственного интеллекта.

6.    Языки для начального обучения программированию.

7.    Языки объектного программирования.

 

Вопросы для обсуждения

 

1.    Почему количество языков программирования так велико?

2.    Может ли программирование стать ненужным?

3.    Почему изучение языков программирования вызывает затруднения?

 

Задачи и упражнения

 

1. Составьте сводную справочную таблицу языков программирования. Отразите в ней название языка (или его версии), год создания, назначение, парадигму, к которой язык относится.

 

Лабораторные работы

 

1.    Выясните, какие книги имеются в библиотеке вашего учебного заведения (и других доступных библиотеках), посвященные языкам и технологиям программирования. Какие это языки? Составьте сводную таблицу-каталог.

2.    Выполните поиск в Интернете ресурсов, посвященных языкам и технологиям программирования. Постарайтесь оценить эти ресурсы на предмет доступности. Составьте каталог этих ресурсов.

3.    Выясните, какие системы программирования и на каких языках доступны в вашем учебном заведении.

 

 

 

 

 

5.2. Языки программирования  высокого уровня. Метаязыки  для описания синтаксических конструкций языка высокого уровня

 

Учебный материал

 

Языки программирования — это формальные языки, специально созданные для общения человека с компьютером.

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

Машинно-ориентированные языки содержат примитивные команды, соответствующие особенностям данной архитектуры компьютера (в этом и состоит их машинная ориентированность), и к тому же записываемые машинными кодами, обычно в шестнадцатеричной форме, типа: переслать число в ячейку; считать число из ячейки; увеличить содержимое ячейки на +1 и т. п. Команда на машинном языке обычно описывает простейший обмен содержимого ячеек памяти, элементарные арифметические и логические операции. Команда содержит код и адреса ячеек, с содержимым которых выполняется закодированное действие.

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

Языки программирования высокого уровня имеют следующие достоинства:

 алфавит языка значительно шире машинного, что делает его гораздо бо- лее выразительным и существенно повышает наглядность и понятность текста;

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

 конструкции команд (операторов) отражают привычные человеку приемы обработки данных и задаются в удобном для чтения и понимания виде;  используется аппарат переменных и действия с ними;  поддерживается широкий набор типов данных.

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

Каждый язык программирования, равно как и "естественный" язык (русский, английский и т. д.), имеет алфавит, словарный запас, свои грамматику и синтаксис, а также семантику.

Алфавит — фиксированный для данного языка набор основных символов, допускаемых для составления текста программы на этом языке.

Синтаксис — система правил, определяющих допустимые конструкции языка программирования из букв алфавита.

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

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

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

Для строгого и точного описания синтаксиса языка программирования, как правило, используют специальные метаязыки (языки для описания других языков). Наиболее распространенными метаязыками являются металингвистические формулы Бэкуса — Наура (язык БНФ) и синтаксические диаграммы Вирта.

Язык БНФ (называемый также языком нормальных форм) представляет собой способ записи конструкций языка программирования с помощью формул, похожих на математические. Для каждого понятия языка существует единственная метаформула (нормальная форма). Она состоит из левой и правой частей. В левой части указывается определяемое понятие, а в правой — задается множество допустимых конструкций языка, которые объединяются в это понятие. В формуле используют специальные метасимволы в виде угловых скобок, которые обозначают определяемое понятие (в левой части формулы) или ранее определенное понятие (в ее правой части). Левая и правая части формулы разделяются метасимволом "::=", имеющим смысл "по определению есть". Знак "|" следует читать "или". Например, метаформулы

<переменная>::=А|В

<выражение>::=<переменная>|<переменная>+<переменная>|<переменная>–

<переменная>

означают, что <переменная> это одна из букв, А или В, а <выражение> — любая из следующих десяти записей: А; В; А+А; А+В; В+А; В+В; А–А; А–В; В–А; В–В.

Правая часть метаформулы может содержать правило построения допустимых последовательностей. Допускаются рекурсивные определения терминов и понятий, т. е. когда в правой части формулы участвует понятие, определяемое левой частью. Например, пусть необходимо ввести понятие <двоичный код>, под которым понимается любая непустая последовательность цифр 0 и 1. Тогда простое и компактное рекурсивное определение с помощью метаформул выглядит так:

<двоичная цифра>::= 0 | 1

<двоичный код>::=<двоичная цифра>|<двоичная цифра><двоичный код>

Данное определение позволяет определить, является ли некая конструкция определяемым понятием.

Так, для нашего примера метаформулы двоичного кода конструкция 001101 является двоичным кодом, поскольку, последовательно применяя рекурсию, мы имеем следующие 5 шагов рекурсии:

1.    0 — двоичная цифра, а 01101 — двоичный код, поскольку

2.    1 — двоичная цифра, а 1101 — двоичный код, поскольку

3.    1 — двоичная цифра, а 101 — двоичный код, поскольку

4.    1 — двоичная цифра, а 01 — двоичный код, поскольку

5.    0 — двоичная цифра, а 1 — также двоичная цифра, рекурсия завершена.

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

1.    1 — двоичная цифра, а 021 — не двоичный код, поскольку

2.    0 — двоичная цифра, а 21 — не двоичный код, поскольку

3.    2 — не двоичная цифра.

Для задания синтаксических конструкций произвольной длины часто используют фигурные скобки как метасимволы. Фигурные скобки означают, что конструкция может повторяться нуль или более раз. В частности, термин <двоичный код> можно определить по-другому, а именно:

<двоичный код>::=<двоичная цифра>{<двоичная цифра>}

И еще, для полноты множества синтаксических конструкций, необходимо определить конструкцию <пусто>:

<пусто>::= .

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

Синтаксические диаграммы позволяют графически отобразить значения метапеременных метаязыка. Диаграмма состоит из основных символов или понятий языка.

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

Для сравнения с метаформулами приведем несколько примеров. Синтаксическая диаграмма

<переменная>

 

эквивалентна метаформуле <переменная>::= А|В.

Еще примеры:

              <двоичная цифра> ::=                                    <двоичный код ::=>

<двоичная цифра>

                                                                                           <двоичная цифра>

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

Пользуясь средствами форм Бэкуса — Наура и синтаксическими диаграммами, опишем грамматику языков программирования.

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

<буква> : : =  A|a|B|b|C|c|D|d|E|e|F|f и т. д.

 

<цифра> : : = 0|1|2|3|4|5|6|7|8|9

 

<знак арифметической операции > : : = *|/|+|–

 

<разделитель> : : = . | , | ; | : | ( | ) | [ | ] |{ | }| ' | : =

 

<служебное слово> : : = begin | end | if | then | else| for | next и т. д.

 

<спецсимвол> :: = <знак арифметической операции> | <разделитель> |

<служебное слово>

 

<основной символ>::=<буква> | <цифра> | <спецсимвол> 

<комментарий>::= {любая последовательность символов}

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

Оператор — одно из главных понятий всех языков программирования. Каждый оператор представляет собой законченную фразу языка и однозначно определяет некоторое действие над данными. В соответствии с теорией алгоритмов выделяют основные (базовые) операторы языка:

 присвоения;

 условного и безусловного перехода;  пустой оператор.

К производным операторам относят:

 составной оператор;

 оператор выбора;

 оператор цикла;

 оператор присоединения.

Все операторы языка в тексте программы отделяются друг от друга явными или неявными разделителями, например:

S1; S2; ...; Sn

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

Большая часть операторов ведет обработку величин.

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

Другая важная классификация величин — простые и составные. Простая величина имеет одно значение. Ей соответствует одна ячейка памяти (точнее, "машинное слово") или ее эквивалент во внешней памяти компьютера.

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

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

Важнейшие характеристики структурированной величины таковы: упорядоченность (да или нет), однородность (да или нет), способ доступа к элементам, постоянство числа элементов (да или нет). Так, массив является упорядоченной однородной структурой с прямым доступом к элементам и постоянным их количеством.

Всем объектам данных в языках программирования даются индивидуальные имена. Имя программного объекта называют идентификатором (от слова "идентифицировать"). Чаще всего идентификатором является любая конечная последовательность букв и цифр, начинающаяся с буквы:

<идентификатор>::=<буква>

<идентификатор> ::= <идентификатор>(<буква>| <цифра>)

Как правило, в качестве идентификатора запрещается использовать служебные слова языка.

Многим слово "идентификатор" не нравится, и в настоящее время чаще употребляют слово "имя", поскольку

<имя>::=<идентификатор>

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

Summa, Time, i, j, Radius, init

Некоторым идентификаторам заранее предписан определенный смысл и их называют стандартными, например Sin — это имя известной математической функции.

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

В некоторых языках широко применяются описания данных по умолчанию для стандартных числовых и символьных данных. В этом случае тип данных  задается с помощью имени объекта данных. Например, в Фортране переменные, имена которых начинаются с букв I, J, K, L, M, N, по умолчанию принимают целые значения (при отсутствии явного описания типа, которое также возможно), т. е. определены как числовые данные целого типа. В Бейсике данные строкового типа присваиваются переменным, имена которых заканчиваются специальным символом $: A$, S1$, а просто имена без $ и специального описания получают действительный тип значений двойной точности.

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

Приведем список наиболее употребительных обозначений типов данных, используемых в описаниях:

Целый                               — Integer

Вещественный              — Real

Логический                     — Boolean

Символьный	— Char
Строковый	— String
Массив	— Array
Множество	— Set
Файл	— File
Запись	— Record
Объект	— Object

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

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

Функция — программный объект, задающий вычислительную процедуру определения значения, зависимого от некоторых аргументов. Вводится в языки программирования для задания программистом необходимых ему функциональных зависимостей. В каждом языке высокого уровня имеется  в наличии библиотека стандартных функций: арифметических, логических, символьных, файловых и т. п. Функции — стандартные и задаваемые программистом — используются в составе выражений.

Выражения строятся из постоянных величин, имен переменных, функций, скобок, знаков операций и т. д. Выражение имеет определенный тип, определяемый типом принимаемых в итоге его вычисления значений. Возможны выражения арифметические, принимающие числовые значения, логические, символьные, строковые и т. д. Выражение 5 + 7 является, несомненно, арифметическим, выражение A + B может иметь самый разный смысл — в зависимости от типа данных, которые стоят за идентификаторами A и B.

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

Модуль (Unit) — это специальная программная единица, предназначенная для создания библиотек и разделения больших программ на логически связанные блоки.

По сути, модуль — набор констант, типов данных, переменных, процедур и функций. В состав модуля входят разделы: заголовок, интерфейс, реализация, инициализация.

Заголовок необходим для ссылок на модуль.

Интерфейс содержит объявления, включая процедуры и функции.

Раздел реализация содержит тела процедур и функций, перечисленных в интерфейсной части.

Раздел инициализация содержит операторы, необходимые для инициализации модуля.

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

 

 

Контрольные вопросы

 

1.        Какие преимущества имеют языки программирования высокого уровня по сравнению с машинно-ориентированными языками?

2.        Каковы основные составляющие языка программирования высокого уровня?

3.        В чем отличие понятий языков программирования от аналогичных понятий естественного языка?

4.        С какой целью используются и что представляют собой металингвистические формулы Бэкуса — Наура?

5.        Что представляет собой синтаксическая диаграмма Вирта?

6.        В чем различие между постоянными и переменными величинами? Чем характеризуется величина?

7.        В чем отличие между величинами простыми и структурированными?

8.        Для чего служит описание величин в программах? Какие стандартные типы данных используют языки высокого уровня?

9.        Для чего служат операторы?

10.    В чем состоит назначение функций? процедур? модулей?

 

 Темы для рефератов и докладов

1.    Проблемы изучения естественных и формальных языков.

2.    Базовые понятия математической лингвистики.

3.    Метаязыки для описания формальных языков.

4.    Тенденции развития языков программирования высокого уровня.

5.    Развитие описания данных в языках программирования.

6.    Развитие декларативных языков программирования.

 

Вопросы для обсуждения

 

1.    Какими могут быть языки "сверхвысокого" уровня, делающие ненужным программирование?

2.    Кому больше нужны БНФ и диаграммы Вирта: программистам или разработчикам компиляторов?

 

Задачи и упражнения

 

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

2.    Опишите известные вам конструкции языков программированиия с помощью БНФ.

3.    Опишите известные вам операторы языков программированиия с помощью диаграмм Вирта.

Лабораторные работы

 

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

 

 

 

 

 

5.3. Паскаль как язык  структурно-ориентированного программирования

 

 

Учебный материал

 

Введение в Паскаль

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

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

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

Существует много версий языка Паскаль. Различия между ними порой весьма велики. Базовая версия языка, созданная Виртом, в этих версиях значительно расширена и дополнена, для того чтобы дать/получить из языка обучения инструмент профессиональных разработчиков прикладного программного обеспечения.

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

Любая программа на Паскале является текстовым файлом с собственным именем и с расширением pas. Рассмотрим в качестве примера текст программы 1 решения квадратного уравнения.  Эта программа имеет вид последовательности символов латинских и русских букв, арабских цифр, знаков операций, скобок, знаков препинания и некоторых дополнительных символов.  В ней можно выделить описания данных и операторы, описывающие действия, которые надо выполнить компьютеру над этими данными.

program SquareEqRoots;			{заголовок программы}
var			{список переменных}
a,b,c: real;			{коэффициенты уравнения}
d,x1, x2: real;			{вспомогательные переменные}
begin			{начало программы}
writeln;			{пропуск строки на экране}

       writeln('введи a,b,c'); read(a,b,c); {запрос и ввод данных}

d:=b*b–4*a*c;	{дискриминант}
if d<0 then	{если d<0, то}
write('корней нет')	{печатать}
else	{иначе}
begin                                                                                                 x1:=(–b+sqrt(d))/(2*a);	{начало серии команд}
x2:=(–b–sqrt(d))/(2*a);	{вычисляем корни}
write('x1=',x1,' x2=',x2)	{печать корней}
end	{конец серии}
end.	{конец программы}

 

Схематически программа представляется в виде последовательности восьми разделов:

1.    Заголовок программы.

2.    Описание внешних модулей, процедур и функций.

3.    Описание меток.

4.    Описание констант.

5.    Описание типов переменных.

6.    Описание переменных.

7.    Описание функций и процедур.

8.    Раздел операторов.

Не в каждой программе обязательно присутствуют все восемь разделов, в простейшей программе, например, могут быть только 5-й и 8-й разделы.

Каждый раздел начинается со служебного слова, назначение которого зафиксировано в Паскале так, что его нельзя употреблять для других целей

(табл. 5.1).

Таблица 5.1. Список зарезервированных слов языка Паскаль в версии для ПК

absolute	абсолютный	label	метка
and	логическое И	library	библиотека
array	массив	mod	остаток от деления
asm	ассемблер	nil	отсутствие
begin	начало блока	not	логическое НЕ
case	вариант	or	логическое ИЛИ
const	константа	of	из
constructor	конструктор	object	объект
div	деление нацело	packed	упакованный
goto	переход на	procedure	процедура
do	выполнять	program	программа
downto	уменьшить до	record	запись
destructor	деструктор (разрушитель)	repeat	повторять
else	иначе	set	множество
end	конец блока	shl	сдвиг битов влево
exports	экспорт	shr	сдвиг битов вправо
external	внешний	string	строка
file	файл	then	то
for	для	to	увеличивая
forward	опережающий	type	тип
function	функция	unit	модуль
if	если	until	до
implementation	реализация	uses	использовать
in	в (входит в ...)	var	переменная
inline	основной	while	пока
interrupt	прерывание	with	с
interface	интерфейс	xor	исключающее ИЛИ
inherited	наследование

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

program circle; const      pi=3.14159; var

     r,s,l : real; begin

     writeln('введите радиус'); readln(r);      s:=pi*r*r; l:=2*pi*r;

     writeln('площадь круга=',s:8:4);      writeln('длина окружности=',l:8:4) end.

 

В этой программе можно выделить четыре раздела. Описание заголовка начинается со служебного слова program, описание констант — const, описание переменных — var, раздел операторов начинается с begin. Программа заканчивается служебным словом end, после которого ставится точка. Описания величин и операторы друг от друга отделяются знаком "точка с запятой".

Для обозначения величин используются имена. Они составляются из латинских букв и цифр, причем первым символом должна быть буква. В примере использованы имена величин — pi, r, s и l.

Имя программы (в примере — circle) выбирается автором и составляется по такому же правилу.

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

Постоянные величины описываются в разделе констант по схеме: const <имя> = <константа>

В разделе констант может быть описано несколько постоянных величин, например:

const

     pi=3.14159; k=–15; s='площадь';

Данные, обрабатываемые программой, могут быть разных типов (числа, символы, строки, массивы и т. д.). Тип определяет область допустимых значений, а также операции и функции, применяемые к величинам этого типа. В Паскале имеется несколько встроенных простых типов со стандартными именами integer (для целых величин), real (для вещественных величин), char (для литерных величин), boolean (для логических величин) и byte (для коротких целых величин).

Группа типов, значения каждого из которых можно перечислить в некотором списке, — ординарные типы. Для них определена порядковая функция ord(x) — номер значения x в списке (для целочисленного х: ord(x)=x); функции pred(x) — значение в списке, предшествующее х, и succ(x) — значение в списке, следующее за x). Из простых типов данных ординарным не является только тип real.

Переменные описываются в разделе описания переменных следующим образом: var <список имен переменных>: <тип>

Имена в списке разделяются запятой. В этом разделе может быть описано несколько переменных разного типа, например: var a,b,c:real; k,l:integer; p:boolean;

Над целыми величинами определены арифметические операции : * (умножение), div (деление нацело), mod (вычисление остатка от деления), +, — (сложение и вычитание); операции перечислены в порядке старшинства.

Например:

25 div 4 = 6

25 mod 4 = 1

Целый результат дают некоторые стандартные функции (аргумент функции заключается в круглые скобки):

 abs(x) — абсолютная величина целого x;

 sqr(x) — квадрат значения x;

 trunc(x) — целая часть вещественной величины x;

 round(x) — целое число, полученное из вещественного x по правилу  округления;

 random(x) — случайное целое число из интервала от 0 до x.

Например: trunc(4.7)=4; round(4.7)=5; sqr(3)=9

Для данных типа byte определены те же операции и функции, что и для данных типа integer.

Над вещественными величинами определены операции: *, +, –, /, а также стандартные функции при вещественном или целом аргументе: abs(x), sqr(x), sin(x), cos(x), arctan(x), ln(x), exp(x), sqrt(x) — квадратный корень из x, int(x) — целая часть из x, random — случайное число из интервала от 0 до 1. Указанные операции и функции дают вещественный результат.

Над логическими величинами определены операции: not — отрицание, and — конъюнкция, or — дизъюнкция. Логическая функция odd(x) принимает значение true, если целочисленное x является нечетным, и false, если четным.

Множество всех символов образуют символьные величины (тип char),  которые являются упорядоченными, причем 'A'<'B'<'C'<...<'Z',

'a'<'b'<...<'z', '0'<'1'<...<'9'.

Основной "строительный материал" программы на Паскале — выражения и оператор присваивания.

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

Оператор присваивания — основной оператор языка. Он имеет следующий

вид:

<имя переменной> := <выражение> и определяет действие компьютера по помещению результатов вычисления <выражения>, записанного справа от знака присваивания :=, в область оперативной памяти, обозначенной <именем переменой>. Отметим, что присваивание :=, это совсем не то, что равенство =. Равенство — это операция сравнения двух величин, результатом которой является логическое значение true или false.

Тип переменной и тип выражения должны быть согласованы (величины принадлежат одному и тому же типу). Есть исключение: имя переменной может относиться к типу real, а значение выражения — к типу integer.

Примеры: l:=2*pi*r; p:=(a+b+c)/2; z:=sqrt(sqr(x)+sqr(y))

В Паскале можно вводить с клавиатуры числовые и символьные данные.

Имеются две встроенные процедуры (подпрограммы) ввода:

 read(<список переменных>);

 readln(<список переменных>).

При выполнении процедуры read(x1,x2,...,xN) программа прерывается и компьютер ждет ввода с клавиатуры N значений переменных из списка x1, x2, ..., xN. Эти значения — константы соответствующих типов — должны при вводе разделяться пробелами. Набор данных завершается клавишей ввода.

Процедура readln отличается от read только тем, что при завершении ввода курсор перемещается в начало следующей строки.

Пример:

var a,b:real; c:char; d:integer; ...

read(a,c,d,b); ...

Допустимый ввод: 83.14 k 200 –7.15

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

 write(<список выражений>);

 writeln(<список выражений>).

Процедура write(x1,x2,...,xN) печатает на экране значения выражений из списка x1, x2, ..., xN. Процедура writeln отличается от write тем, что переводит курсор в начало следующей строки.

Для управления печатью используются форматы данных. Пусть x — переменная типа real. Если не использовать форматы, то значение x будет выводиться в "плавающей" форме (например, 1.654887892Е–04). Форматы позволяют напечатать вещественное число в естественной форме. Пусть m, n — целые числа. Процедура write(x:m:n) выводит на экран значение переменной x в виде десятичной дроби, причем m определяет общее число выводимых символов, включая цифры, точку и знак числа, n — количество цифр после точки. Если количество выводимых символов меньше m, то перед числом добавляются пробелы.

Пусть, например, x=387.26. Табл. 5.2 демонстрирует влияние форматов на вывод значения x.

Таблица 5.2

Оператор	Строка вывода
writeln('*',x)	* 3.8726000000E+02
writeln('*',x:8:3)	* 387.260
writeln('*',x:8:1)	* 387.3

 

Один формат — ширину поля вывода — можно использовать и для вывода значений выражений типов integer, boolean, char.

Основные конструкции языка Паскаль

Конструкции языка Паскаль разрабатывались с учетом принципов структурного программирования и ориентированы на высокую дисциплину программирования. Это означает, что программист должен использовать небольшое число конструкций, применяя как чередование, так и вложение их друг в друга. Не рекомендуется (хотя и возможно) использовать оператор перехода go to.

Реализация последовательности действий (т. е. структуры следования) выполняется с помощью составного оператора:

begin <последовательность операторов> end

Операторы в последовательности операторов разделяются ";". Отметим, что ";" является разделителем и не относится к операторам.

Раздел операторов в программе всегда является составным оператором. Служебные слова begin и end часто называют операторными скобками.

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

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

Структура и действие условного оператора таковы:

if <логическое выражение>          then <оператор 1>          else <оператор 2>

Условный оператор может не содержать часть else <оператор 2>, т. е. может быть неполным:

if <логическое выражение>          then <оператор 1>

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

Пример: составим программу, которая определяет длину общей части двух отрезков числовой оси, заданных координатами своих концов соответственно a, b и c, d (a<b, c<d). Если отрезки имеют общую часть, то левая координата общей части отрезков m равна максимальному из чисел a и c, а правая n — минимальному из чисел b и d.

program cross;    var a,b,c,d,m,n,l:real; begin       writeln('введите координаты концов отрезков');       read(a,b,c,d);       writeln;       if a<c then m:=c else m:=a;       if b<d then n:=b else n:=d;       if m<n then l:=n–m else l:=0;       writeln('длина общей части отрезков=',l:6:2) end.

 

Оператор выбора имеет следующую форму:

case <выражение> of

     <список констант 1> : <оператор 1>;

     <список констант 2> : <оператор 2>;      ...................................      <список констант N> : <оператор N> end.

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

Оператор варианта вычисляет значение выражения, записанного после case. Если его значение совпадает с одной из констант в некотором списке, то выполняется оператор, стоящий после этого списка. Если значение выражения не совпало ни с одной константой во всех вариантах, то оператор варианта ничего не делает.

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

program seasons;    var k:integer; begin       writeln('введите номер месяца');       readln(k);       case k of

           1,2,12:writeln('зима');

           3,4,5:writeln('весна');

           6,7,8:writeln('лето');            9,10,11:writeln('осень')       end end.

 

Для реализации циклов в Паскале имеются три оператора: оператор цикла  с предусловием, оператор цикла с постусловием и оператор цикла с параметром.

Если число повторений оператора цикла (тела цикла) известно заранее, то удобно воспользоваться оператором цикла с параметром. В других случаях следует использовать операторы цикла с предусловием (цикл "пока") или с постусловием (цикл "до"). Форма цикла с предусловием такова: while <логическое выражение> do <оператор>

Исполняется этот цикл следующим образом. Сначала вычисляется значение логического выражения. Если оно имеет значение true, то выполняется оператор тела цикла, после чего снова вычисляется значение логического выражения. Если же логическое выражение имеет значение false, оператор тела цикла не выполняется и производится переход на следующий после цикла оператор.

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

Введем обозначения: sum — сумма; num — число слагаемых; w — значение очередного слагаемого. Вначале величины sum и num равны нулю. Цикл продолжается, пока выполняется неравенство sum<100.

program store;    var sum,w:real;    num:integer; begin      num:=0;sum:=0;      while sum<100 do      begin           writeln('введите слагаемое');           readln(w);           sum:=sum+w;           if sum<=100 then num:=num+1           else writeln('сумма превысила 100')      end;      writeln('число слагаемых =',num:3) end.

 

Оператор цикла с постусловием имеет форму:

repeat <последовательность операторов> until <логическое выражение>

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

Решим предыдущую задачу, применяя цикл с постусловием. Цикл заканчивается, если выполняется условие: sum>100.

program store2;    var sum,w:real; num:integer; begin      num:=0;sum:=0;      repeat            writeln('слагаемое');            readln(w); sum:=sum+w;            if sum<=100 then num:=num+1            else writeln('сумма превысила 100')      until sum>=100;      writeln('количество слагаемых =',num:3) end.

 

Оператор цикла с параметром предусматривает вычисление выражений 1 и 2, присвоение параметру цикла значения выражения 1, проверку, что оно не превышает значения выражения 2, и, если это так, выполнение оператора тела цикла, после чего параметр изменяется на 1 и все повторяется. Если же параметр при проверке оказывается больше значения выражения 2, оператор тела цикла не выполняется и происходит переход на оператор, следующий после цикла.

Оператор цикла с параметром имеет две формы:

 for <параметр>:= <выражение 1> to <выражение 2> do <оператор>

<Параметр>, <выражение 1>, <выражение 2> должны быть одного типа, относящегося к ординарным типам. <Параметр> в этом цикле возрастает. Действие эквивалентно действию следующего составного оператора:

   begin

        <параметр>:=<выражение 1>;         while <параметр> <= <выражение 2> do         begin

              <oператор>;

              <параметр>:=succ(<параметр>)         end    end.

 for <параметр>:=<выражение 1> downto <выражение 2> do <оператор> Этот цикл эквивалентен следующему:

   begin

        <параметр>:=<выражение 1>;         while <параметр> >= <выражение 2> do         begin

              <oператор>;

              <параметр>:=pred(<параметр>)         end    end.

Пример: составим программу, по которой будет напечатана таблица перевода километров в мили (1 миля = 1,603 км). Параметром цикла можно считать целую величину k — количество километров. Пусть эта величина изменяется от 1 до 10 (с шагом 1, разумеется).

program mili;

   const a=1.603; b='км'; c='мили';    var k:integer; m:real; begin

     writeln(b:5,c:7); writeln;      for k:=1 to 10 do

     begin

          m:=k/a; writeln(k:5,m:6:3)      end end.

 

Запишем в этой программе цикл с параметром по второй форме:

for k:=10 downto 1 do begin

     m:=k/a; writeln(k:5,m:6:3) end.

Тогда значения k в таблице будут убывать от 10 до 1 с шагом 1.

Структуры данных

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

Помимо простых предопределенных типов real, integer, boolean, byte, char, программист по своему желанию может определить новые типы.

Еще один ординарный тип данных — перечисляемый тип, он  задается путем перечисления его элементов.

Описание перечисляемого типа выполняется в разделе типов следующим образом: type <имя типа> = <список имен> Примеры:

type operator = (plus,minus,multi,divide); color = (white,red,blue,yelow,purple,green); В списке должно быть не более 256 имен.

К элементам перечисляемого типа можно применять функции ord(x), pred(x), succ(x) и операции отношения. Отметим, что данные этого типа не подлежат вводу и выводу с помощью функций ввода/вывода и могут использоваться внутри программы для повышения ее читабельности и понятности.

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

program week;    type days=(mon,tue,wed,thu,fri,sat,sun);    var d:days; begin      for d:=mon to sun do      case d of           mon:writeln('понедельник');           tue:writeln('вторник');           wed:writeln('среда');           thu:writeln('четверг');           fri:writeln('пятница');           sat:writeln('суббота');           sun:writeln('воскресенье')      end end.

 

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

type days=(mon,tue,wed,thu,fri,sat,sun); workdays=mon..fri; index=1..30; letter='a'..'z';

Можно задать интервал и в разделе переменных: var a:1..100; b:–25..25;

Операции и функции — те же, что и для базового типа. Использование интервальных типов в программе позволяет экономить память и избегать выхода значения переменной интервального типа за границы интервала. Пример: если k — номер месяца в году, то вместо описания var k:integer; можно написать var k:1..12;

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

Часто используемый составной тип — массив. Массив — это последовательность, состоящая из заранее задаваемого числа элементов одного типа. Массивы необходимы для решения таких задач, когда требуется одновременно иметь в памяти набор однотипных данных и выполнять их преобразования, т. е. использовать прямой доступ к этим данным с помощью вычисляемых значений индексов.

Все элементы массива имеют общее имя (имя массива) и различаются индексами. Индексы можно вычислять, их тип должен быть ординарным. При описании массивов используются служебные слова array и of. В описании массива указывается тип его элементов и типы их индексов.

Форма описания такова: type <имя типа> = array [<список типов индексов>] of <тип элементов>

Тип элементов — произвольный, он также может быть составным. Число индексов называется размерностью массива. После описания типа массива конкретные массивы можно задать в разделе описания переменных.

Например:

type vector = array [1..10] of real; table = array ['A'..'Z',1..5] of integer; var a,b : vector;       c : table;

Отметим, что тип массива table — двухмерный, это таблица, положение элемента в которой задается двумя индексами — латинской буквой и цифрой от 1 до 5. Обращение к элементу массива осуществляется с помощью задания имени переменной, за которым следует заключенный в квадратные скобки список индексов элемента.

Например: а[7]:=3.1; b[k*k+1]:=0; c['M',3]:=–14;

Если массивы имеют одно и то же описание, то во многих версиях Паскаля допустимо их копирование, например: b:=a;.

Описание массива можно совместить с описанием соответствующих переменных:

var  a,b : array [1..10] of real;        d : array [byte] of char;

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

Форма описания начальных значений элементов массива: const <имя массива>: <тип массива> = (<список значений элементов>) Тип массива может быть описан ранее:

type digits = array [1..5] of char; const a : digits =('0','2','4','6','8');

Рассмотрим часто встречающуюся задачу упорядочения членов числовой последовательности по какому-либо признаку.

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

Используем метод упорядочения, носящий имя метод "пузырька". Здесь имеет место аналогия с "всплыванием" пузырька в жидкости под действием силы Архимеда. Будем сравнивать пары соседних элементов последовательно справа налево и переставлять элементы в паре, если они стоят в порядке, не соответствующем требуемому:

5,3,2,4,1 → 5,3,2,1,4 → 5,3,1,2,4 → 5,1,3,2,4 → 1,5,3,2,4

В начале просмотра присвоим некоторой логической переменной значение true: p:=true;

Если при просмотре пар была совершена хотя бы одна перестановка, изменим значение логической переменной на противоположное:

p:=false;

Это означает, что последовательность еще не была упорядочена и просмотр пар надо повторить. Цикл просмотров заканчивается, если после очередного просмотра выполняется условие:

p=true;

Последовательность зададим в программе как массив типизированных констант из 10 элементов — целых чисел.

program bubble;    const a:array[1..10] of integer=(19,8,17,6,15,4,13,2,11,0);    var b,i:integer; p :boolean; begin clrscr;

     for i:=1 to 10 do write(a[i]:3); writeln; writeln;      repeat p:=true;

            for i:=10 downto 2 do             if a[i]<a[i–1] then             begin                  b:=a[i];a[i]:=a[i–1]; a[i–1]:=b; p:=false             end      until p=true;      for i:=1 to 10 do write(a[i]:3);      writeln end.

 

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

При решении различных задач обработки информации часто возникает необходимость в использовании последовательностей символов. Такую последовательность можно описать как массив символов, однако в Паскале для таких целей имеется более удобный тип данных string[n] строка из n символов, где n<=255. Отметим, что элемент строки с индексом 0 хранит заданную при описании длину строки n, а элементы строки индексируются целыми числами от 1 до n. Способы описания переменных — строк — аналогичны описанию массивов.

 Строковый тип определяется в разделе описания типов, переменные этого типа — в разделе описания переменных:

   type word : string[20];    var a,b,c : word;

 Можно совместить описание строкового типа и соответствующих переменных в разделе описания переменных:

   var a,b,c : string[20];    d : string[30];

 Можно определить строковую переменную и ее начальное значение как констант-строку:    const l:string[11]='информатика';

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

Для переменных одного строкового типа определен лексикографический порядок, являющийся следствием упорядоченности символьного типа:

'fife'<'tree' (т. к. 'f'<'t'); '4'>'237' (т. к. '4'>'2').

Кроме логических операций <, >, =, для величин строкового типа определена некоммутативная операция соединения (конкатенации), обозначаемая знаком плюс: a:='кол'+'о'+'кол'; (в результате a='колокол').

 

Для строковых величин определены следующие четыре стандартные функции:

 Функция соединения — concat(s1,s2,...,sk), аналогичная конкатенации с помощью операции "+". Значение функции — результат соединения строк s1, s2, ..., sk, если он содержит не более 255 символов.

 Функция выделения — copy(s,i,k). Выделяет k символов из строки s, начиная с i-того символа: a:=copy('крокодил',4,3);  В результате a='код'.

 Функция определения длины строки — length(s). Возвращает количество символов, имеющихся в строке s:

b:=length('каникулы');  В результате b=8.

 Функция определения позиции — pos(s,t). Определяет номер позиции, начиная с которого строка s входит первый раз в строку t; результат равен 0, если строка s не входит в t:

c:=pos('ом','компьютер');  В результате c=2.

В Паскале определены также четыре стандартные процедуры для обработки строковых величин:

 Процедура удаления — delete(s,i,k). Удаляет k символов из строки s, начиная с i-того символа. s:='таракан'; delete(s,5,2);

В результате s='таран'.

 Процедура вставки — insert(s,t,i). Вставляет в строку t строку s, начиная с позиции i:

t:='таран'; insert('ка',t,5); В результате t='таракан'.

 Процедура преобразования числа в строку символов — str(k,s). Превращает число k в строку s, каждый элемент которой — цифра числа k: str(564,s);

В результате s='564'.

 Процедура преобразования строки из цифр в число — val(s,k,i), кроме формирования числа k из цифр строки s определяет значение i=0, если 

в строке s нет символов, отличных от цифр, в противном случае i равно позиции первого символа, отличного от цифры:

val('780',k,i);

В результате k=780, i=0.

Рассмотрим несколько программ, в которых используются строковые величины.

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

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

program vowel;    const c:string[18]='аеиоуыэюяАЕИОУЫЭЮЯ';    var a :string[100]; k,n:integer; begin      writeln('введите текст'); readln(a);n:=0;      for k:=1 to length(a) do          if pos(a[k],c)>0 then n:=n+1;             writeln('кол. гласных=',n) end.

 

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

2.    Заменить в арифметическом выражении функцию sqr на exp. Замена выражения sqr на exp достигается последовательным применением процедур delete и insert.

program stroka;    var a,b:string[40]; k:integer; begin      writeln('введите строку <= 40 символов');      readln(a);b:=a;      repeat k:=pos('sqr',b);             if k>0 then

            begin                  delete(b,k,3);insert('exp',b,k);             end      until k=0;      writeln('старая строка=',a); writeln('новая строка=',b); end.

 

3.    Ввести и упорядочить по алфавиту 10 латинских слов. В программе определим массив из 10 элементов-строк и упорядочим его элементы методом пузырька.

program order;    const s=10;    type word=string[20];    var i,j,k :1..s;        b:word; p:boolean; list :array[1..s] of word; begin      clrscr;writeln('введите список слов');      for i:=1 to s do readln(list[i]);      repeat p:=true;            for i:=s downto 2 do            if list[i]<list[i–1] then            begin                b:=list[i]; list[i]:=list[i–1];                list[i–1]:=b; p:=false            end      until p=true;      writeln('упорядоченный список слов:');      for i:=1 to s do writeln(list[i]) end.

 

Множество в Паскале позволяет решать задачи, требующие сравнения значений ординальных величин и имеет такой же смысл, как и в алгебре, — это неупорядоченная совокупность отличных друг от друга однотипных элементов. Число элементов множества не должно превышать 255. В качестве типа элементов может быть любой ординарный тип, кроме типа integer и его интервалов, содержащих числа >255. Тип элементов множества называется базовым. При описании множественного типа используются служебные слова set и of. Задание конкретного множества определяется правилом (конструктором) — списком элементов или интервалов, заключенным в квадратные скобки. Пустое множество обозначается двумя символами [].

Множественный тип можно определить в разделе описания типов по схеме: type <имя> = set of <тип элементов>; Например:

type t=set of byte; var a:t;

Можно совместить описание множественного типа и соответствующих переменных:

var code : set of 0..7;     digits : set of '0' . . '9';

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

type up=set of 'A' . . 'Z';       low=set of 'a' . . 'z'; const upcase : up=['A' . . 'Z'];       vocals : low=['a', 'e', 'i', 'o', 'u', 'y'];

      delimiter : set of char=[' ' . . ' / ' , ' : ' . . ' ? '];

Для данных множественного типа определены операции объединения, пересечения и дополнения множеств, обозначаемые в Паскале соответственно знаками +, * и –, а также отношения равенства множеств (A=B), неравенства (A<>B), включения (A<=B, A>=B).

Логическая операция проверки принадлежности элемента x множеству A 

(x in A) принимает значение true, если элемент x принадлежит множеству A, и false в противном случае. Так как к элементам множества прямого доступа нет, то операция in часто используется для этой цели.

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

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

Пусть alfa — множество всех букв латинского алфавита. Будем вводить заданный текст с клавиатуры символ за символом, одновременно формируя множество E — множество латинских букв текста. В конце текста введем символ *. Затем с помощью операции in будем проверять, какие буквы алфавита имеются во множестве E. Множество N — множество ненайденных букв в тексте — определяется оператором: N:=alfa–E.

program search;    const alfa:set of char=['a' ..'z'];    var c:char;E,N:set of char; begin      clrscr; E:=[]; writeln('введите текст, конец ввода -*');read(c);      while c<> '*' do      begin           if c in alfa then E:=E+[c]; read(c)      end;      writeln;      if E=alfa then writeln('найдены все латинские буквы')      else begin

               N:=alfa–E;                writeln('найдены:');                for c:='a' to 'z' do if c in E then write(c);                writeln; writeln('не найдены:');                for c:='a' to 'z' do if c in N then write(c);                writeln      end end.

 

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

type address = record        index     : string[6];        city      : string[20];        street    : string[20];        haus,flat : integer        end;

Из примера видно, что тип "запись" описывается по схеме

type <имя типа записи> = record        <имя поля 1> : <тип>;

       <имя поля 2> : <тип>;        .....................        <имя поля N> : <тип>        end;

Как и при описании массивов, можно совместить описание типа записи и соответствующих переменных. Например, данные о двух книгах можно описать так:

var book1,book2 : record        authors   : string[20];        title     : string[40];        pages     : integer;        publisher : string[20];        year      : integer        end;

Переменную типа "запись" и ее первоначальное значение можно определить в разделе констант в следующем виде:

const <имя>: <имя типа> = <константное значение>

<Константное значение> — это список имен полей и соответствующих значений, заключенный в круглые скобки. Элементы списка разделяются знаком "точка с запятой". Например, запись о начале координат можно определить так:

type point = record        x, y, z : integer        end;

const o: point = (x:0; y:0; z:0);

С компонентами записи можно обращаться как с переменными соответствующего типа. Обращение к компонентам записи осуществляется с помощью указания имени поля через точку. Пусть, например, переменная х имеет тип address, т. е. в программе имеется описание var x: address. Тогда допустимы следующие присваивания:

x.haus:=52; x.street:='пр.Героев'; x.city:='Москва';

x.flat:=135; x.index:='129113'

Для того чтобы облегчить запись операций над полями записи, служит опeрaтор with do. Предыдущий пример с использованием этого оператора можно переписать так:

with x do        begin haus:=52; street:='пр.Героев';              city:='Москва'; flat:=135; index:='129113'        end

В операторах присваивания разрешается использовать не только имена полей, но и имена записей.

Тип поля также может быть записью.

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

man = record    fio : record       fam, im, otch : string[10];       end;    data : record       day : 1..31;       mes : 1..12;       god : integer       end;    pol : char;    telef : record       dom,rab : string[10];       end; end;

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

Процедуры и функции

Важное значение в Паскале имеют процедуры  и  функции, определяемые программистом. Эти конструкции позволяют разрабатывать и отлаживать модульные программы, содержащие десятки и сотни тысяч команд. Создание таких программ без аппарата процедур и функций было бы невозможным, поскольку работа с такими программами превосходит по своей сложности возможности человека и не обеспечивает разделения труда в программистских коллективах. Использование процедур и функций, напротив, позволяет "разбить" исходную задачу на набор взаимосвязанных подзадач, для решения каждой из них независимо друг от друга разработать и отладить силами многих программистов подпрограммы и функции размером 15—20 строк и таким образом по принципу "разделяй и властвуй" решить сложную задачу.

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

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

Процедура имеет такую же структуру, как и программа, но с двумя отли-

чиями:

 описание процедуры заканчивается точкой с запятой (а не точкой);

 заголовок процедуры начинается со служебного слова procedure, за которым следует список формальных параметров — аргументов в следующей форме:

procedure <имя> (<список описаний формальных параметров>);

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

Данные для обработки могут передаваться процедуре через глобальные имена или через параметры процедуры. Описание формальных параметров может иметь вид:

<список имен>: <тип> или var <список имен>: <тип>

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

Оператор вызова процедуры имеет вид:

<имя процедуры> (<список выражений и переменных>);

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

Пример: составим программу, которая с помощью строки символов разделит экран на части, где напечатает таблицу квадратных корней для чисел 1, 2,..., 10 и таблицу кубов чисел 1, 2,..., 5.

Печать строки символов оформим как процедуру. Так как никакую информацию передавать из процедуры в программу не надо, то аргументы процедуры (вид и количество символов) будут описаны как параметры-значения.

Заметим, что процедура в программе выполняется пять раз.

program section;    var x:integer;

   procedure line(a:integer;c:char);       var j:integer;    begin

        for j:=1 to a do write(c);         writeln    end; begin

     line(35,'–'); writeln('таблица квадратных корней');      line(35,'–');

     for x:=1 to 10 do writeln(x:8,sqrt(x):8,4);      line (35,'–'); writeln('таблица кубов чисел');      line(35,'–');

     for x:=1 to 5 do writeln(x:8,x*x*x:8:4);      line(35,'*') end.

 

Функции, определяемые в Паскале программистом, аналогичны процедурам с тем отличием, что идентификатор (имя) функции служит для возврата в вызвавшую ее программу, процедуру или функцию скалярного, вещественного или строкового значения. 

Отличия функции от процедуры:

 заголовок функции начинается со служебного слова function и заканчивается указанием типа значения функции:

function <имя> (<список описаний формальных параметров>): <тип>;

 раздел операторов функции должен содержать хотя бы один оператор присваивания имени функции;

 обращение к функции — не оператор, а выражение вида:

<имя функции> (<список фактических параметров>);

Функции (и процедуры) могут использовать свое имя в собственном описании, т. е. могут быть рекурсивными.

Пример: составим программу, которая для заданных четырех натуральных чисел a, b, c, d напечатает наибольшие общие делители первой и второй пар чисел и сравнит их по величине.

Определим рекурсивную функцию nod(x,y) с помощью формул:

                   x, если y=0

nod(x,y)    nod(y,x), если x<y                    nod(x mod y,y), если x>y

 

Применяя эти формулы к числам 21 и 15, последовательно находим: nod(21,15) = nod(6,15) = nod(15,6) = nod(3,6) = nod(6,3) = nod(0,3) = nod(3,0) = 3.

program four;    var a,b,c,d,m,n:integer;    function nod(x,y:integer):integer;       var h:integer;    begin         if y=0 then h:=x                else if x<y then h:=nod(y,x)                else h:=nod(x mod y, y);         nod:=h    end; begin      writeln('введите 4 натуральных числа');      read(a,b,c,d); writeln;      m:=nod(a,b); n:=nod(c,d);      writeln('нод(',a,',',b,')=',m);      writeln('нод(',c,',',d,')=',n);      if m>n then writeln('первый > второго')             else if m<n then writeln(' первый < второго')                         else writeln('нод пар равны') end.

 

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

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

В промышленных версиях Паскаля для создания библиотек и разделения больших программ на логически связанные независимые друг от друга составные части используют модули. В состав модуля входят следующие разделы: заголовок, интерфейс, реализация, инициализация. Заголовок необходим для ссылок на модуль. Интерфейс содержит объявления, включая процедуры и функции, представленные списком заголовков и доступные пользователям в теле основной программы. Раздел "реализация" содержит тела процедур и функций, перечисленных в интерфейсной части модуля. Раздел "инициализация" содержит операторы, необходимые для инициализации модуля. Таким образом, модуль — это набор констант, типов данных, переменных, процедур и функций. Каждый модуль компилируется отдельно; результат компиляции сохраняется как библиотека процедур и функций. Каждый элемент модуля можно использовать в программе пользователя без дополнительного объявления, для чего достаточно записать имя используемого модуля в директиве uses в начале программы после ее заголовка.

Известны стандартные модули Crt, Graph и др., применяемые в Турбо Паскале (Turbo Pascal) — одной из версий Паскаля. В этих модулях содержатся сервисные процедуры и функции по работе с экраном дисплея, клавиатурой, графическими примитивами и т. п. Модули подключаются к программе специальной командой, размещаемой сразу после заголовка: uses <имя модуля>;

Программист может сам создать модуль.

Этот модуль может быть отдельно откомпилирован. После этого любая программа, написанная на Паскале, может получить доступ к интерфейсным объектам (в данном случае — процедурам) этого модуля с помощью директивы uses <имя модуля>. При описании модуля в интерфейсной части модуля от процедур присутствуют лишь заголовки, а в части "реализация" от заголовков процедур остаются лишь их имена.

Обработка файлов

Одна из наиболее фундаментальных структур данных — файл (последовательность). Программная организация компьютеров, их связь с внешними устройствами основаны на файловой структуре.

Файлы позволяют решить две проблемы:

 возможность формирования и сохранения значений для последующего использования другими программами (например, в программах многократной обработки информационных систем, таких как платежные ведомости, различные АСУ, базы данных, необходимость длительного хранения информации очевидна);

 взаимодействие программ с внешними устройствами ввода/вывода: дисплеем, принтером, АСП и т. п.

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

Файловый тип данных в программе задается следующим образом: type <имя файлового типа> = file of <тип компонентов>;

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

Например:

type

    intfile = file of integer;     refile = file of real;     chfile = file of char;     ran = 1 . . 10;     st = set of ran;     vector = array[ran] of real;     compl = record        re,im : integer;        end;

    setfile = file of st;     vecfile = file of vector;     compfile= file of compl;

Описание файловой переменной задается обычным способом в разделе описаний. Например: var f: intfile; или var f : file of integer;

Файловая переменная является буфером между Паскаль-программой и внешним устройством и должна быть логически с ним связана. Связь осуществляется оператором языка Паскаль: assign (<имя файловой переменной>,'<имя устройства>');

Как правило, файлы для хранения данных связаны с устройством внешней памяти на магнитных носителях (дисковод) и носят название внешние файлы. Если, например, файл с именем primer.dat логически связан с дисководом A:, то все данные, помещаемые в файл, будут храниться на этом дисковом накопителе, а установка "окна" между программой и файлом будет определяться через файловую переменную f оператором: assign (f, 'primer.dat');

Если внешним устройством является принтер, то связь осуществляется оператором:

assign(f, 'lst:');

Здесь lst — логическое имя печатающего устройства. Далее приведены логические имена внешних устройств ввода/вывода: con — консоль; trm — терминал; kbd — клавиатура; lst — принтер; aux — буфер сети; usr — драйвер пользователя.

После осуществления связи файловая переменная f отождествляется с соответствующим файлом.

Для работы с файлом его необходимо открыть, а по окончании работы — закрыть. Файл открывается для чтения оператором reset(f), для записи — оператором rewrite(f).

Чтение и запись данных осуществляются известными командами read/write, только в начале списка помещается имя файловой переменной:

read (f, <список ввода>); readln (f, <список ввода>); write(f, <список вывода>); writeln(f, <список вывода>);

Закрытие файла осуществляется командой close(f).

Условно файл можно представить в виде ленты, у которой есть начало, а конец не фиксируется. Компоненты файла записываются на эту ленту последовательно, друг за другом:

f 0

f 1

f 2

f 3

...

м.к.

                                                                                     ^ т.м.                                             

Здесь т.м. — текущий маркер, указывающий на рабочую позицию (окно) файла; м.к. (маркер конца файла) — специальный код, автоматически формируемый вслед за последним элементом файла.

Такого рода файлы называются файлами последовательного доступа. В исходной версии Паскаля файлов прямого доступа, для которых можно непосредственно "достать" любую компоненту, не предусмотрено; однако в Турбо Паскале элементы прямого доступа есть (например, через функцию seek, см. далее).

Команда rewrite(f) — открыть файл для записи — устанавливает файл в начальное состояние режима записи; текущий маркер устанавливается на маркер конца файла. Если в файле f до этого была информация, то она уничтожается.

В открытом для чтения командой reset(f) файле текущий маркер устанавливается на нулевое состояние, однако содержимое файла не утрачивается.

rewrite(f)

м.к.

                                                           ^                                                 

reset(f)

f0

f1

f2

f3

...

м.к.

                               ^                                                                                                          

Команда закрытия файла close(f) обязательна, поскольку эта команда формирует маркер конца файла, что в большинстве случаев является необходимым (например, для работы с функцией eof(f), см. далее).

В системе Турбо Паскаль предусмотрены встроенные функции по работе с файлами:

 filesize(f) — текущее количество компонент открытого файла;

 filepos(f) — номер текущей позиции маркера;

 rename(f,имя) — переименование файла, связанного с f;

 erase(f) — уничтожение файла;

 execute(f) — выполнение COM-файла;

 chain(f) — выполнение CHN-файла;

 seek(f,N) — устанавливает маркер на позицию N;  eof(f) — возвращает true, если найден конец файла;

 ealn(f) — возвращает true, если найден конец строки.

На практике широко используются текстовые файлы, которые состоят из литерных (логических) строк. Поэтому в языке Паскаль предусмотрен стандартный файловый тип text (он не является file of char, скорее всего, это — file of string[n]). Логические строки бывают разной длины, в том числе и нулевой. В конец каждой строки помещается специальный символ "конец строки" (eoln — "end of line"). В качестве печатного символа конца строки используют литеру #. Текстовый файл (text) является строго последовательным, к нему не применимы некоторые встроенные функции, в частности, seek. В отличие от типизированных файлов, с текстовым файлом нельзя одновременно проводить операции чтения (read) и записи (write). Однако допустимы операторы writeln и readln. Числовые данные, целые и вещественные, в текстовом файле должны записываться через пробел.

Далее приведены несколько примеров, иллюстрирующих работу с файлами.

Пример 1. Вывод данных на печатающее устройство — принтер (lst:).

program print;    var    fal :text; x :real; name :string[25]; begin      assign(fal,'lst:'); rewrite(fal); x:=2.5; name:='Слава';      writeln(fal,x:8:2);      writeln(fal,'Привет, ',name); close(fal) end.  {Здесь файловая переменная fal связывается с принтером lst:,          и запись в файл fal практически означает вывод на печать}

 

Пример 2. Создание и сохранение в файле xxx.dat последовательности целых чисел от 10 до 20.

program zapis;    var    f: file of integer; i: integer; begin      assign(f,'xxx.dat'); rewrite(f);      for i:=10 to 20 do write(f,i); close (f); end.  {После выполнения программы формируется внешний файл xxx.dat} 

Пример 3. Считывание первых пяти компонент из существующего файла xxx.dat и вывод на дисплей квадратов этих значений.

program read;    var ff: file of integer; j,i : integer; begin      assign(ff,'xxx.dat'); reset(ff);      for j:=1 to 5 do begin read(ff,i); writeln(i*i);      end;      close(ff); end.

 

Пример 4. В текстовом файле (text) slov.txt содержится русский текст. Определить, сколько гласных букв в тексте.

program text;    var    ft : text; n : integer; ch : char; st : set of char; begin      assign (ft,'slov.txt'); reset(ft);      st := ['А','Е','И','О','У','Ы','Э','Ю','Я'];      st := st+['а','е','и','о','у','ы','э','ю','я'];      n:=0;      while not eof(ft) do      begin           read(ft, ch); if ch in st then n:=n+1;      end;      close(ft);

     writeln; write('кол-во гласных букв =',n); end.

 

Поскольку длина текста (файла) неизвестна, то в цикле "пока" используется логическая функция eof(f), которая возвращает значение true, если найден конец файла.

Пример 5. Шифрование и дешифрование текста.

Программа шифрования заданного текста (sekret) использует следующее правило шифровки: каждая буква в тексте заменяется на букву, расположенную на n позиций вправо от искомой в русском алфавите. Причем последним символом алфавита является пробел ' ', далее алфавит продолжается циклически.

Значение смещения n находится вo внешнем файле n.key, который формируется программой key. Зашифрованный текст выводится во внешний файл с именем шифр.txt, а также на дисплей.

Программа дешифровки (retsek) считывает шифрованный текст из файла шифр.txt и выводит на экран дисплея искомый текст.

program key;    var    n : integer; f : file of integer; begin      assign (f,'n.key'); rewrite(f); write('введи ключ(смещение): ');      readln(n);      write(f,n); close(f); end. 

program sekret;    var    slovo,anslovo: string[100];    alfavit : string[33];    n, i, k, p : integer;    fkl : file of integer;    fs : text; begin      alfavit:='абвгдежзийклмнопрстуфхцчшщъыьэюя ';      assign(fkl,'n.key'); reset(fkl); read(fkl,n); close(fkl);      writeln; write('введи текст: ');      readln(slovo); anslovo:='';      for k:=1 to length(slovo) do      begin for i:=1 to 33 do

           if slovo[k]=alfavit[i] then begin p:=i+n;               if p >33 then p:=p mod 33;               anslovo:=anslovo+alfavit[p];

           end;      end;      assign(fs,'шифр.txt'); rewrite(fs); write(fs,anslovo);close(fs);      writeln; write(anslovo); end. 

program retsek;    var slovo, anslovo : string[100];    alfavit : string[33];    n, i, k, p : integer;    fi : file of integer;    f : text; begin alfavit:='абвгдежзийклмнопрстуфхцчшщъыьэюя ';       assign(fi,'n.key'); reset(fi); read(fi,n); close(fi);       assign(f,'шифр.txt'); reset(f); read(f,anslovo); close(f)       slovo:='';       for k:=1 to length(anslovo) do       begin for i:=1 to 33 do             if anslovo[k]=alfavit[i] then begin                 p:=i–n; if p < 1 then p:=33–p mod 33;                 slovo:=slovo+alfavit[p];             end;       end;       writeln; write('текст шифровки: ',slovo); end. 

Динамические информационные структуры

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

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

В языке Паскаль предусмотрена возможность использования динамических величин. Для них выделение и очистка памяти происходят не на этапе трансляции, а в ходе выполнения самой программы. Для работы с динамическими величинами в Паскале предусмотрен специальный тип значений — ссылочный. Этот тип не относится ни к простым, ни к составным. Переменные ссылочного типа, или указатели, являются статическими переменными. Значением переменной ссылочного типа является адрес ячейки — места в памяти соответствующей динамической величины. Свое значение ссылочная переменная получает в процессе выполнения программы, в момент появления соответствующей динамической величины.

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

Значением указателя является адрес ячейки, начиная с которой будет размещена в памяти соответствующая динамическая величина. Задание ссылочного типа выполняется по схеме: type <имя ссылочного типа> = ^ <имя типа динамической величины> Значок ^ указывает на то, что величина является динамической.

Например:

type

    p = ^ integer;     q = ^ record     x: integer;     y: string [20]     end;

Объявлены два ссылочных типа — p и q. Первый — указатель на целочисленные значения, второй — на запись из двух полей.

Связь указателя с динамическим объектом можно изобразить следующим образом:

p

 

На этой схеме р — имя указателя; звездочкой изображено значение указателя, а стрелка отражает тот факт, что значением указателя является адрес  объекта (ссылка на объект), посредством которого объект и доступен в программе.

В некоторых случаях возникает необходимость в качестве значения указателя принять "пустую" ссылку, которая не связывает с указателем никакого объекта. Такое значение в Паскале задается служебным словом nil и принадлежит любому ссылочному типу. Результаты выполнения оператора p:=nil; можно изобразить следующим образом:

p

 

Имея объявленные типы, можно обычным образом описывать переменные этих типов. Например: var i: p; zap: q;

Динамические переменные базовых типов можно вводить прямо в разделе описания переменных: var i: ^integer;

Описание указателя еще не резервирует память для значения соответствующего динамического объекта. Так, каждое приведенное ранее описание выделяет в памяти два байта для записи адреса * — значения указателя, но никакой величины типа p или q в памяти не образуется, и даже адреса * еще нет.

Для порождения динамического объекта, на который указывает ссылочная переменная i, служит стандартная процедура new(i), где new — "новый" — имя процедуры, i — имя указателя.

Процедура new(i) выполняет две функции:

 резервирует место в памяти для размещения динамического объекта соответствующего типа с именем i;

 указателю i присваивает адрес динамического объекта i.

Однако узнать адрес динамической переменной с помощью процедуры writeln(i) нельзя.

Динамические объекты размещаются по типу стека в специальной области памяти — так называемой "куче", свободной от программ и статических переменных. Как уже было отмечено, символ ^ после имени указателя означает, что речь идет не о значении ссылочной переменной, а о значении того динамического объекта, на который указывает эта ссылочная переменная. Так, если в программе имеется описание переменной var i:^integer;

то при выполнении процедуры new(i) порождается динамическая переменная типа integer. Если затем будет выполнен оператор присваивания i^:= 58; то этой динамической переменной будет присвоено значение 58.

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

Так, если j — статическая переменная типа integer, то допустимы операторы присваивания j:=j+i^+2; i^:=i^ div 3+7; i^:=sqr(i^) и т. д. Если ссылочная переменная b указывает на массив

type mas = array[1...100] of integer; var b:^mas то в этом случае переменные с указателем могут выглядеть, например, так: b^[2], b^[k+5].

Если в процессе выполнения программы некоторый динамический объект p^, созданный в результате выполнения оператора new(p), становится ненужным, то его можно уничтожить (очистить выделенное ему место в памяти) с помощью стандартной процедуры dispose(p). В результате выполнения оператора вида dispose(p) динамический объект, на который указывает ссылочная переменная p, прекращает свое существование, занимаемое им место в памяти становится свободным, а значение указателя р становится неопределенным (но не равным nil).

Если p имел пустое значение nil до вызова процедуры dispose(p), то это приведет к "зависанию" программы.

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

Значение одного указателя можно присвоить другому указателю того же типа. Можно также указатели одинакового типа сравнивать друг с другом, используя отношения "=" или "<>".

Стандартные процедуры new и dispose позволяют динамически порождать программные объекты и уничтожать их, что дает возможность использовать память машины более эффективно.

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

 не определенное заранее число элементов;

 необходимость хранения в оперативной памяти.

Средство для реализации таких структур дает аппарат динамических переменных.

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

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

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

 связывание последующих компонентов стека;

 смещение ссылок при каждом движении по стеку.

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

                              a  a                     . . .           a  a                 ni^l

(элементу, который пришел первым, ссылаться не на что, о чем свидетельствует "пустая ссылка" nil).

Пусть для конкретности элементы стека — действительные числа, и при последовательном заполнении состояния стека будут:

                  1,75

                       35,7 1,75

                            –6,94 35,7 1,75

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

program stack;     {формирование динамической структуры — стека}    type s=^StackComp; StackComp=record         b:real;         p:s;         end;    var a:s; k:real;    procedure Dobavl(k:real);  {процедура добавления к стеку числа k}       var j:s;    begin new(j);           {создание новой динамической записи}          j^.b:=k;          {внесение следующей компоненты стека}          j^.p:=a;          {смещение указателя}          a:=j              {формирование новой записи}    end;    procedure Vzjat(var k:real);  {процедура чтения из стека}       var j:s;    begin j:=a;          k:=j^.b;          {k–значение последней компоненты}          a:=j^.p;          {перенастройка указателя}          dispose(j)        {ликвидация использованной записи}    end; begin                      {пример записи и чтения}      a:=nil; Dobavl(1.75);

     Dobavl(35.7);

     Dobavl(–6.94);           {сформирован стек: –6.94, 35.7, 1.75}

     Vzjat(k); writeln(k);    {контрольное взятие из стека}

     Vzjat(k); writeln(k);    {еще одно взятие из стека}      Vzjat(k); writeln(k)     {еще одно взятие из стека} end.                    {результат работы программы: –6.94 35.7 1.75} 

Работа с графикой

Машинная (компьютерная) графика — одно из важных направлений в современной прикладной информатике. В отличие от базового Паскаля, современные версии содержат мощные средства разработки графических программ. Рассмотрим часть соответствующих возможностей Турбо Паскаля, в котором они реализованы с помощью стандартного модуля Graph.

Модуль представляет собой мощную библиотеку графических подпрограмм универсального назначения, рассчитанную на работу с наиболее распространенными графическими адаптерами SVGA IBM-совместимых персональных

компьютеров.

Подключение модуля Graph.tpu к программе выполняется директивой uses graph;

Инициализация графического экрана осуществляется с помощью процедуры Initgraph. Процедура инициализации в Турбо Паскале имеет три аргумента:

Initgraph(<драйвер>, <режим>, '<путь к драйверу>') Она может быть выполнена так:

uses graph;    var gd, gm: integer;   {переменные gd и gm определяют                            драйвер и режим} begin      gd:=vga; gm:=vgahi;      initgraph(gd,gm,'d:\tp55');     ...

Первые две команды можно заменить одной: gd:=detect;

Целая константа detect=0 в модуле Graph автоматически распознает драйвер и устанавливает режим максимального разрешения для данной машины.

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

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

uses graph; var gd, gm, errorcod: integer; begin      gd:=detect; initgraph(gd,gm,'');      errorcod:=graphresult;      if errorcod<>grok then      begin           writeln('ошибка графики');           writeln(grapherrormsg(errorcod));           halt      end;

Процедура Halt останавливает выполнение программы и возвращает управление операционной системе.

Для формирования палитры используется система смешения красного, зеленого и синего цветов и изменения яркости луча. Цвет задается номером из списка цветов палитры в интервале 0 .. 15.

Процедуры setcolor(<цвет>) и setbkcolor(<цвет>) устанавливают текущий цвет рисунка и цвет фона. При инициализации графики по умолчанию устанавливается черный фон и белый цвет рисунка.

В табл. 5.3 указаны основные процедуры модуля Graph, применяющиеся для построения простейших геометрических примитивов.

Координаты точек воспринимаются в "экранной" системе координат, в которой начало — верхний левый угол экрана, ось X направлена вниз, ось Y — направо. Максимальные значения координат определяются разрешением.

В процедуре setlinestyle(a,b,t) первый аргумент а — стиль линии, второй параметр b — "образец" — имеет значение 4, если a=4, в остальных случаях b=0; третий параметр t — толщина линии — может иметь значение 1 (нормальная толщина) или 3 (жирная линия).

Таблица 5.3. Основные процедуры модуля Graph

Заголовок процедуры	Геометрический смысл
putpixel(x,y,c)	Построить точку (х,у) цветом с
setlinestyle(a,b,t)	Установить стиль, образец и толщину линий
line(x1,y1,x2,y2)	Соединить две точки отрезком
rectangle(x1,y1,x2,y2)	Построить прямоугольник с заданными концами диагонали и сторонами, параллельными осям координат
circle(x,y,r)	Построить окружность с центром (х,у) и радиусом r
arc(x,y,a,b,r)	Построить дугу окружности: а, b — начальный и конечный угол в градусах
ellipse(x,y,a,b,rx,ry)	Построить эллиптическую дугу: rx, ry — полуоси эллипса
setfillstyle(t,c)	Установить стиль закраски и ее цвет
fillellipse(x,y,rx,ry)	Построить закрашенный эллипс, используя цвет рисунка
floodfill(x,y,cg)	Закрасить фигуру до границы с цветом cg; (х,у) — внутренняя точка фигуры
bar(x1,y1,x2,y2)	Построить столбец, используя тип и цвет закраски
pieslice(x,y,a,b,r)	Построить и закрасить сектор круга
sector(x,y,a,b,rx,ry)	Построить и закрасить эллиптический сектор
settextstyle(f,n,d)	Установить шрифт, направление вывода и размер символа текста
outtextxy(x,y,st)	Вывести строку st, начиная с точки (х,у)

Таблица 5.3 (окончание)

Заголовок процедуры	Геометрический смысл
outtext(st)	Вывести строку, начиная с точки расположения текущего указателя

 

Первый аргумент процедуры setfillstyle(t,c) — тип закраски t — принимает значения из интервала 0..12. Наиболее употребителен тип t=1 — заполнение фигуры текущим цветом.

Для вывода текста на графический экран сначала выполняется процедура settextstyle(f,n,d), устанавливающая шрифт f, направление вывода n и размер символов (параметр d). При f=0 используется стандартный точечный шрифт, встроенный в систему Турбо Паскаль. С использованием других шрифтов познакомимся позже. Направление вывода n принимает значения 0 (горизонтальный вывод) и 1 (вертикальный вывод).

Размер букв определяется параметром d, принимающим значения из интервала 1..10. Если d=1 и f=0, то каждый символ занимает квадрат 8*8 точек, при d>1 сторона квадрата умножается на d.

Далее с помощью процедуры outtextxy(x,y,st) строка st выводится на экран, начиная с точки (x,y). Например:

settextstyle(0,0,2); outtextxy(100,200,'горизонтальная строка'); outtextxy(100,230,'размер увеличен вдвое');

Пример 1. Программа рисует звездное небо с 400 звездами, вспыхивающими постепенно, и полную желтую луну.

program sky;    uses crt,graph;    var k,gd,gm:integer; begin gd:=detect;       initgraph(gd,gm,''); randomize;       for k:=1 to 400 do       begin            putpixel(random(640),random(480),random(15)+1);            delay(10);       end;       setfillstyle(1,14); setcolor(14);       circle(550,80,30); floodfill(550,80,14);       repeat until keypressed; closegraph end.

Пример 2. Узор. Используя простейшие геометрические образы, строят замечательные графические изображения. Далее приведена программа изображения муарового узора, полученного пересечением двух семейств расходящихся отрезков прямых. Качество и изображение получаемого узора зависит  в основном от трех параметров: k1, k2 — расстояний между отрезками слева и справа; h — смещения вниз (вверх) всего семейства.

program uzor;    uses crt, graph;    var gd,gm,errCode,i,k1,k2,h: integer; begin      k1:=8; k2:=3; h:=110; gd:=Detect; InitGraph(gd,gm,'');      errCode:=GraphResult;      if errCode = grOk then begin            setcolor(green);            for i:=1 to (420 div k1) do            begin line(0,i*k1,640,i*k2+h); line(0,i*k2+h,640,i*k1);            end;            repeat until keypressed; CloseGraph;      end      else writeln('errCode=',errCode) end.

 

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

Пример 3. Программа 25 строит столбчатую диаграмму, наглядно отражающую числовую информацию о населении 6 крупных городов мира: Токио, Гамбурга, Москвы, Бангкока, Мехико и Парижа.

program colon;    uses crt,graph;    const m:array[1..6] of real=(11500,2300,9700,5100,12400,8200);    name:array[1..6] of    string=('Токио','Гамбург','Москва','Бангкок','Мехико','Париж');    var gd,gm,k,n,s:integer; st:string[6]; begin

     gd:=detect; initgraph(gd,gm,' '); setcolor(15); setlinestyle(0,0,1);      line(60,400,620,400); line(60,400,60,100);

     settextstyle(0,0,1);      for k:=1 to 12 do

     begin n:=1000*k; str(n,st); outtextxy(10,400–20*k–4,st);            line(60,400–k*20,65,400–k*20)      end;

     setcolor(14); settextstyle(0,0,2);

     outtextxy(120,20,'Население городов (тысяч)'); settextstyle(0,0,1);      for k:=1 to 6 do begin setfillstyle(1,k+2);

           bar(100+(k–1)*70,400,100+k*70,round(400–m[k]/1000*20));            outtextxy(100+(k–1)*70+4,450,name[k]);      end;

     repeat until keypressed; closegraph end.

 

Процедура bar3d(x1,y1,x2,y2,d,top) рисует трехмерный столбец, глубина которого определяется параметром d. Последний параметр процедуры top — логического типа. Если top=true, рисуется верхнее основание столбика, в противном случае оно не изображается, что позволяет рисовать столбики один над другим. Диаграммы с трехмерными столбиками красивы, но их труднее создавать.

Построение графиков функций. Построение графиков функций — неотъемлемая часть большинства программ, предназначенных для обучения математике, физике. Далее представлен пример программы построения графика функции y=x*x*sin(1/x) на произвольном отрезке [a,b]. Количество точек графика (параметр n) также задается произвольно (точка x=0 исключается, т. к. в ней функция не определена). В программе определяются величины t1=(x1–x0)/(b–a) и t2=(y1–y0)/(2m), которые означают масштабы по осям X и Y соответственно.

График рассматриваемой функции представлен на двух отрезках [a,b]  и [–0.1,0.1]. Чтобы построить график другой функции, достаточно задать ее аналитический вид в описании функции (function f).

program grafik;    uses crt, graph;

   var gd,gm, errCode : integer; a,b : real; n : integer;    function f(x:real):real;    begin if x<>0 then f:=x*x*sin(1/x);    end;

   procedure grafun(x0,x1,y0,y1,n :word;a,b:real);       var h,m,x, t1,t2 : real; i, u,v,xv,yv : word;    begin

        h:=(b–a)/n;                      {поиск максимума f(x)}         m:=abs(f(a));

        for i:=1 to n do if m<abs(f(a+i*h)) then m:=abs(f(a+i*h));         t1:=(x1–x0)/(b–a);

        t2:=(y1–y0)/(2*m);                {построение координатных осей}         setfillstyle(1,15); bar(x0–5,y0–5,x1+5,y1+5);         xv:=round(x0–a*t1); yv:=round((y0+y1)/2);         setcolor(1); line(xv,y0,xv,y1);         line(x0,yv,x1,yv);

        Moveto(x0,yv–round(f(a)*t2));  {установка курсора                                         в начало графика}         setcolor(3);                     {построение графика}         for i:=1 to n do         begin

            x:=a+i*h; u:=x0+round((x–a)*t1);             v:=yv–round(f(x)*t2); lineto(u,v);         end;

   end;                                  {конец процедуры } begin

     clrscr; write ('введи a,b и n : '); readln(a,b,n); gd:=Detect;      InitGraph(gd,gm,'');      errCode:=GraphResult;      if errCode = grOk then begin            grafun(100,500,50,300,n,a,b);            grafun(550,620,10,100,200,–0.1,0.1);            repeat until keypressed; CloseGraph;      end

     else writeln('errCode=',errCode); end.

 

Для изображения поверхностей, определяемых функцией двух переменных z=f(x,y), можно использовать разные способы. Одним из них является метод построения семейства одномерных графиков функции z=f(x,y) от одной переменной x или y различных фиксированных значениях другой. Это может быть хорошей тренировкой для самостоятельной работы по освоению гра- фики.

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

Наиболее просто это сделать по следующему плану:

1.    Нарисовать фрагмент в нужном месте экрана.

2.    Стереть фрагмент, рисуя его цветом фона или используя процедуру cleardevice.

3.    Снова нарисовать фрагмент в другом месте экрана.

Такой способ осуществлен в программе billiard, где два шарика радиусом 5 пикселов разных цветов двигаются с одинаковой скоростью внутри зеленого прямоугольника, построенного с помощью процедуры bar.

Процедура blou измеряет смещение центра шарика от сторон прямоугольника по каждой оси и, если это смещение на следующем шаге цикла станет меньше радиуса, изменяет направление движения, моделируя поведение упругого шара при ударе о стенку.

В программе также рассмотрена ситуация соприкосновения шариков во время их движения. Она решается примитивно просто: каждый шарик меняет направление своего движения на противоположное.

program billiard;    uses crt,graph;    var x,y,dx,dy,gd,gm:integer; x1,y1,dx1,dy1:integer;    procedure blow(a,b:integer; var c,d:integer);    begin if (a<107) or (a>523) then c:=–c;          if (b<107) or (b>363) then d:=–d;    end; begin      gd:=detect; initgraph(gd,gm,''); setcolor(14);      setlinestyle(0,0,1); rectangle(99,99,531,371);      setfillstyle(1,3); bar(100,100,530,370);      x:=320; y:=240; dx:=2; dy:=2;      x1:=320; y1:=200; dx1:=–2; dy1:=–2;      repeat circle(x,y,5); setcolor(4); circle(x1,y1,5);         blow(x,y,dx,dy); blow(x1,y1,dx1,dy1); delay(10);         if (abs(x–x1)<=10) and (abs(y–y1)<=10) then begin             dx:=–dx; dy:=–dy; dx1:=–dx1; dy1:=–dy1; delay(300)         end;

        setcolor(3); circle(x,y,5);         x:=x+dx; y:=y+dy;         setcolor(3); circle(x1,y1,5);         x1:=x1+dx1; y1:=y1+dy1; setcolor(14)      until keypressed;      closegraph end. 

Система программирования на Паскале

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

 E  — системное меню;

 File — работа с файлами (сохранение, загрузка, связь с операционной системой);

 Edit — редактирование текущего файла (стандартные возможности встроенного текстового редактора);

 Search — поиск и замена фрагментов текста;

 Run — запуск программы на выполнение;

 Compile — компиляция программы;

 Options — установка опций интегрированной среды;

 Debug — установка параметров отладки программы;

 Window — работа с окнами;

 Tools — инструментальные программные средства;  Help — система помощи и подсказок.

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

Компилятор может работать в трех режимах: обычном режиме MS DOS (Real), защищенном режиме (Protected) и в режиме операционной среды Windows (Windows). Синтаксическая подсветка обеспечивает цветовое выделение управляющих структур, зарезервированных слов, идентификаторов, строк и т. п. Секция меню Tools предназначена для передачи управления внешним программам и создания собственных инструментальных программных средств. Нажатие клавиш <Alt>+<F10> (или правый щелчок мыши) активизирует локальные меню, чувствительные к контексту (Browse, Edit, Help, Message, Watch).

Библиотека стандартных модулей включает модули: Crt, Graph, Graph3,

Overlay, String, System, Turbo3, WinAPI, WinCrt, WinDos, WinPrn, WinTypes, WinProcs.

 

Контрольные вопросы

 

1.       Назовите разделы программы на Паскале. Какова их последовательность?

2.       Какие типы данных относят к ординарным?

3.       Какие операции допустимы над величинами целого типа? Вещественного типа?

4.       Как в Паскале осуществляется ввод и вывод данных?

5.       Как в Паскале реализуется ветвление?

6.       В чем различие оператора ветвления и оператора выбора? Как реализуется оператор выбора?

7.       Какие виды оператора цикла имеются в языке Паскаль? Как эти операторы выполняются?

8.       Для чего служит и как определяется перечислимый тип данных?

9.       Для чего может понадобиться интервальный тип данных?

10.   Как описываются и используются в программах массивы?

11.   Какие действия возможны над величинами строкового типа?

12.   Какие операции допустимы над множествами?

13.   В чем различия между одномерными массивами и записями?

14.   Для чего служат и в каких случаях используются в программах процедуры и функции?

15.   По каким правилам описывают процедуры и функции и как их вызы- вают?

16.   Какие параметры называют формальными и какие — фактическими?

17.   В чем различие между локальными и глобальными переменными?

18.   Для чего служат модули?

19.   Для чего при программировании на Паскале используются файлы?

20.   Какие операции и функции используются при работе с файлами?

21.   В чем различие статических и динамических переменных?

22.   Как реализуется связь указателя с динамическим объектом?

23.   Что такое "связанный список данных"?

24.   Какими графическими процедурами располагает система программирования Турбо Паскаль?

25.   Как можно создать движущееся изображение?

 

 Темы для рефератов и докладов

1.    Развитие Паскаля от разработки Вирта до современных систем программирования.

2.    Принципы работы компилятора с языка Паскаль.

3.    Компьютерное представление данных различных типов.

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

5.    Рекурсивное программирование на Паскале.

6.    Перспективы развития языка Паскаль.

 

Вопросы для обсуждения

 

1.    Правда ли, что на Паскале можно запрограммировать решение любой задачи?

2.    Какой язык программирования самый лучший?

3.    Чем полезно и чем мешает требование описания данных в Паскале?

 

Задачи и упражнения

 

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

1.       Упорядочите числа a, b, c в порядке возрастания.

2.       Определите все пары двузначных чисел, обладающих свойством:

(20+25)^2 = = 2025.

3.       Вычислите в числовом массиве а1, а2, ..., аn суммы положительных и отрицательных элементов, подсчитайте разность и тех, и других чисел.

4.       Вычислите сумму произведений элементов двух десятимерных векторов

X и Y.

5.       Упорядочите массив х1, х2, ..., хn по неубыванию, используя метод сортировки вставками: пусть первые k элементов уже упорядочены по неубыванию; берется (k+1)-й элемент и размещается среди первых k элементов так, чтобы упорядоченными оказались уже (k+1) первых элементов.

6.       Решите систему n линейных уравнений методом Гаусса.

7.       Замените в заданном арифметическом выражении все вхождения sin на cos и sqrt на abs.

8.       Для заданного текста определите длину содержащейся в нем максимальной последовательности цифр 0, 1, 2, ..., 9.

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

10.   Найдите и выведите в порядке убывания все простые числа из диапазо- на [2..201].

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

12.   Заданы N точек на плоскости. Найдите точку, ближайшую к началу координат. Используйте тип "запись".

13.   Найдите площадь выпуклого четырехугольника со сторонами x, y, z, t и одной из диагоналей d.

14.   Разработайте программу, которая вычислит 500!=1*2*3*...*500. Поскольку такое большое число само по себе не может храниться в памяти компьютера, для хранения значащих цифр результата используйте массив целого типа.

15.   Имеется внешний файл записей lab.zap, содержащий сведения об учениках школы. Файл формируется приведенной далее программой. Составьте программу, в которой необходимо сделать следующее:

^•            упорядочить файл по признаку class в порядке возрастания;

^•            упорядочить файл по признаку god в порядке убывания;

^•            упорядочить файл в алфавитном порядке.

   program lab;       type shcool = record            fio : string[20]; class : 1 . . 11;            god : integer; pol : char;            end;       var x:array[1..100] of shcool; n,i:integer; f:file of school;    begin         write('введите кол-во учеников:'); readln(n);         assign(f,'lab.zap'); rewrite(f);         for i:=1 to n do with x[i] do         begin write('введи Ф.И.О.',i,'–ого ученика:'); readln(fio);               write('класс:'); readln(class);               write('год рождения:–'); readln(god);               write('пол(м/ж):–'); readln(pol);               write(f,x[i]);         end; close(f);    end.

16.   Напишите программы, одна из которых выполняет "сжатие"  текста (если подряд идет более 4 одинаковых символов, она должна заменить их на этот символ, разделитель # и число повторений символа) и обратное преобразование.

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

18.   Напишите программу, строящую графики заданных функций.

19.   Создайте демонстрационную модель идеального газа в замкнутом объеме.

 

Лабораторные работы

 

Лабораторная работа 1. Простые типы данных. Символьный тип. Перечисляемые и интервальные типы.

1.    Дано натуральное число:

^•            найти сумму цифр этого числа;

^•            верно ли, что число начинается и заканчивается одной и той же цифрой.

2.    Найти все трехзначные числа, такие что сумма цифр равна А, а само число делится на В (А и В вводятся с клавиатуры).

3.    Найти количество делителей натурального числа. Сколько из них четных?

Лабораторная работа 2.  Одномерные массивы.

1.    Заменить максимальный по модулю отрицательный элемент нулем.

2.    Заменить первые k элементов массива на противоположные по знаку.

3.    Вставить в массив число k после всех элементов, кратных своему номеру (k вводить с клавиатуры).

 

Лабораторная работа 3. Двухмерные массивы.

1.    Дан двухмерный массив размерностью 5*6, заполненный целыми числами с клавиатуры. Сформировать одномерный массив, каждый элемент которого равен произведению четных положительных элементов соответствующего столбца.

2.    Дан двухмерный массив размером n*m, заполненный случайным образом. Определить, есть ли в данном массиве строка, в которой ровно два отрицательных элемента.

3.    В двухмерном массиве удалить строку, содержащую наибольший элемент массива, и строку, содержащую наименьший элемент массива.

 

Лабораторная работа № 4. Строковый и множественный типы данных.

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

2.    Вывести общие русские буквы трех предложений.

3.    Решить ребус:

                      VOLVO

  F I AT

MOTOR

 

 

Лабораторная работа № 5. Комбинированный тип данных (записи).

1.    Дан текстовый файл, в котором хранятся данные об учениках класса: фамилия, имя, отчество, адрес (улица, дом, квартира) и домашний телефон (если есть). Вывести на экран фамилию, имя и адрес тех учеников, до кого нельзя дозвониться.

2.    Дан массив данных о работающих в фирме: фамилия, имя, отчество, адрес (улица, дом, квартира) и дата поступления на работу (месяц, год). Во второй массив записать только данные тех из них, кто на сегодняшний день проработал уже не менее 5 лет.

 

 

 

5.4. Методы и искусство программирования

 

 

 

Учебный материал

 

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

Современный подход к проектированию программ основан на декомпозиции задачи, которая в свою очередь основана на использовании абстракций. Целью при декомпозиции является создание модулей, которые представляют собой небольшие, относительно самостоятельные программы, взаимодействующие друг с другом по хорошо определенным и простым правилам. Если эта цель достигнута, то разработка отдельных модулей может осуществляться различными людьми независимо друг от друга, при этом объединенная программа будет функционировать правильно.

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

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

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

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

2.    Проектирование программы.

3.    Построение модели.

4.    Разработка алгоритма.

5.    Реализация алгоритма.

6.    Анализ алгоритма и его сложности.

7.    Тестирование программы.

8.    Документирование.

Кратко остановимся на каждом из этих этапов.

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

 выработать требования (свойства, качества и возможности), необходимые для решения проблемы или достижения цели (как правило, эта деятельность носит экспертный характер);

 разработать спецификации, включающие:

^•            цель программы;

^•            граничные условия;

^•            описание функций системы;

^•            спецификации входных и выходных данных;

^•            верификационные требования (установление тестовых случаев);

^•            тип и количество документов.

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

Чтобы приступить к решению задачи, необходимо точно ее сформулировать. В первую очередь, это означает определение исходных и выходных данных, т. е. ответы на вопросы: а) что дано; б) что нужно найти. Дальнейшая детализация постановки задачи представляет собой ответы на серию вопросов такого рода:

 как определить решение;

 каких данных не хватает и все ли они нужны;  какие сделаны допущения и т. п.

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

 имя/цель — дается имя модулю и предложение о функции модуля с формальными параметрами;

 неформальное описание — обзор действий модуля;

 ссылки — какие модули ссылаются на него и на какие модули ссылается данный модуль;

 вход/выход — формальные и фактические параметры, глобальные, локальные и связанные (общие для ряда модулей) переменные;

 примечания — полезные комментарии общего характера по модулю.

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

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

Методы проектирования архитектуры делятся на две группы: ориентированные на обработку и ориентированные на данные.

Методы, ориентированные на обработку, включают следующие общие идеи:

 Модульное программирование.

Основные концепции:

^•            каждый модуль реализует единственную независимую функцию;

^•            имеет единственную точку входа/выхода;

^•            размер модуля минимизируется;

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

^•            система в целом построена из модулей.

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

 Функциональная декомпозиция.

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

 Проектирование с использованием потока данных.

Использует поток данных как генеральную линию проектирования программы. Содержит элементы структурного проектирования сверху-вниз с пошаговой детализацией:

^•            экспертиза потоков данных и отображение графа потока данных;

^•            анализ входных, центральных и выходных преобразующих поток данных элементов;

^•            формирование иерархической структуры программы;

^•            детализация и оптимизация структуры программы.

 Технология структурного анализа проекта.

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

Методы проектирования, основанные на использовании структур данных, описаны далее.

 Методология Джексона.

Здесь структура данных — ключевой элемент в построении проекта. Структура программы определяется структурой данных, подлежащих обработке. Программа представляется как механизм, с помощью которого входные данные преобразуются в выходные. В методе предусматривается:

^•            разработка и изображение структуры входных и выходных данных;

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

 

^•            определение дискретных операций над структурами данных;

^•            построение алгоритмов обработки структур данных.

 Методология Уорнера.

Подобна предыдущей, но процедура проектирования более детализирована. Используются следующие виды представления проекта:

^•            диаграммы организации данных (описывают входные и выходные данные);

^•            диаграммы логического следования (логический поток этих данных);

^•            список инструкций (команды, используемые в проекте);

^•            псевдокод (описание проекта);

^•            определение входных данных системы;

^•            организация входных данных в иерархическую структуру;

^•            детальное определение формата элементов входного файла;

^•            то же самое для выходных данных;

^•            спецификация программы: чтение, ветвление, вычисление, выходы, вызовы подпрограмм;

^•            составление диаграммы (по типу блок-схем), указывающей логическую последовательность инструкций.

 Метод иерархических диаграмм.

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

Алгоритм проектирования по этому методу заключается в следующих  шагах:

^•            начать с наивысшего уровня абстракции, определив вход, выход, обработку;

^•            соединить каждый элемент входа и выхода с соответствующей обработкой;

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

^•            детализировать диаграммы, используя предыдущие шаги.

 Объектно-ориентированная методология проектирования.

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

Каждый объект содержит некоторую структуру данных с набором процедур, знающих, как работать с этими данными. По этой методологии создаются абстракции по заданной проблемной области:

^•            определение проблемы;

^•            развитие неформальной стратегии, удовлетворяющей требованиям к системе;

^•            формализация стратегии;

^•            создание объектов и их атрибутов;

^•            определение операций над объектами;

^•            установка интерфейсов;

^•            реализация операций.

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

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

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

                                                                  ma mg=  −Fсопр

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

Рис. 5.2. Схема построения модели при дедуктивном способе

Индуктивный способ (рис. 5.3) предполагает выдвижение гипотез, декомпозицию сложного объекта, анализ, затем синтез. Здесь широко используется подобие, аналогичное моделирование, умозаключение с целью формирования каких-либо закономерностей в виде предположений о поведении системы.

Рис. 5.3. Схема построения модели при индуктивном способе

Технология построения модели при индуктивном способе:

1.    Эмпирический этап:

^•            умозаключение; ^• интуиция;

^•            предположение;

^•            гипотеза.

2.    Постановка задачи для моделирования.

3.    Оценки, количественное и качественное описание.

4.    Построение модели.

Разработка алгоритма — самый сложный и трудоемкий процесс, но и самый интересный в творческом отношении. Выбор метода разработки зависит от постановки задачи, ее модели. На этом этапе необходимо провести анализ правильности алгоритма, что очень непросто и трудоемко. Наиболее распространенная процедура доказательства правильности алгоритма — это прогон его на множестве различных тестов. Однако это не гарантирует того, что не может существовать случая, в котором программа "не сработает". В общей методике доказательства правильности алгоритма предполагают, что алгоритм описан в виде последовательности шагов. Для каждого шага предлагается некое обоснование его правильности для всех подходящих входных (условиях до данного шага) и выходных данных (условиях после этого шага). Затем предлагается доказательство конечности алгоритма с окончательными исходными входными и выходными данными.

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

 кодирование;

 интеграцию;

 тестирование (сертификацию).

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

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

Перед началом эксплуатации программы необходим этап ее отладки и тестирования.

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

Тестирование программы как "черного ящика" (стратегия "черного ящика" определяет тестирование с анализом входных данных и результатов работы программы). Критерием исчерпывающего входного тестирования является использование всех возможных наборов входных данных.

Тестирование программы как "белого ящика" заключается в стратегии управления логикой программы, позволяет использовать ее внутреннюю структуру. Критерием выступает исчерпывающее тестирование всех маршрутов и управляющих структур программы.

Разумная и реальная стратегия тестирования — сочетание моделей "черного" и "белого" ящиков. Принципы тестирования:

 описание предполагаемых значений выходных данных или результатов должно быть необходимой частью тестового набора;

 тесты для неправильных и непредусмотренных входных данных следует разрабатывать так же тщательно, как для правильных и предусмотренных;

 необходимо проверять не только делает ли программа то, для чего она предназначена, но и не делает ли она то, что не должна делать;

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

 вероятность наличия необнаруженных ошибок в части программы пропорциональна числу ошибок, уже обнаруженных в этой части;  тестирование — процесс творческий.

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

Основные типы ошибок, встречающихся при программировании:

 обращения к переменным, значения которым не присвоены или не инициализированы;

 выход индексов за границы массивов;

 несоответствие типов или атрибутов переменных величин;

 явные или неявные проблемы адресации памяти;

 ошибочные передачи управления;  логические ошибки.

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

Особое внимание необходимо уделять тестам на граничных условиях. Граничные условия — это ситуации, возникающие непосредственно выше или ниже границ входных и выходных классов эквивалентности (т. е. вблизи границ эквивалентных разбиений). В частности, примерами классов эквивалентных тестов для алгоритма решения квадратного уравнения могут служить следующие классы: множество действительных, отличных от нуля, чисел a, b, c, таких, что b·b — 4·a·c < 0; множество чисел a = 0, b и c не равны нулю; b = 0, a и с не равны нулю и т. п.

Сам процесс тестирования может быть пошаговым и/или сплошным. В том и в другом случае используют стратегии нисходящего тестирования, — начиная с верхнего (головного) модуля и затем подключая последовательно другие модули (аппарат заглушек), и восходящего тестирования, начиная с тестирования отдельных модулей.

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

Есть золотое правило программистов — оформляй свои программы в том виде, в каком бы ты хотел видеть программы, написанные другими. К каждому конечному программному продукту необходимо документированное сопровождение в виде помощи (help), файлового текста (readme.txt).

Основные принципы разработки  и анализа алгоритмов

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

При дедуктивном подходе рассматривается частный случай общеизвестных алгоритмических моделей. Здесь при заданных предположениях известный алгоритм приспосабливается к условиям решаемой задачи. Например, многие вычислительные задачи линейной алгебры, в частности нелинейные уравнения, системы алгебраических уравнений и т. п., могут быть решены с использованием известных методов и алгоритмов, для которых существует множество специальных библиотек подпрограмм, модулей. В настоящее время получили распространение специализированные пакеты, позволяющие решать многие задачи (Mathcad, Mathlab, Autocad и т. п.).

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

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

Структурное программирование основано на использовании блок-схем, формируемых с помощью управляющих структурных элементов. Выделяют три базовых структурных элемента (управляющие структуры): композицию, альтернативу, итерацию.

Композиция — это линейная конструкция алгоритма, составленная из последовательно следующих друг за другом функциональных вершин, рис. 5.4. begin S1; S2; end

Альтернатива — это конструкция ветвления. Конструкция ветвления в алгоритмах может быть представлена в виде развилки (рис. 5.5, а), неполной развилки (рис. 5.5, б) и выбора (рис. 5.5, в).

                                                                                                       

Рис. 5.4. Структура "композиция"

if B then S1 else S2 if B then S1  а           б 

 

в

Рис. 5.5. Структура "альтернатива". 

Здесь В — условие (логическое выражение)

 

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

(рис. 5.6, а) и с постусловием (рис. 5.6, б).

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

while B do S1;                repeat S1 until B; а                б

Рис. 5.6. Структура "итерация"

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

                             

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

Метод разработки программы сверху-вниз предполагает процесс пошагового разбиения алгоритма (блок-схемы) на все более мелкие части до уровня элементарных конструкций, для которых можно составить конкретные команды. Идея структурного программирования сверху-вниз состоит в том, что если для некоторой функции f существует ее композиция через две другие функции _g и ^h, т. е. f ⁼ h g x( ( )), то проблема разработки алгоритма для f сводится к проблемам разработки алгоритмов для ^h и _g . В структурном программировании сверху-вниз на каждом шаге пытаются текущую функцию выразить как композицию двух (или более) других функций, которые представимы в виде рассмотренных ранее управляющих структур.

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

Пример 1. Технология разработки программы решения квадратного уравнения.

На рис. 5.7 проиллюстрирована пошаговая детализация процесса построения алгоритма. Заметим, что для начального шага разработки программы имеем  в качестве исходных данных коэффициенты a , ^b, c квадратного уравнения

2

ax + + =bx c 0, а на выходе — значения двух корней x1, x2.

Рис. 5.7. Пошаговая детализация построения алгоритма

Пример 2. Рассмотрим более сложный и поучительный пример структурного программирования, известный в литературе как "обход конем шахматного поля". В задаче необходимо ответить на вопрос, существует ли при заданном положении шахматного коня последовательность его ходов однократного обхода всех клеток шахматного поля.

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

Одной из эвристических стратегий алгоритма может быть следующая. Начиная с произвольного поля i , j (на рис. 5.8 i ⁼⁴, j ⁼4), пытаемся пойти на поле *1, если невозможно, то на поле *2; при неудаче — на поле *3 и т. д. по часовой стрелке (варианты возможных ходов приведены на рис. 5.8). Сделав очередной ход на пустую клетку, запишем в нее номер очередного хода и снова осуществляем процедуру поиска нового хода. В случае, когда из очередной клетки невозможно сделать ход, прерываем маршрут и выводим результат в виде таблицы, соответствующей шахматному полю,  в которой расставлены ходы коня. Очевидно, что такая стратегия лишь при удаче может дать полный обход шахматной доски конем.

Итак, исходные данные задачи — произвольные начальные координаты коня i , j от 1 до 8. Результат — возможный маршрут коня из заданного поля.

Удачным считается маршрут, содержащий все 64 хода, т. е. полный обход доски конем.

j

Рис. 5.8. Иллюстрация к задаче "обход конем шахматной доски"

Инициализация доски предполагает задание двумерного массива размером

8×8 с нулевыми элементами (рис. 5.9). В дальнейшем элемент a[i,j] принимает значения номера очередного хода. Распечатать результат — означает вывести таблицу a[1..8,1..8]. На рис. 5.10 показан один из результатов возможного маршрута коня из начального поля i=1, j=1.

Рис. 5.9а. Пошаговая детализация построения алгоритма к примеру 2

 

Рис. 5.9б. Пошаговая детализация построения алгоритма к примеру 2

Program Tur_Konja;     var a: array[1..8,1..8] of integer;    im, jm :array[1..8] of integer;    i, j, k, n, inac, jnac: integer;    inext, jnext: integer; begin  {-----инициализация шахматной доски-----}      for i:=1 to 8 do for j:=1 to 8 do a[i,j]:=0;      im[1]:=–2; jm[1]:=1; im[2]:=–1; jm[2]:=2; im[3]:=1; jm[3]:=2;      im[4]:=2; jm[4]:=1; im[5]:=2; jm[5]:=–1; im[6]:=1; jm[6]:=–2;      im[7]:=–1; jm[7]:=–2; im[8]:=–2; jm[8]:=–1;

     write('введи начальные координаты коня 0<i,j<9: ');      readln(inac,jnac);      a[inac,jnac]:=1; i:=inac; j:=jnac; n:=2; k:=1;      while k<=8 do           begin inext:=i+im[k]; jnext:=j+jm[k];                 if (inext<1) or (inext>8) or (jnext<1) or

                (jnext>8) or (a[inext,jnext]<>0)                 then k:=k+1                 else begin a[inext,jnext]:=n; n:=n+1; i:=inext;                      j:=jnext; k:=1;                      end;          end;

      {--------вывод результата прохода--------}      for i:=1 to 8 do      begin writeln; writeln; for j:=1 to 8 do write(a[i,j]:2,' ')      end;      writeln; write('кол-во шагов = ',n–1); readln; end.

 

                                                      1       2       3       4       5       6       7       8

1			34	3	36	19	22
		2	37	20	23	4	17
		33		35	18	21	10
		38		24	11	16	5
	32			39	26	9	12
			25		15	6	27
31			40	29	8	13	42
		30		14	41	28	7

1

2

3

4

5

6

7

8

 

Рис. 5.10. Возможный результат маршрута коня с поля (1,1)

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

Методы построения алгоритмов, 

ориентированные на структуры данных

Мы уже отмечали, что правильный выбор структуры данных — залог эффективности, понятности программы, ее устойчивости по отношению к ошибкам. Структуры данных, используемых в программе, также влияют на технологию разработки алгоритма. Удачный выбор структур данных заметно облегчает построение эффективного алгоритма. Методы программирования, в которых такое влияние доминирует, называют методами, ориентированными на структуры данных.

Рассмотрим некоторые классы задач, где полезны такие структуры, как связные списки, очереди, стеки, деревья.

Сортировка массивов данных, т. е. расположение их элементов в определенном порядке, являясь одной из важнейших задач при создании информационных систем, требует больших временных затрат и ресурсов памяти компьютера. Легко представить возникающие трудности, когда в массиве данных происходят удаления и внесения новых записей. Быстродействие известных алгоритмов сортировки массивов пропорционально квадрату числа их элементов (n²). Обычные подходы заставят нас осуществлять заново сортировку измененного массива с физическими перестановками записей согласно известным процедурам упорядочивания.

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

Линейный связанный список — это конечный набор пар, состоящих из информационной части (Info) и указующей части (Link):

 

Info	Link
1 Петров	3
2 Смирнов	4
3 Алексеев	1
...........
nКузнецов	2

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

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

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

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

Первым необходимым условием правильности расстановок скобок является совпадение количества левых и правых скобок. Такой контроль легко осуществить, введя счетчик top, который при просмотре выражения и обнаружении левой скобки (допустим, что имеем только круглые скобки '(' ) увеличивается на +1. Если на очередном месте встретилась правая скобка, то значение счетчика уменьшается на 1. Тогда правильность расстановки определяется по итоговому значению top.

рrogram skobka1; (*проверка скобок по количеству*)    var top, i, n: integer; slovo: string[100]; skob: string[100]; begin      write('введи арифметическое выражение: ');      readln(slovo); n:=length(slovo);      top:=0; skob:=''; i:=1;      while (i<=n) do      begin           if slovo[i]=')' then begin top:=top+1; skob:=skob+slovo[i]           end;           if slovo[i]=')' then begin              top:=top–1; skob:=skob+slovo[i]           end;           i:=i+1      end;

     writeln(skob);

     if top=0 then write('выражение правильное')      else write('выражение неправильное');      readln end.

 

Строковая переменная skob предназначена для визуализации всех имеющихся скобок в выражении.

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

program skobka2; (*проверка расстановок скобок*)    var top, i, n: integer;    slovo: string[100];

   store: array[1..100] of char; x: char; skob: string[100];    p: boolean; begin

     write('введи арифметическое выражение: ');      readln(slovo); n:=length(slovo);      top:=0; p:=true; skob:=''; i:=1;      while (i<=n)and(p) do

     begin if (slovo[i]='{') or (slovo[i]='[') or (slovo[i]='(')            then begin top:=top+1; store[top]:=slovo[i];                skob:=skob+slovo[i]            end;

           if slovo[i]='}' then begin x:=store[top];               if x<>'{' then p:=false

              else begin top:=top–1; skob:=skob+slovo[i]               end;            end;

           if slovo[i]=']' then begin x:=store[top];               if x<>'[' then p:=false

              else begin top:=top–1; skob:=skob+slovo[i]               end;            end;

           if slovo[i]=')' then begin x:=store[top];

              if x<>'(' then p:=false

              else begin top:=top–1; skob:=skob+slovo[i]               end;            end;            i:=i+1      end;

     writeln(skob); if top=0 then write('выражение правильное')      else write('выражение неправильное');      readln end.

 

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

Пусть задана скорость поступления клиентов в банк и известна скорость обслуживания. Вместо скорости поступления клиентов будем задавать вероятность р их появления в единицу времени. За скорость обслуживания примем число v, соответствующее времени обслуживания одного клиента. Для простоты примем в качестве массива данных о клиентах банка числовой массив со случайными числами из интервала 1..100. Для формирования очереди достаточно ввести две переменные, которые указывают на начало и конец списка данных.

Следующая программа демонстрирует процесс обслуживания очереди.

program bank;    uses crt;    type item = integer;

   var qq:array[1..100] of item; i, t, v, L, R: integer;    p, x: real; st: string[10]; begin (*начальное состояние очереди*)

     qq[1]:=random(100); qq[2]:=random(100); qq[3]:=random(100);      L:=1; R:=3; p:=0.6; v:=2; randomize; t:=0;      repeat

           t:=t+1; x:=random; if x<p then begin R:=R+1;            qq[R]:=random(100);            end;

           if (t mod v=0) then L:=L+1;

     until keypressed or (R>100);

     (*вывод состояния очереди на момент прерывания*)      for i:=L to R do writeln(qq[i]);      readln; end. 

Рекурсивные алгоритмы

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

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

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

procedure RETR; begin      инициализация начального хода      repeat выбор очередного хода             if подходит then его запись;             if решение не полное then RETR;             if неудача then стирание хода и возврат на предыдущий      until удача or нет хода end.

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

program tur;    var i, j, ii, jj, n, nn: integer; q: boolean;    dx, dy:array[1..8] of integer; h: array[1..8,1..8] of integer;

   (*рекурсивная процедура — попытка сделать ход*)    procedure try(i,x,y:integer; var q:boolean);       var k, u, v: integer; q1: boolean;    begin         k:=0;         repeat k:=k+1; q1:=false; u:=x+dx[k]; v:=y+dy[k];            if ((1<=u)and(u<=n)and(1<=v)and(v<=n))and(h[u,v]=0)            then begin h[u,v]:=i;

                (*для отладки и наблюдения процесса поиска с возвратом*)                 for ii:=1 to n do                 begin for jj:= 1 to n do                       write(h[ii,jj]:5); writeln;                 end;                 readln;                 if i<nn then begin try(i+1,u,v,q1);                    if not(q1) then h[u,v]:=0                    else q1:=true;                 end                 else q1:=true            end;         until (q1) or (k=8);         q:=q1;    end; (*конец процедуры*) begin      dx[1]:=2; dx[2]:=1; dx[3]:=–1; dx[4]:=–2; dx[5]:=–2;      dx[6]:=–1; dx[7]:=1; dx[8]:=2; dy[1]:=1; dy[2]:=2;      dy[3]:=2; dy[4]:=1; dy[5]:=–1; dy[6]:=–2;      dy[7]:=–2; dy[8]:=–1;      write( 'введи n: '); readln(n);      for i:=1 to n do for j:=1 to n do h[i,j]:=0;         write( 'введи i,j : '); readln(i,j); nn:=n*n;         h[i,j]:=1; try(2,i,j,q);         if q then begin              for i:=1 to n do begin                  for j:= 1 to n do write(h[i,j]:5);                  writeln;              end;         end

     else writeln( 'нет маршрута');      readln end.

 

Для n=5 и n=6 алгоритм быстро находит искомые туры коня. Для n=8 время решения может возрасти в несколько десятков раз.

Алгоритмы поиска и сортировки

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

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

Существуют различные алгоритмы сортировки данных. И понятно, что не существует универсального, наилучшего во всех отношениях алгоритма сортировки. Эффективность алгоритма зависит от множества факторов, среди которых можно выделить основные:

 числа сортируемых элементов;

 степени начальной отсортированности (диапазона и распределения значений сортируемых элементов);

 необходимости исключения или добавления элементов;

 доступа к сортируемым элементам (прямого или последовательного).

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

В этой связи выделяют сортировку двух классов объектов: массивов (внутренняя сортировка) и файлов (внешняя сортировка).

Процедура сортировки предполагает, что при наличии некоторой упорядочивающей функции F расположение элементов исходного множества меняется таким образом, что:

F

a a1 2, ,..., aN →a ak1, k2,..., akN F a( k1) ≤F a( k2) ≤ ≤... F a( kN ),

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

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

Поиск. Для определенности примем, что множество, в котором осуществляется поиск, задано как массив: var a:array[0..N] of item;

где item — заданный структурированный тип данных, обладающий хотя бы одним полем (ключом), по которому необходимо проводить поиск.

Результатом поиска, как правило, служит элемент массива, равный эталону, или отсутствие такового.

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

i:=0; while (i<=N)and(a[i]<>X) do i:=i+1 end.

Часто бывает целесообразнее осуществлять поиск с барьером, вводя дополнительно граничный элемент массива a[N+1]:

a[N+1]:=X; i:=0; while a[i]<>X do i:=i+1 end.

Равенство i=N+1 означает, что совпадений не было, т. е. что эталонный элемент отсутствует.

Приведем пример программы поиска эталона х в массиве a[0..n].

 

program poisk1; (*линейный поиск*)    const N=8;    type item= integer;    var a : array[0..n] of item; i :integer; x : item; begin

     (*задание искомого массива*)      for i:=0 to N do      begin write('введи элемент a[ ',i, ']= '); readln(a[i]);      end;      writeln; write('введи эталон x= '); readln(x);

     (* линейный поиск*)      i:=0; while (i<=N)and(a[i]<>X) do begin i:=i+1      end;

     (*вывод результата*)      if i<=N then write( 'найден элемент на ',i, ' месте ')      else write( 'такого элемента в массиве нет ');      readln end.

 

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

L:=0; R:=N; while L<R do begin      m:=(L+R) div 2;      if a[m]<X then L:=m+1 else R:=m; end;

Например, пусть эталонный ключ х=13, а в массиве имеются следующие элементы: a[0]=1; a[1]=3; a[2]=4; a[3]=7; a[4]=8; a[5]=9; a[6]=13; a[7]=20; a[8]=23.

Бинарный процесс поиска показан далее:

1 3 4 7 8 9 13 20 23 — элементы массива

0 1 2 3 4 5 6 7 8 — порядковые номера элементов

L			m		R
L			m		R
			a[m]=x			⇒ поиск закончен, и m=6

Программа поиска представлена далее.

program poisk2; (*поиск делением пополам*)    const N=8;    type item= integer;    var a: array[0..n] of item; i, L, R, m:integer; x: item; f: boolean; begin

     (*задание искомого массива*)      for i:=0 to N do      begin write( 'введи элемент a[',i, ']= '); readln(a[i]);      end;      writeln; write( 'введи эталон x= '); readln(x);

     (*бинарный поиск*)      L:=0; R:=N; f:=false;      repeat m:=(L+R) div 2; if a[m]=X then f:=true;             if a[m]<X then L:=m+1             else R:=m;             writeln(m,L,R);      until (L>=R)or(f);      (*вывод результата*)      if f then write('найден элемент на ',m, ' месте')      else write('такого элемента в массиве нет ');      readln end. 

Сортировка массивов. Как и в случае поиска, определим массив данных: var a: array [0..N] of item

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

Cортировка с помощью включения. Кто играл в карты, процедуру сортировки включениями осуществлял многократно. Как правило, после раздачи карт игрок, держа карты веером в руке, переставляет карты с места на место, стремясь их расположить по мастям и рангам, например сначала все тузы, затем короли, дамы и т. д. Элементы (карты) мысленно делятся на уже "готовую последовательность" и неправильно расположенную последовательность. Теперь на каждом шаге, начиная с i=2, из неправильно расположенной последовательности извлекается очередной элемент и перекладывается в готовую последовательность на нужное место.

for i:=2 to N do begin      x:=a[i];

     <включение x на соответствующее место       готовой последовательности a[1],...,a[i]> end

Поиск подходящего места можно осуществить одним из методов поиска в массиве, описанном ранее. Затем х либо вставляется на свободное место, либо сдвигает вправо на один индекс всю левую сторону. Схематично представим алгоритм для конкретного примера:

 

Исходные элементы	23	34	12	13	9
i=2	23	34	12	13	9
i=3	12	23	34	13	9
i=4	12	13	23	34	9
i=5	9	12	13	23	34

 

 

В алгоритме поиск подходящего места осуществляется как бы просеиванием х при движении по последовательности и сравнении с очередным a[j]. Затем х либо вставляется на свободное место, либо a[j] сдвигается вправо и процесс как бы "уходит" влево.

program sortirovka_1;

(*сортировка включением по линейному поиску*)    const N=5;    type item= integer;

   var a: array[1..n] of item; i, j: integer; x: item; begin (*задание искомого массива*)

     for i:=1 to N do begin write('введи элемент a[',i,']=');          readln(a[i])      end;

     for i:=1 to N do begin write(a[i], ' ' );      end;      writeln;

     (*алгоритм сортировки включением*)      for i:=2 to n do      begin

          x:=a[i]; j:=i; a[0]:=x; (*барьер*)           while x<a[j–1] do

          begin                a[j]:=a[j–1]; j:=j–1;           end;           a[j]:=x;

          {for k:=1 to n do write(a[k], ' ') end; writeln;}      end;

     (*вывод отсортированного массива*)      for i:=1 to N do      begin           write(a[i], ' ');      end;      readln; end.

 

В рассмотренном примере программы для анализа процедуры пошаговой сортировки можно рекомендовать использовать трассировку каждого прохода по массиву с целью визуализации его текущего состояния. В тексте программы в блоке непосредственного алгоритма сортировки в фигурных скобках находится строка, которая при удалении скобок выполнит требуемое (параметр k необходимо описать в разделе переменных — var k:integer;). Во всех последующих программах сортировки легко осуществить подобную процедуру.

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

program sortirovka_2;

(*сортировка двоичным включением*)    const N=5;    type item= integer;    var a: array[1..n] of item; i, j, m, L, R: integer; x: item; begin

     (*задание элементов массива*)      for i:=1 to N do

     begin write('введи элемент a[',i,']= '); readln(a[i]);      end;      for i:=1 to N do      begin write(a[i], ' ');      end;

     writeln;

     (*алгоритм сортировки двоичным включением*)      for i:=2 to n do      begin

          x:=a[i]; L:=1; R:=i;           while L<R do           begin

               m:=(L+R) div 2; if a[m]<=x then L:=m+1 else R:=m;           end;

          for j:=i downto R+1 do a[j]:=a[j–1];           a[R]:=x;      end;

     (* вывод отсортированного массива*)      for i:=1 to N do      begin write(a[i], ' ');      end;      readln; end.

 

Один из вариантов улучшенной сортировки включением был предложен Д. Шеллом. Его метод предполагает сначала отдельную группировку и сортировку элементов, отстоящих друг от друга на некотором расстоянии,  например 4 (четвертная сортировка), после первого прохода — перегруппировку элементов таким образом, чтобы каждый элемент группы отстоял от другого на 2 номера, после двойной сортировки на третьем проходе — одинарную (обычную) сортировку.

 

Исходные элементы	44 55 12 42 94 18 6                                                               67
Четвертная сортировка	44 18 6                                                               42 94 55 12 67
Двойная сортировка	6                                                               18 12 42 44 55 94 67
Одинарная сортировка	6                                                               12 18 42 44 55 67 94

 

Каждая из сортировок основывается на алгоритме прямого включения и соответственно должна программироваться аналогично. Если для условия окончания поиска использовать барьер, а их необходимо ставить для каждой из сортировок, то необходимо расширить границы массива на несколько компонентов (барьеров) влево, т. е. использовать массив a[–r..n], где r — количество сортировок.

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

                                  1           2           3          4           5           

12 15 17 11 13 i=2, min=11

11 15 17 12 13 i=3, min=12

11 12 17 15 13 i=4, min=13

11 12 13 15 17 i=5, min=15

 

 

program sortirovka_3;

(*улучшенная сортировка включением — сортировка Шелла*)    const N=8; t=4;    type item= integer;    var a: array[–9..n] of item; i, j, k, s :integer; x: item;    m: 1..t; h :array [1..t] of integer; begin

     (*задание искомого массива*)      for i:=1 to N do

     begin write('введи элемент a[',i,']='); readln(a[i])      end;

     for i:=1 to N do begin write(a[i], ' ');      end;      writeln;

     (*алгоритм Шелла*)

     h[1]:=9; h[2]:=5; h[3]:=3; h[4]:=1;      for m:=1 to t do

     begin k:=h[m]; s:=–k; (*барьеры для каждого шага*)            for i:=k+1 to n do

           begin x:=a[i]; j:=i–k; if s=0 then s:=–k; s:=s+1;                  a[s]:=x; while x<a[j] do begin a[j+k]:=a[j]; j:=j–k;                  end;                  a[j+k]:=x            end;      end;

     (*вывод отсортированного массива*)      for i:=1 to N do begin write(a[i], ' ');      end;      readln; end.

program sortirovka_4; (*сортировка прямым выбором*)    const N=5;    type item= integer;

   var a: array[1..n] of item; i, j, k: integer; x: item; begin

     (*задание искомого массива*)      for i:=1 to N do

     begin write('введи элемент a[', i, ']='); readln(a[i]);      end;

     for i:=1 to N do begin write(a[i],' ');      end;      writeln;

     (*алгоритм прямого выбора*)      for i:=1 to n–1 do

     begin k:=i; x:=a[i]; (*поиск наименьшего элемента*)            for j:=i+1 to n do (*и его индекса из a[i]...a[n]*)                if a[j]<x then begin k:=j; x:=a[k]                end;

               a[k]:=a[i]; a[i]:=x;      end;

     (*вывод отсортированного массива*)      for i:=1 to N do begin write(a[i], ' ');      end;      readln; end.

 

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

program sortirovka_6;

(*сортировка прямым обменом — пузырьковая сортировка*)    const N=5;

   type item= integer; var a: array[1..n] of item; i, j: integer;    x: item;

begin (*задание искомого массива*)

     for i:=1 to N do begin write('введи элемент a[',i,']= ');          readln(a[i]);      end;

     for i:=1 to N do begin write(a[i], ' ');      end;      writeln;

     (*алгоритм пузырьковой сортировки*)      for i:=2 to n do for j:=n downto i do begin

         if a[j–1]>a[j] then begin x:=a[j–1];a[j–1]:=a[j]; a[j]:=x;           end;      end;

     (*вывод отсортированного массива*)      for i:=1 to N do begin write(a[i], ' ');      end;      readln; end.

 

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

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

program sortirovka_7;

(*сортировка прямым обменом — шейкерная сортировка*)    const N=5;    type item= integer;

   var a: array[1..n] of item; i, j, k, L, R: integer; x: item; begin (*задание искомого массива*)

     for i:=1 to N do begin write('введи элемент a[',i,']=');          readln(a[i]);      end;      for i:=1 to N do begin write(a[i],' ');      end;      writeln;

     (*алгоритм шейкерной сортировки*)      L:=2; R:=n; k:=n;      repeat            for j:=R downto L do begin                if a[j–1]>a[j] then begin x:=a[j–1];a[j–1]:=a[j];                   a[j]:=x; k:=j                end;            end;            L:=k+1;            for j:=L to R do begin                if a[j–1]>a[j] then begin x:=a[j–1];                a[j–1]:=a[j]; a[j]:=x; k:=j                end;            end;            R:=k–1;      until L>R;

     (*вывод отсортированного массива*)      for i:=1 to N do      begin write(a[i],' ');      end; readln; end.

 

Пузырьковая сортировка является не самой эффективной, особенно для последовательностей, у которых "всплывающие" элементы находятся в крайней правой стороне. В улучшенной (быстрой) пузырьковой сортировке предлагается производить перестановки на большие расстояния, причем двигаться с двух сторон. Идея алгоритма заключается в сравнении элементов, из которых один берется слева (i=1), другой — справа (j=n). Если a[i]<=a[j], то устанавливают j=j–1 и проводят следующее сравнение. Далее уменьшают j до тех пор, пока a[i]>a[j]. В противном случае меняем их местами и устанавливаем i=i+1. Увеличение i продолжаем до тех пор, пока не получим a[i]>a[j]. После следующего обмена опять уменьшаем j. Чередуя уменьшение j и увеличение i, продолжаем этот процесс с обоих концов до тех пор, пока не станет i=j. После этого этапа возникает ситуация, когда первый элемент занимает ему предназначенное место, слева от него младшие элементы, а справа — старшие.

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

program sortirovka_8;

(*улучшенная сортировка разделением — быстрая сортировка с рекурсией*)    const N=8;    type item= integer;    var a: array[1..n] of item; i: integer;    procedure sort(L,R: integer);       var i, j: integer; x, y: item;    begin         i:=L; j:=R; x:=a[(L+R) div 2];         repeat               while a[i]<x do i:=i+1; while x<a[j] do j:=j–1;                    if i<=j then begin y:=a[i]; a[i]:=a[j];                       a[j]:=y; i:=i+1; j:=j–1;                    end;         until i>j;         if L<j then SORT(L,j); if i<R then SORT(i,R);    end; begin

     (*задание искомого массива*)      for i:=1 to N do begin write('введи элемент a[',i,']=');          readln(a[i]);      end;      for i:=1 to N do begin write(a[i],' ');      end;      writeln;

     (*алгоритм быстрой сортировки*)

     SORT(1,n); (*рекурсивная процедура*)      (*вывод отсортированного массива*)      for i:=1 to N do begin write(a[i],' ');      end;      readln; end.

 

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

 

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

Предположим, что нам необходимо упорядочить содержимое файла с последовательным доступом по какому-либо ключу. Для простоты изучения и анализа сортировки условимся, что файл формируем мы сами, используя, как и в предыдущем случае, некоторый массив данных. Его же будем применять и для просмотра содержимого файла после сортировки. В предлагаемом далее алгоритме необходимо сформировать вспомогательный файл, который позволит осуществить следующую процедуру сортировки. Сначала выбираем из исходного файла первый элемент в качестве ведущего, затем извлекаем второй и сравниваем с ведущим. Если он оказался меньше, чем ведущий, то помещаем его во вспомогательный файл, в противном случае во вспомогательный файл помещается ведущий элемент, а его замещает второй элемент исходного файла. Первый проход заканчивается, когда аналогичная процедура коснется всех последовательных элементов исходного файла. Ведущий элемент заносится во вспомогательный файл последним. Теперь необходимо поменять местами исходный и вспомогательный файлы. После n/2 проходов в исходном файле данные будут размещены в упорядоченном виде.

program sortirovka_faila_1;

{сортировка последовательного файла}    const N=8;    type item= integer;    var a: array[1..n] of item; i,k: integer; x,y: item;    f1,f2: text; {file of item}; begin

     {задание искомого массива}      for i:=1 to N do begin write('введи элемент a[ ',i,']=');          readln(a[i]);      end;      writeln; assign(f1, 'dat1.dat'); rewrite(f1);      assign(f2, 'dat2.dat'); rewrite(f2);      {формирование последовательного файла}      for i:=1 to N do begin writeln(f1,a[i]);      end;

     {алгоритм сортировки с использованием вспомогательного файла}      for k:=1 to (n div 2) do      begin {извлечение из исходного файла             и запись во вспомогательный}           reset(f1); readln(f1,x);

          for i:=2 to n do begin readln(f1,y);               if x>y then writeln(f2,y)               else begin writeln(f2,x); x:=y;               end;           end;           writeln(f2,x);

           {извлечение из вспомогательного файла             и запись в исходный}

          rewrite(f1); reset(f2); readln(f2,x);           for i:=2 to n do begin readln(f2,y);               if x>y then writeln(f1,y)               else begin writeln(f1,x); x:=y;               end;           end;

          writeln(f1,x); rewrite(f2);      end;

     {вывод результата}      reset(f1);

     for i:=1 to N do readln(f1,a[i]);      for i:=1 to N do begin write(a[i], ' ');      end;

     close(f1); close(f2); readln; end.

 

По сути, можно в программе обойтись без массива а[1..n]. В качестве упражнения попытайтесь создать программу, в которой не используются массивы.

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

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

Если объединить эти два массива в один, разумеется, двойного размера, то программа упрощается. Пусть индексы i и j фиксируют два входных элемента с концов исходного массива, k и L — два выходных, соответствующих концам вспомогательного массива. Направлением пересылки (сменой ролей массивов) удобно управлять с помощью булевой переменной, которая меняет свое значение после каждого прохода, когда элементы a₁,..., a_n движутся на

место a_n+1,..., a_2n и наоборот. Необходимо еще учесть изменяющийся на каждом проходе размер объединяемых упорядоченных групп элементов. Перед каждым последующим проходом размер удваивается. Если считать, что количество элементов в исходной последовательности не является степенью двойки (для процедуры разделения это существенно), то необходимо придумать стратегию разбиения на группы, размеры которых q и r могут не совпадать с ведущим размером очередного прохода. В окончательном виде алгоритм сортировки слиянием представлен далее.

program sortirovka_faila_2;

{сортировка последовательного файла слиянием}    const N=8;    type item= integer; var a: array[1..2*n] of item;    i, j, k, L, t, h, m, p, q, r: integer; f: boolean; begin

     {задание искомого массива}      for i:=1 to N do begin write('введи элемент a[ ',i,']=');          readln(a[i]);      end;      writeln;

     {сортировка слиянием}      f:=true; p:=1;      repeat            h:=1; m:=n;            if f then begin i:=1; j:=n;k:=n+1; L:=2*n            end

           else begin k:=1; L:=n;i:=n+1; j:=2*n            end;            repeat

                 if m>=p then q:=p else q:=m; m:=m–q;                  if m>=p then r:=p else r:=m; m:=m–r;                  while (q<>0) and (r<>0) do                  begin                       if a[i]<a[j] then                       begin a[k]:=a[i]; k:=k+h; i:=i+1;q:=q–1                       end                       else                       begin a[k]:=a[j]; k:=k+h; j:=j–1; r:=r–1                       end;                  end;                  while r>0 do                  begin a[k]:=a[j]; k:=k+h; j:=j–1; r:=r–1;                  end;                  while q>0 do begin                       a[k]:=a[i]; k:=k+h; i:=i+1; q:=q–1;                  end;                  h:=–h; t:=k;k:=L; L:=t;            until m=0;            f:=not(f); p:=2*p;      until p>=n;      if not(f) then for i:=1 to n do a[i]:=a[i+n];

     {вывод результата}      for i:=1 to N do begin write(a[i], ' ');      end;      readln; end.

 

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

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

 

Контрольные вопросы

 

1.        Каковы основные этапы проектирования и разработки программы?

2.        Что означает хорошо сформулированная постановка задачи?

3.        Назовите методологии проектирования и разработки программ.

4.        Как выбрать модель задачи?

5.        Что такое тестирование программы?

6.        Постройте группу тестов для алгоритма решения системы линейных уравнений.

7.        Как в общем случае формулируется задача поиска, сортировки?

8.        Почему внутренняя и внешняя сортировки реализуются разными мето- дами?

9.        В чем состоят принципы линейного поиска, поиска делением пополам?

10.    Какие вы знаете методы внутренней сортировки?

11.    Как соотносятся эффективности различных методов сортировки мас- сивов?

12.    В чем состоит принцип метода слияния упорядоченных файлов?

13.    Разработайте программу упорядочивания списка группы студентов:

•      методом прямого включения;

•      методом выбора;

•      методом обмена.

 

 

Темы для рефератов  и докладов

1.    Алгоритмы поиска и сортировки.

2.    Управление программными проектами.

3.    Проектирование и разработка больших программных проектов.

4.    Дисциплина программирования.

5.    Искусство и дисциплина программирования.

6.    Доказательство правильности программ.

 

Вопросы для обсуждения

 

1.    Каковы наиболее сложные программы, созданные человеком?

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

 

 

Задачи и упражнения

 

1.       Разработайте алгоритм и программу расстановки ферзей на шахматном поле таким образом, чтобы ни один из них не бил другого.

2.       Разработайте программу игры "Ханойские башни".

3.       Предложите другие модификации алгоритма полного обхода шахматной доски конем.

4.       Какое наименьшее число ферзей можно расставить на доске так, чтобы они держали под боем все ее свободные поля? Модификация задачи. Найти расстановку ферзей, которая одновременно решает задачу для досок 9*9, 10*10 и 11*11.

5.       Расставить на доске N * N ( N≤12 ) N ферзей так, чтобы наибольшее число ее полей оказалось вне боя ферзей.

6.       Расставить на доске как можно больше ферзей так, чтобы при снятии любого из них появлялось ровно одно не атакованное поле.

7.       За какое наименьшее число ходов ферзь может обойти все поля доски 8*8?

8.       Расставить на доске 8*8 максимальное число ферзей так, чтобы каждый из них нападал ровно на _p ( _p≤2 ) ферзей. (Ответ. При _p⁼1 десять, а при p=2 четырнадцать.)

9.       Задача о коне Аттилы ("Трава не растет там, где ступил мой конь!"). На шахматной доске стоят белый конь и черный король. Некоторые поля доски считаются "горящими". Конь должен дойти до неприятельского короля, повергнуть его и вернуться на исходное место. При этом ему запрещено становиться как на горящие поля, так и на поля, которые уже пройдены.

10.   Магараджа — это фигура, которая объединяет ходы коня и ферзя. Для доски 10*10 найти способ расстановки 10 мирных магараджей.

11.   Пронумеровать позиции в матрице (таблице) размером 5*5 следующим образом. Номер ⁱ (1≤ ≤i 25 ) соответствует позиции с координатами (x,y), вычисляемыми по одному из следующих правил:

•      (z,w)=(x^±3,y); • (z,w)=(x,y^±3);

•      (z,w)=(x^±2,y^±2).

Требуется:

•      написать программу, которая последовательно нумерует позиции матрицы 5*5 при заданных координатах позиции, в которой поставлен номер 1 (результаты должны быть представлены в виде заполненной матрицы);

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

 

 

Лабораторные работы

 

1.    Используя принцип проектирования сверху-вниз, постройте блок-схему и программу для решения системы линейных алгебраических уравнений методом Гаусса.

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

3.    Постройте программу упорядочивания списка фамилий учащихся вашего класса с использованием линейного списка.

4.    С помощью стека организуйте алгоритм, который определяет, является ли заданное слово палиндромом ("перевертышем").

5.    Придумайте и решите задачу на использование очереди.

 

 

 

 

5.5. Введение  в язык программирования Си

 

Учебный материал

 

Общая характеристика языка  и пример программы на Си

Язык программирования Си — это универсальный язык с богатым набором операторов и компактным способом записи выражений. Благодаря гибкости, выразительности и компактности своих конструкций Си завоевал наибольшую популярность в среде профессиональных программистов и широко используется при разработке системных и прикладных программ.

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

Си был создан Деннисом Ритчи как инструмент для разработки операционной системы UNIX и реализован в рамках этой операционной системы. Название языка имеет случайное происхождение: "С" — третья буква английского алфавита. Это наименование говорит о чувстве юмора у создателей языка — его предшественником был язык B ("В" — вторая буква английского алфавита).

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

Язык Си — компилирующего типа. Текст программы на Си, подготовленный с помощью текстового редактора, для получения объектного модуля обрабатывается компилятором, причем компиляция выполняется в два прохода. При первом проходе (претрансляции) обрабатываются строки-директивы, начинающиеся со знака #, при втором — транслируется текст программы и создается объектный (машинный) код. Для получения загрузочного (исполняемого) модуля теперь необходимо отредактировать внешние связи объектного модуля — подсоединить к нему соответствующие библиотечные модули.

Рассмотрим простую программу на языке Си. Такой пример позволит нам выявить некоторые основные черты любой программы, написанной на языке Си.

#include <stdio.h>

main()  /* Простая программа */

{      int num;      num = 1;

     printf ("Это моя %d-я программа на языке Си.\n",num);

}

 

Результат выполнения программы:

Это моя 1-я программа на языке Си.

Поясним строки этой программы:

#include  <stdio.h>

Подключение файла stdio.h, который является частью пакета, имеющегося в любом компиляторе языка Си и описывающего функции ввода/вывода (например, средства взаимодействия программы с терминалом). В качестве имени файла используется аббревиатура английских слов: STandard Input/Output header — стандартный заголовок ввода/вывода. Данная строка не является оператором языка Си. Символ # указывает, что она должна быть обработана "препроцессором" компилятора. Препроцессор осуществляет некоторую предварительную обработку текста программы перед началом компиляции.

main()

Имя функции (в переводе с английского main — "главная"). Любая программа, написанная на языке Си, состоит из одной или более "функций", являющихся модулями, из которых она собирается. Данная программа состоит из одной функции main. Круглые скобки указывают именно на то, что main() — имя функции. Программа, написанная на языке Си, всегда начинает выполняться с функции, называемой main(). У программиста есть возможность выбирать имена для всех используемых им функций, кроме main. В круглых скобках в общем случае содержится информация (параметры), передаваемая этой функции. В нашем примере параметры не требуются и, следовательно, в скобках ничего не содержится.

/* Простая программа */

Комментарий. Использование комментариев облегчает процесс понимания программы любым программистом. Большим удобством при написании комментариев является возможность располагать их в той же строке, что и операции, которые они объясняют. Длинный комментарий может помещаться в отдельной строке или даже занимать несколько строк. Все, что находится между символом, указывающим начало комментария /*, и символом, указывающим его конец */, игнорируется компилятором, поскольку он не в состоянии интерпретировать язык, отличный от Си.

{ }

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

int num;

Оператор описания. С помощью такого оператора мы объявляем, что будем использовать в программе переменную num, которая принимает целые (int) значения.

Точка с запятой в конце строки является частью оператора языка Си, а не разделителем операторов, как в Паскале.

Слово int служит "ключевым словом", определяющим один из основных типов данных языка Си. Ключевыми словами называются специальные зарезервированные слова, используемые для построения фраз языка.

 

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

num=1;

Оператор присваивания. Служит для присваивания переменной num значения 1.

printf("Это моя %d-я программа на языке Си.\n",num);

Вызов функции printf() форматного вывода на печать. Этот оператор выводит на печать значение переменной num в формате, содержащемся в строке в кавычках (в данном случае печатается приведенная в кавычках фраза). Символы %d указывают компилятору, где в выводимой строке и в какой форме необходимо вставить значение переменной num. Символ % сигнализирует программе, что, начиная с этой позиции, необходимо вывести значение переменной, а d указывает, что число надо печатать в десятичном формате.

Символы \n не появляются на экране. Эти символы служат директивой для начала новой строки на устройстве вывода. Комбинация символов \n на самом деле представляет собой один символ, называемый "новая строка". Для этого символа (\n) не существует соответствующей клавиши на клавиатуре. Символ "новая строка" служит примером управляющей последовательности, которую невозможно ввести с клавиатуры.

В общем случае обращение к этой функции имеет вид: printf(<формат>,<выражение1>,<выражение2>,...,<выражениеN>);

где <выражение1>, <выражение2>, ..., <выражениеN> — произвольные выражения, результаты которых надо вывести.

Управляющая строка "формат" содержит объекты двух типов: обычные символы, которые просто копируются в выходной поток (печатаются), и спецификации преобразования значений из внутреннего машинного представления в текстовое для вывода на печатающем устройстве.

Каждая спецификация преобразования начинается с символа % и заканчивается символом преобразования. Между % и символом преобразования могут (не обязательно) находиться:

 знак минус, указывающий, что преобразуемый параметр должен быть выровнен влево в своем поле;

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

 строка цифр с начальным нулем — лишние позиции поля заполняются нулями, а не пробелами;

 точка, отделяющая размер поля от последующей строки цифр (только для преобразования строк %s) — строка цифр указывает максимальное число символов, выводимых в одной строке.

Символы преобразования:

 d — десятичное число со знаком;

 u — десятичное число без знака;

 o — восьмеричное число без знака (и без ведущего 0);

 x — шестнадцатеричное число без знака (и без ведущего 0);

 s — символьная строка;

 c — одиночный символ;

 f — действительное число в представлении с фиксированной точкой;

 e — действительное число в экспоненциальном представлении;

 g — наиболее короткое представление действительного числа;  и др.

Функцией ввода, аналогичной функции вывода printf(), является scanf() — стандартная функция форматного ввода. Обращение к этой функции имеет вид scanf(<формат>,<&имя1>,<&имя2>,...,<&имяN>);

где <имя1>, <имя2>, ..., <имяN> — имена переменных, значения которых надо ввести. Наличие символа & перед каждым именем обязательно (кроме переменных строкового типа), его смысл будет пояснен далее.

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

В качестве спецификаций в формате можно использовать те же символы, что и в функции printf(). Спецификации формата должны соответствовать количеству и типу вводимых переменных. В управляющей строке функции scanf нет промежуточных управляющих символов между % и символом преобразования, за исключением *. Если присутствует символ *, входное поле просто пропускается и никакого присваивания не производится. Обычные символы (кроме %) сопоставляются с очередными (отличными от символов промежутков) символами входного потока, и, в случае отличия, дальнейший ввод игнорируется.

#include <stdio.h> main() {      int data,month,year; char name[15],town[15];      printf("Как вас зовут? "); scanf("%s",name);      printf("Укажите дату, месяц и год вашего рождения.\nДата:");      scanf("%d",&data);      printf("Месяц(числом):"); scanf("%d",&month);      printf("Год:"); scanf("%d",&year);      printf("А в каком городе? "); scanf("%s",town);      printf("Вот мы и познакомились...\n");      printf("Вас зовут %s ",name);      printf("Вы родились в городе %s (%d.%d.%d)",town,data, month,year); }

 

Результат работы программы:

Как вас зовут? Иван

Укажите дату, месяц и год вашего рождения.

Дата : 23

Месяц (номером) : 02

Год : 1054

А в каком городе? Новгород Вот мы и познакомились...

Вас зовут Иван

Вы родились в городе Новгород

(23.02.1054)

Элементы Си: алфавит, идентификаторы, литералы, служебные слова

Перечислим основные символы языка Си, образующие его алфавит:

 строчные латинские буквы:

a b c d e f g h i j k l m n o p q r s t u v w x y z  прописные латинские буквы:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

 арабские цифры:

0 1 2 3 4 5 6 7 8 9  специальные символы:

            * звездочка                                                         ( круглая скобка левая

            + плюс                                                                   ) круглая скобка правая

            – минус                                                                < меньше

            / дробная черта                                                > больше

           % процент                                                            \ обратная дробная черта

            ! восклицательный знак                               ^ стрелка вверх

            = знак равенства                                              [ квадратная скобка левая

            ? вопросительный знак                                 ] квадратная скобка правая

            : двоеточие                                                        # номер

             ; точка с запятой                                              { фигурная скобка левая

           & коммерческое "и" (амперсанд)             } фигурная скобка правая

             ' апостроф                                                           | вертикальная черта

             . точка                                                                   ~ черта сверху (тильда)

            , запятая                                                               " кавычки

           _ подчеркивание                                               пробел

 

 управляющие символы:

\t горизонтальная табуляция 

\n перевод строки и возврат каретки 

\r возврат каретки 

\f перевод страницы 

\b возврат на шаг (на один символ)

 

Множество основных символов расширено буквами русского алфавита (строчными и прописными). Они могут быть использованы только в комментариях, символьных константах и строках.

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

Идентификатор — это последовательность латинских букв, цифр и символа "_", начинающаяся с буквы или символа "_".

Прописные и строчные латинские буквы считаются различными! Например, y и Y — это разные имена. Рекомендуется в именах переменных использовать только строчные буквы.

Примеры правильных идентификаторов: schetchik get_line a12 Param1 _ab Примеры неправильных идентификаторов:

%ab 12abc —x вася

Литералы — это неизменяемые объекты языка (константы). Литерал может быть числовым, символьным или строковым. Числовые литералы могут быть десятичными (целыми и вещественными, простыми и длинными), восьмеричными, шестнадцатеричными.

Примеры:

/* Целые десятичные литералы */

57  3200000l                                     /* длинный */ 2e3  5E3

/* Вещественные десятичные литералы */

0.00  5.3 7.1e–3   6.34E–2                                        .21e+56

Лидирующий нуль (0) указывает на числовой восьмеричный литерал:

030  /* Десятичное 24 */

040  /* Десятичное 32 — символ пробел */

Лидирующий 0x указывает на числовой шестнадцатеричный литерал:

0x22 /* Десятичное 34 — символ "*/

0x6С /* Десятичное 108 — символ i */

Символьный литерал — это один символ, заключенный в одинарные кавычки: 'c', '*', 'q'.

"\007" /* Звонок, восьмеричный код после \ */

"\x0a" /* Перевод на новую строку, шестнадцатеричный код после \x */

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

Примеры:

"STRING\n"

"" /* Строчный литерал состоит из одного символа "\0" */

"Очень,"\

"очень,"\

"очень длинный строковый литерал!"

Следующие зарезервированные служебные (ключевые) слова языка запрещено использовать в качестве идентификаторов:

auto               — автоматический;	default	— по умолчанию;
break              — завершить;	do	— выполнить;
case                — вариант;	double	— двойной точности;
char                — символьный;	else	— иначе;
continue  — продолжить;	entry	— вход;
extern            — внешний;	short	— короткий;
for                  — для;	sizeof	— размер;
float              — плавающее;	static	— статический;
goto               — перейти;	struct	— структура;
if                    — если;	switch	— переключатель;
int                  — целое;	typedef	— определение типа;
long               — длинное;	union	— объединение;
register — регистровый;	unsigned	— без знака;
return             — возврат;	while	— пока.

Типы данных и операции в языке Си.  Выражения

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

В языке Си типы связаны с именами (идентификаторами) величин, т. е. с переменными. С переменной в языке Си связывается ячейка памяти. Тип переменной задает размер ячейки, способ кодирования ее содержимого, допустимые преобразования над значением данной переменной. Все переменные должны быть описаны до их использования. Каждая переменная должна быть описана только один раз.

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

Примеры описаний:

char a,b;                 /* Переменные a и b имеют тип char */ int x;  /* Переменная x — типа int */

char sym;               /* Описана переменная sym типа char; */ int count,num;                 /* num и count типа int */

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

Примеры: 

char backch = '\0'; int i = 0;

Рассмотрим основные типы в языке Си.

int — целый ("integer"). Значения этого типа — целые числа из некоторого ограниченного диапазона (обычно от –32 768 до 32 767). Диапазон определяется размером ячейки для типа и зависит от конкретного компьютера. Кроме того, имеются служебные слова, которые можно использовать с типом int: short int (от short integer — короткое целое), unsigned int (от unsigned integer — целое без знака), long int (длинное целое), они сокращают или, наоборот, расширяют диапазон представления чисел.

char — символьный ("character"). Допустимое значение для этого типа — один символ (не путать с текстом!). Символ записывается в апострофах.

Примеры:

'x' '2' '?'

В памяти компьютера символ занимает один байт. Фактически хранится не символ, а число — код символа (от 0 до 255). В специальных таблицах кодировки указываются все допустимые символы и соответствующие им коды.

В языке Си разрешается использовать тип char как числовой, т. е. производить операции с кодом символа, применяя при этом спецификатор целого типа в скобках — (int).

float — вещественный (с плавающей точкой). Значения этого типа — числа, но, в отличие от char и int, не обязательно целые.

Примеры:

12.87  –316.12                            –3.345e5                 12.345e–15

double — вещественные числа двойной точности. Этот тип аналогичен типу float, но имеет значительно больший диапазон значений (например, для системы программирования Borland C от 1.7E–308 дo 1.7E+308 вместо диапазона от 3.4E–38 дo 3.4E+38 для типа float). Однако увеличение диапазона и точности представления чисел ведет к снижению скорости выполнения программ и неэкономному использованию оперативной памяти компьютера.

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

Необходимо отметить, что последним элементом массива является символ \0. Это "нуль-символ", и в языке Си он используется для того, чтобы отмечать конец строки. Нуль-символ не цифра 0; он не выводится на печать и в таблице кодов ASCII имеет номер 0. Наличие нуль-символа означает, что количество ячеек массива должно быть, по крайней мере, на одну больше, чем число символов, которые необходимо размещать в памяти.

Приведем пример использования строк.

#include <stdio.h> main() {

     char string[31];      scanf("%s",string);      printf("%s",string);

}

 

В этом примере описан массив из 31 ячейки памяти, в 30 из которых можно поместить один элемент типа char. Он вводится при вызове функции scanf("%s",string);. "&" отсутствует при указании массива символов.

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

Например, &name — указатель на переменную name.

Здесь & — операция получения адреса. Фактический адрес — это число, а символическое представление адреса &name является константой типа "указатель".

В языке Си имеются и переменные типа указатель. Точно так же, как значением переменной типа char является символ, а значением переменной типа int — целое число, значением переменной типа указатель служит адрес некоторой величины.

Если мы дадим указателю имя ptr, то сможем написать такой оператор: ptr = &name; /* присваивает адрес name переменной ptr */

Мы говорим в этом случае, что prt "указатель на" name. Различие между двумя формами записи: ptr и &name — в том, что prt — это переменная, в то время как &name — константа. В случае необходимости можно сделать так, чтобы переменная ptr указывала на какой-нибудь другой объект: ptr = &bah; /* ptr указывает на bah, а не на name */

Теперь значением переменной prt является адрес переменной bah.

Предположим, мы знаем, что в переменной ptr содержится ссылка на переменную bah. Тогда для доступа к значению этой переменной можно воспользоваться операцией "косвенной адресации" *: val = *ptr; /* определение значения, на которое указывает ptr */ Последние два оператора, взятые вместе, эквивалентны следующему: val = bah;

Итак, когда за знаком & следует имя переменной, результатом операции является адрес указанной переменной; &nurse дает адрес переменной nurse; когда за знаком * следует указатель на переменную, результатом операции является величина, помещенная в ячейку памяти с указанным адресом.

Пример:

nurse = 22; ptr = &nurse; /* указатель на nurse */ val = *ptr;

Результат — присваивание значения 22 переменной val.

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

Примеры правильного описания указателей: int *pi; char *pc;

Спецификация типа задает тип переменной, на которую ссылается указатель, а символ * определяет саму переменную как указатель. Описание вида int *pi; говорит, что pi — это указатель, и что *pi — величина типа int.

В языке Си предусмотрена возможность определения имен типов данных. Любому типу данных с помощью определения typedef можно присвоить имя и использовать это имя в дальнейшем при описании объектов. Формат: typedef <cтарый тип> <новый тип> Пример: typedef long LARGE; /* определяется тип large, эквивалентный типу long */ Имена производного типа рекомендуется записывать прописными буквами, чтобы они выделялись в тексте программы.

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

Операции. Язык Си отличается большим разнообразием операций (более 40). Здесь мы рассмотрим лишь основные из них, табл. 5.4.

Арифметические операции. К ним относят:

 сложение (+),

 вычитание (бинарное) (–),

 умножение (*),

 деление (/),

 остаток от деления нацело (%),  вычитание (унарное) (–) .

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

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

#include <stdio.h> main() {       int s;       s = –3 + 4 * 5 — 6; printf("%d\n",s);       s = 3 + 4%5 — 6;                 printf("%d\n",s);       s = –3 * 4% — 6/5;             printf("%d\n",s);       s= (7 + 6)%5/2;                 printf("%d\n",s);

}

 

Результат выполнения программы: 11                   1              0              1

 

Таблица 5.4. Старшинство и порядок выполнения операций

Приоритет	Операция	Название	Порядок выполнения
Высший	()	Круглые скобки	Слева направо
	[]	Квадратные скобки	Слева направо
	++	Увеличение	Справа налево
	--	Уменьшение	Справа налево
	(тип)	Приведение	Справа налево
	*	Содержимое	Справа налево
1	&	Адрес	Справа налево
	–	Унарный минус	Справа налево
	!	Логическое "НЕ"	Справа налево
	\~	Инверсия битов	Справа налево
	sizeof	Размер объекта	Справа налево
	*	Умножение	Слева направо
2	\	Деление	Слева направо
	%	Остаток	Слева направо
3	+	Сложение	Слева направо
	–	Вычитание	Слева направо
4	>>	Сдвиг вправо	Слева направо
	<<	Сдвиг влево	Слева направо
	>	Больше	Слева направо
5	>=	Больше или равно	Слева направо
	<	Меньше	Слева направо
	<=	Меньше или равно	Слева направо
6	==	Равно	Слева направо
	!=	Не равно	Слева направо
7	&	Битовое "И"	Слева направо
8	~	Битовое исключающее "ИЛИ"	Слева направо
9	|	Битовое "ИЛИ"	Слева направо
10	&&	Логическое "И"	Слева направо

Таблица 5.4 (окончание)

Приоритет	Операция	Название	Порядок выполнения
11	||	Логическое "ИЛИ"	Слева направо
	=	Операция присваивания	Справа налево
	+=	Справа налево
12	–=	Специальная	Справа налево
	*=	форма	Справа налево
	/=	операции	Справа налево
	%=	присваивания	Справа налево

 

В программировании часто встречаются ситуации, когда надо увеличить или уменьшить значение некоторой переменной на 1. Для этого обычно выполняется оператор присваивания вида: s=s+1;.

В языке Си для таких действий существуют специальные операции:

 увеличение (++);

 уменьшение (––).

Следующие записи на языке Си являются эквивалентными: i=i+1;  и  i++; j=j–1;  и  j––;

Символы "++" или "––" записываются после имени переменной или перед ним.

Пример:

s++;  /* s увеличить на единицу */ t––;  /* t уменьшить на единицу */ ++a;  /* a увеличить на единицу */

––b;  /* b уменьшить на единицу */

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

Пример:

int i, j, s;

i=j=2; /* i и j получают значение 2 */ s=(i++)+(++j);

После выполнения этих действий переменные имеют такие значения: i=3; j=3; s=5;

Операции увеличения ++ и уменьшения –– можно применять только к переменным, выражения типа s=(i+j)++ являются незаконными! Кроме того, не рекомендуется:

 применять операции увеличения или уменьшения к переменной, присутствующей в более чем одном аргументе функции;

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

Операции отношения и логические операции:

 больше или равно (>=);

 больше (>);

 меньше или равно (<=);

 меньше (<);

 равно (==);

 не равно (!=);

 логическое "и"(&&);

 логическое "или"(||);  отрицание "не" (!).

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

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

Старшинство операции && выше, чем у операции ||.

#include <stdio.h> main()

{       int x, y, z;       x=1; y=1; z=0; x=x&&y||z; printf("%d\n",x);       x=x||!y&&z; printf("%d\n",x);       x=y=1; z=x++–1; printf("%d\n",x);printf("%d\n",z);       z+=–x++ + ++y; printf("%d\n",x); printf("%d\n",z);       z=x/++x; printf("%d\n",x); printf("%d\n",z);

}

 

Результат выполнения программы: 1   1   2   0   3   0   4   1

Битовые операции:

 битовое "и" (&);

 битовое "или" (|);

 битовое исключающее "или" (~);

 сдвиг влево (<<);

 сдвиг вправо (>>);

 инверсия битов (унарная операция) (\~).

#include <stdio.h> main() {       int y, x, z, k;       x=03; y=02; z=01; k=x|y&z; printf("%d\n",k);       k=x|y&~z; printf("%d\n",k);       k=x^y&~z; printf("%d\n",k);       k=x&y&&z; printf("%d\n",k);       x=1; y=–1;       k=!x|x; printf("%d\n",k);       k=–x|x; printf("%d\n",k);       k=x^x; printf("%d\n",k);       x<<=3; printf("%d\n",x);       y<<=3; printf("%d\n",y);       y>>=3; printf("%d\n",y);

}

 

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

3   3   1   1   1   –1   0   8   –8   8   1   9   1

Выражения. Конструкции, включающие константы (литералы), переменные, знаки операций, скобки для управления порядком выполнения операций, обращения к функциям, называют выражениями.

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

 переменные типа char интерпретируются как целые без знака (unsigned);

 переменные типа short автоматически преобразуются в int; если один из операндов имеет тип unsigned, то другой (другие) также преобразуется к типу unsigned и результат имеет тип unsigned;

 если один из операндов имеет тип int, то другой (другие) также преобразуется к типу int и результат имеет тип int;

 если один из операндов имеет тип char, то другой (другие) также преобразуется к типу char и результат имеет тип char;

 во время операции присваивания значение правой части преобразуется к типу левой части, который и становится типом результата;

 в процессе преобразования int в char лишние старшие 8 бит просто отбрасываются.

Кроме того, существует возможность точно указывать требуемый тип данных, к которому необходимо привести некоторую величину (в скобках перед этой величиной). Скобки и имя типа вместе образуют операцию, называемую приведением типов. Например: z=(int)x+(int)y;

Операторы.  Управляющие конструкции языка

Операторы служат основными строительными блоками программы. В языке Си указанием на наличие оператора служит символ "точка с запятой", стоящий в конце него.

Операторы состоят из выражений. Выражение представляет собой объединение операций и операндов. Операндом называется то, над чем выполняется операция.

Оператор присваивания

Общий вид оператора присваивания:

<Имя> = <Выражение>;

Пример:

int x, y, a; x=5; y=x*2+7; a=y/4;

Переменные получают значения: x=5, y=17, a=4.

В языке Си разрешается включать присваивания в выражения, т. е. присваивание может рассматриваться как операция с учетом старшинства и влияния скобок. Пример: a=(y=(x=5)*2+7)/4;

В результате переменная x получает значение 5, причем это значение участвует в дальнейших вычислениях. Затем выполняется умножение (5*2), сложение (10+7) и еще одно присваивание (y=17). Переменная y получает значение 17, после чего производится деление (17/4), результат которого присваивается переменной a.

В языке Си для компактной записи операторов присваивания имеются специальные операции:

+= –= *= /= %=

Так, следующие две записи на языке Си эквивалентны: i=i+2 и i+=2.

Пример:

int x,y; x=y=5; x+=2;    /* x увеличить на 2, результат x=7 */ y–=3;    /* y уменьшить на 3, результат y=2 */ x*=y;    /* x умножить на y, результат x=14 */

x/=++y;  /* разделить x на увеличенный y; результат y=3, x=12/3 */

Операция присваивания сама по себе имеет значение (равное значению выражения, стоящего справа от знака "=") и может входить в выражения.

Оператор if/else

Общий вид оператора:

if (<выражение>) <оператор1> else <оператор2>;

Здесь часть else <оператор2> является необязательной, можно применять и одиночный оператор if(<выражение>) <оператор1>;

Вначале вычисляется значение выражения. Оператор1 выполняется, если значение выражения истинно. Если выражение ложно (его значение равно нулю), и если есть часть с else, то выполняется оператор2.

Программа 50 (нахождение наибольшего из двух целых чисел a и b)

#include <stdio.h> main( ) {        int a,b;        printf("Введите первое число — "); scanf("%d", &a);        printf("Введите второе число — "); scanf("%d", &b);        if (a==b)        printf("Заданные числа равны.\n");        else        if (a>b)        printf("Первое число больше второго.");              else              printf("Второе число больше первого.");

}

 

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

В качестве оператора1 может стоять любой оператор, в частности, снова оператор if/else. При этом может возникнуть неоднозначность, если во вложенной последовательности операторов if/else часть else опускается. Else всегда соответствует ближайшему предыдущему if, не содержащему else.

Например, в конструкции:

if (n>0)     if (a>b)         z=a;     else z=b;

else относится к внутреннему if. Если требуется отнести else к внешнему if, то необходимо использовать фигурные скобки:

if (n>0) {    if (a>b)    z=a; } else z=b;

Часто приходится осуществлять выбор более чем из двух вариантов. Чтобы учесть это, конструкция if/else расширяется конструкцией else/if. Распространенный способ выбора по значению из нескольких вариантов:

if (<выражение1>) <оператор1>     else if (<выражение2>) <оператор2>         else if (<выражение3>) <оператор3> else <операторN>;

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

В языке Си имеется компактный способ записи одного из видов оператора if/else. Он называется "условным выражением" или "тернарной операцией". Такое выражение выглядит в общем виде так:

В1 ? В2 : В3

Сначала вычисляется значение выражения В1. Если оно отлично от нуля (истинно), то вычисляется значение выражения В2, которое и становится значением условного выражения. В противном случае вычисляется значение выражения В3, и оно становится значением условного выражения.

Условное выражение удобно использовать в тех случаях, когда имеется отдельная переменная, которой можно присвоить одно из двух возможных значений. Типичными примерами являются присваивание переменной значения большей из двух величин: max = (a>b)?a:b; и нахождение абсолютного значения числа: x = (y<0)?–y : y;

Оператор-переключатель switch

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

Его синтаксис:

switch (<выражение>)

{       сase <константа1>: <список операторов1>;       case <константа2>: <список операторов2>;      ...

      case <константаN>: <список операторовN>;       default: <список операторов>;

}

Оператор-переключатель выполняется следующим образом. Вычисляется значение выражения в скобках, приведенного после ключевого слова switch, затем программа просматривает список меток, указанных после слов case, до тех пор, пока не находит ту, которая соответствует данному значению. Далее программа переходит к выполнению оператора, расположенного в этой строке. Если подходящей метки не найдется и если существует строка с меткой default:, то будет выполняться оператор, помеченный этой меткой. В противном случае произойдет переход к оператору, расположенному за оператором switch.

Метки, имеющиеся в операторе switch, должны быть константами или константными выражениями (выражениями, операнды которых — константы) целого или символьного типа. Запрещается использовать в качестве метки переменную. Значением выражения в скобках должна быть величина целого или символьного типа. Список операторов варианта может быть либо пустым, либо заканчиваться одним из операторов завершения (break, continue, goto, return). Если у вариантов нет общих частей, то рекомендуется каждый вариант завершать оператором break.

#include <stdio.h> main () {       int c;       printf("Введите цифру от 1 до 7:");       c=getchar();       printf("\nСоответствующий день недели:");       switch (c)

      {             case '1' : {printf("\nПонедельник!");break;}             case '2' : {printf("\nВторник!");break;}             case '3' : {printf("\nСреда!");break;}             case '4' : {printf("\nЧетверг!");break;}             case '5' : {printf("\nПятница!");break;}             case '6' :{printf("\nСуббота!");break;}             default: printf("\nВоскресенье! ");

      }

}

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

Оператор цикла for

Оператор for (<оператор1>;<выражение>;<оператор2>) <оператор3>;

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

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

Выражение1 является условием завершения цикла, а оператор2 задает приращение управляющей переменной. Например, следующая конструкция: for (i=1; i<n; i++) <оператор>;

является широко распространенной и позволяет "перебрать" первые n натуральных чисел. Из первой строки цикла for можно сразу узнать всю информацию о параметрах цикла: начальное значение переменной i, ее конечное значение, а также насколько увеличивается значение переменной i при каждом выполнении тела цикла.

Любой из операторов и выражений в цикле for может быть опущен, хотя точка с запятой при этом должна оставаться. Если отсутствует оператор1 или оператор2, то он просто выпадает из вычислений. Если же отсутствует выражение1, то считается, что оно всегда истинно. Например, цикл

for (i=1;;i++)

{

... } является бесконечным.

Существуют разнообразные возможности применения цикла for:

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

for (n=10;n>0;n– ) printf("%d \n",n);

 при желании можно вести счет двойками, десятками и т. д.:

for (n=2;n<60;n+=2) printf("%d\n",n);

 можно вести подсчет при помощи символов, а не только чисел: for(ch='a';ch<='z';ch++) printf("Величина кода ASCII для %c равна %d.\n",ch,ch);

 можно проверить выполнение некоторого произвольного условия, отличного от условия, налагаемого на число итераций:

for (num=1;num*num*num<216;num++)

 можно сделать так, чтобы значение некоторой величины возрастало не в арифметической, а в геометрической прогрессии:

for(n=1;n<1500;n*=3) printf("%d \n",n);

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

for(x=1;y<=75;y=5*(x++)+10) printf("%d, %d\n",x,y);

 можно даже опустить одно или более выражений (но при этом нельзя опускать символы ";"); необходимо только включить в тело цикла несколько операторов, которые в конце концов приведут к завершению его работы:

ans=2; for(n=3;ans<=25;) ans=ans*n; Тело цикла for(;;) printf("* \n"); будет выполняться бесконечное число раз, поскольку пустое условие всегда считается истинным;

 первое выражение не обязательно должно инициализировать переменную; вместо этого, например, там мог бы стоять оператор printf() некоторого специального вида; необходимо помнить, что первое выражение вычисляется только один раз перед тем, как остальные части цикла начнут выполняться:

for(printf("Запоминайте введенные числа!\n");num == 6;) scanf("%d",&num); printf("Это как раз то, что я хочу!\n");

В этом фрагменте первое сообщение оказывается выведенным на печать один раз, а затем осуществляется прием вводимых чисел до тех пор, пока не поступит число 6;

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

for(n=1;n<1000;n+=delta) и если после нескольких итераций программа решает, что величина параметра delta слишком мала или велика, оператор if внутри цикла может изменить значение этого параметра (в диалоговой программе пользователь может изменить этот параметр в процессе выполнения цикла).

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

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

1.    for(i=1; i<10; i++)     for(j=1; j<10; j++)

        <оператор>

2.    for(i=1, j=1; i<10, j<10; i++, j++)

    <оператор>

В следующей программе переменные x, y, z изменяются параллельно.

#include <stdio.h> main() {       int x,y,z,v,u,zero();       for(x=1,y=1,z=1;x<10;x++,y++,z++)           printf("x=%d y=%d z=%d\n", x, y, z);

}

 

Результат работы программы:

x=1 y=1 z=1 x=2 y=2 z=2 x=3 y=3 z=3 x=4 y=4 z=4 x=5 y=5 z=5 x=6 y=6 z=6 x=7 y=7 z=7 x=8 y=8 z=8 x=9 y=9 z=9

Оператор цикла while

В общем виде цикл while записывается так: while (<выражение>) <оператор>;

Цикл while является "условным" циклом, использующим предусловие (т. е. условие на входе). Он называется условным, потому что выполнение оператора зависит от истинности условия, описываемого с помощью выражения.

Если выражение "истинно" (или в общем случае не равно нулю), то оператор, входящий в цикл while, выполняется один раз, а затем выражение проверяется снова. Эта последовательность действий, состоящая из проверки и выполнения оператора, периодически повторяется до тех пор, пока выражение не станет ложным (или в общем случае равным нулю). После этого управление передается оператору, следующему за оператором цикла while.

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

Пример 1. Алгоритм Евклида.

#include <stdio.h> main() {       int x,y;       scanf("\n%d",&x); scanf("\n%d",&y);       while (x!=y)

      {          if (x>y) x=x–y; else y=y–x;

      }

      printf("\n%d",x);

}

Пример 2. Проверить, содержит ли квадрат натурального числа n цифру 3.

#include <stdio.h> main() {       int i,n,a;       scanf("%d",&n); n=n*n; i=10000;       while(i>=1)

      {             a=n/i; /* если результат целочисленного деления n/i                        меньше 1, то a=0 */             n=n–a*i;             if(a==3) goto abc; else i=i/10;

      }       printf("цифры 3 в числе n^2 нет");       goto cd;       abc: printf("цифра 3 в числе n^2 есть");       cd: ;

}

 

Оператор цикла do/while

В языке Си имеется также конструкция цикла с постусловием (условие на выходе), где истинность условия проверяется после выполнения каждой итерации цикла. Этот подход реализуется с помощью цикла do/while.

Тело цикла do/while всегда выполняется по крайней мере один раз, поскольку проверка условия осуществляется только после его завершения.

Форма записи:

do <оператор> while (<выражение>);

Оператор break

Оператор break дает возможность выйти из операторов цикла for, while, do/while, а также из переключателя switch без проверки условия. Оператор break приводит к немедленному выходу из самого внутреннего охватывающего его цикла или из переключателя.

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

#include <stdio.h> main() {       int x=1,y,z;       рrintf("Мы будем вычислять значение функции y=2*x+z\n");       printf("Введите значение z:"); scanf("%d",&z);       while(x<1000)

      {             y=2*x+z;x++; if y=100 { printf(= 100\n"); break; }

      }       if y=100       printf("Цикл закончен!!!");       else printf("Цикл закончен!!! Но y<>100.");

} 

Наличие оператора break позволяет использовать "бесконечные циклы". В ряде случаев весьма удобно записать заголовок цикла без всякого условия в виде: for(;;) , а выход из цикла оформить с помощью операторов break.

Оператор продолжения continue

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

#include <stdio.h> main() {       int x,y,z;       printf("Мы будем вычислять значение функции y=2*x+z\n");       printf("в промежутках [1;6] и [13;18].");       рrintf("Введите значение z= "); scanf("%d",&z);       for(x=1;x<18;x++)

      {

         if ((x>6) and (x<13))          continue;

         y=2*x+z; printf(= %d, y= %d",x,y);

      }

}

Оператор безусловного перехода goto

Оператор перехода предназначен для безусловной передачи управления в заданную точку программы. Его выполнение заключается в передаче управления оператору, помеченному заданной меткой.

В качестве метки используется идентификатор. Метка отделяется от оператора, к которому она относится, двоеточием. Помеченный оператор должен находиться в пределах той же функции, что и оператор goto. Может быть помечен любой оператор, но никакие два разных оператора не должны иметь одинаковые метки (внутри одной и той же функции). Кроме того, один оператор может быть помечен несколькими метками.

Форма:

goto <метка>; ... <метка>: <оператор>

Составные операторы и блоки

Символы "{" и "}" используются для объединения описаний и операторов в составной оператор или блок, так что все конструкции, заключенные в фигурные скобки, оказываются синтаксически эквивалентными одному оператору. Точка с запятой никогда не ставится после первой фигурной скобки, которая завершает блок.

Составной оператор — последовательность операторов, заключенная в фигурные скобки (при необходимости его используют в качестве "внутреннего" оператора в операторах ветвления и цикла). Он называется также блоком. Блоки не могут быть вложенными.

#include <stdio.h> main() {      int sam,index=0;

     /* В цикл включен только оператор присваивания. Печать данных */      /* будет произведена только один раз — после завершения цикла. */      while(index++<10)      sam=10*index+2;      printf("sum= %d\n",sam);

}

Результат работы программы:

sam = 102

#include <stdio.h> main() {       int sam,index=0;

      /* Наличие фигурных скобок гарантирует, что оба оператора */

      /* являются частью цикла while, и печать результатов будет */

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

      /* оператор рассматривается как один оператор, являющийся */

      /* составной частью оператора while. */       while(index++<10)

      {             sam=10*index+2; printf("sum = %d\n",sam);

      }

}

 

Результат работы программы:

sam = 12 sam = 22 sam = 32 sam = 42 sam = 52 sam = 62 sam = 72 sam = 82 sam = 92 sam = 102

Пустой оператор состоит только из точки с запятой (;) и используется для обозначения пустого тела управляющего оператора.

Структура программы на Си.  Понятие о функциях

Программа на языке Си представляет собой набор последовательно описанных функций (процедуры и подпрограммы в языке Си считаются частным случаем функций). Каждая функция — самостоятельная единица программы, предназначенная для решения определенной задачи (или подзадачи). 

При описании она имеет следующий вид:

Тип_функции Имя (<cписок аргументов>)

<описания аргументов>

{

    <описания>

    <операторы>

}

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

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

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

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

#include <stdio.h> main() {       int i,print();       for (i=1;i<=15;i++) print();

      {           print() /* вызываемая функция без аргументов */

      }       printf ("Простая функция без аргументов\n");

}

 

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

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

Можно задавать список аргументов, разделенных запятыми.

Пример: программа 60, которая находит числа x, y, z, принадлежащие отрезку [1;20] и удовлетворяющие условию x^2=y^2+z^2.

#include <stdio.h> main() {

     int x, y, z, zero();      char p, q, ch();      x=2; y=45; z=0;      q='o';

     printf("x= "); zero(x);

     printf("x+y+(x+y)^z= "); zero(x+y+(x+y)^z);      printf("q= "); ch(q);

} int zero(u) int u; {

     printf("%d\n",u);

} char ch(u) char u; {

     printf("%c\n",u);

}

 

Результат работы программы:

x= 2 x+y+(x+y)^z= 94 q= о

#include <stdio.h> main() {      int x,y,z;      int zero();      printf("Следующие величины могут быть сторонами прямоугольного треугольника:\n");      for (x=1;x<=20;x++)      for (y=1;y<=20;y++)      for (z=1;z<=20;z++)      if (y*y+z*z==x*x)      zero(x,y,z);

} int zero(f,g,h) int f,g,h; {      printf ("x= %d, y= %d, z=%d\n",f,g,h);

}

 

Результат работы программы:

Cледующие величины могут быть сторонами прямоугольного  треугольника: x= 5, y= 3, z= 4 x= 5, y= 4, z= 3 x= 10, y= 6, z= 8 x= 10, y= 8, z= 6 x= 13, y= 5, z= 12 x= 13, y= 12, z= 5 x= 15, y= 9, z= 12 x= 15, y= 12, z= 9 x= 17, y= 8, z= 15 x= 17, y= 15, z= 8 x= 20, y= 12, z= 16 x= 20, y= 16, z= 12

Завершает выполнение данной функции и передает управление вызывающей функции оператор return; в главной функции main он же вызывает завершение выполнения всей программы. Оператор return может содержать любое выражение: return (<выражение>);

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

Достижение "конца" функции (правой закрывающей фигурной скобки) эквивалентно выполнению оператора return без возвращаемого значения (т. е. оператор return в конце функции может быть опущен).

Пример: данная программа вычисляет факториал, если число меньше 8; если вводимое число больше или равно 8, то выводится сообщение "Очень большое число".

#include <stdio.h> main() {      int n, s();      printf("Введите число ");      scanf("%d", &n);      if (n<8) printf("p=%d", s(n));      else printf("Очень большое число");

} int s(x) /* определение функции с параметром */ int x; {      int y,p=1;      for (y=x; y>0; y– ) p*=y;      return(p); /* Возвращает в основную программу значение p */ }

 

Результат работы программы:

1.      Введите число 4 p=24

2.      Введите число 9

Очень большое число

Пример: предположим, что нужно вычислить x² (для некоторого неотрицательного целого y) (очевидный способ реализации возведения в целочисленную степень — многократное умножение, но существует более эффективный алгоритм, приведенный далее).

#include <stdio.h> main() {

     int a, b, x, y, z;      int odd();      printf("\nВведите x, y через пробел: ");      scanf("%d %d", &x, &y); a=x; b=y; z=1;      while (b!=0)      if (odd(b))      { z=z*a; b– –;}      else

     { a=a*a; b=b/2;}      printf("\n%d", z);

} int odd(t) int t; {      return((t%2==0)? 0:1);

}

 

Результат работы программы:

Введите x, y через пробел: 15 2

225

Если функции необходимо вернуть несколько значений, можно использовать два различных приема:

 применить глобальные переменные (в этом случае кроме изученных ранее характеристик переменных (имени, типа, значения) используется еще одна — класс памяти, см. далее);

 применить переменные типа "указатель" в качестве аргументов функции.

При вызове функции информация о переменной может передаваться функции в двух видах. Если мы используем форму обращения function1(x);

то происходит передача в функцию значения переменной x. Изменение этого значения в вызывающую функцию не возвращается. Если мы используем форму обращения function2(&x);

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

function1(num) int num;

Вторая форма обращения требует, чтобы определение функции включало  в себя формальный аргумент, являющийся указателем на один из объектов соответствующего типа:

function2(x) int *x;

Обычно пользуются первой формой, если входное значение необходимо функции для некоторых вычислений или действий, и второй формой, если функция должна будет изменять значения переменных в вызывающей программе. Ранее вторая форма вызова уже применялась при обращении к функции scanf(). Когда мы хотим ввести некоторое значение в переменную num, мы пишем scanf("%d",&num). Данная функция читает значение, затем, используя адрес, который ей дается, помещает это значение в память.

Пример: пусть необходимо поменять местами заданные значения переменных x и y.

#include <stdio.h> main() {      int x, y;      int interchange();             /* описание функции типа int */      x=1; y=3;

     printf("Имели... x=1 y=3\n");

     interchange(&x, &y);  /* обращение к функции (в данном случае                                                                                  передаются адреса переменных) */

     printf("Получили... x=%d y=%d", x, y);

}

/* вызываемая функция */ int interchange(u, v) int *u, *v;

{     int p;     p=*u; *u=*v; *v=p;

}

 

Результат работы программы:

Имели x=1 y=3

Получили x=3 y=1

В этой программе в вызове функции interchange(&x,&y) вместо передачи значений x и y мы передаем их адреса. Это означает, что формальные аргументы u и v, имеющиеся в спецификации interchange(u,v), при обращении будут заменены адресами и, следовательно, они должны быть описаны как указатели.

Поскольку x и y целого типа, u и v являются указателями на переменные целого типа, и мы вводим следующее описание: int *u,*v; int p;

Оператор описания используется с целью резервирования памяти. Мы хотим поместить значение переменной x в переменную p, поэтому пишем: p=*u;. Вспомните, что значение переменной u — это &x, поэтому переменная u ссылается на x. Это означает, что операция *u дает значение x, которое как раз нам и требуется. Мы не должны писать, например, так: p=u; /* неправильно */

поскольку при этом происходит запоминание адреса переменной x, а не ее значения. Аналогично, оператор *u=*v соответствует оператору x=y.

Тип функции определяется типом возвращаемого ею значения, а не типом ее аргументов. Если указание типа отсутствует, то по умолчанию считается, что функция имеет тип int. Если значения функции не принадлежат типу int, то необходимо указать ее тип в двух местах.  Описать тип функции в ее определении:

    char pun(ch,n) /* функция возвращает символ */     int n;     char ch;

 Описать тип функции также в вызывающей программе. Описание функции должно быть проведено наряду с описаниями переменных программы; необходимо только указать скобки (но не аргументы) для идентификации данного объекта как функции.

   main()    char rch,pun();

Классы памяти

Помимо изученных ранее характеристик переменных (имени, типа, значе- ния) в ряде случаев оказывается важной еще одна — класс памяти. Класс  памяти характеризует время существования и место хранения объекта в программе.

Для обозначения класса памяти в языке Си используются следующие служебные слова:

auto        extern register         static

Автоматические объекты (auto) являются локальными по отношению к блоку и хранятся внутри того блока, где они описаны. Автоматические переменные можно инициализировать произвольными выражениями, включающими константы и ранее описанные переменные и функции.

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

Объекты, описанные внутри блока с классом памяти register, называются регистровыми переменными. Они подчиняются всем правилам, касающимся автоматических переменных. Описание register указывает компилятору, что данная переменная будет часто использоваться. Когда это возможно, переменные, описанные как register, располагаются в машинных регистрах. Это приводит к меньшим по размерам и более быстрым программам.

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

Внешние объекты делятся на внешние глобальные и внешние статические.

Важно различать описание внешнего объекта и его определение. Описание указывает свойства объекта (тип, размеры и т. д.); определение же вызывает еще и отведение памяти установке начального значения, если используется инициализация.

Например, появившиеся вне определения какой-либо функции строчки

int max; char save[maxline];

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

В то же время строчки

extern int max; extern char save[];

описывают в остальной части данного блока переменную max как int, a save как массив типа char (размеры которого указаны в другом месте), но не создают переменных и не отводят для них места в памяти.

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

#include <stdio.h> int i=0;

/* Класс памяти переменной — внешний.

/* Область действия переменной — любая программа, */ /* загружающаяся с данным файлом.

/* Время существования i=0 — все время выполнения программы. */ main()                                     /* Блок уровня 1. */

{     auto int i=1;

    /* В блоке 1 область действия i=1 — функция main().*/

    /* Время существования i=1 — все время выполнения /*

    /* главной функции main(). /*     printf("%d\n", i);

    /* Если две переменные имеют одно и то же имя, то по этому */

    /* имени обращаются к внутренней переменной, */

    /* внешняя переменная непосредственно недоступна, поэтому */

    /* после выполнения блока 1 программа напечатает i=1. */     {                                    /* Блок уровня 2. */           int i=2;

          /* Класс памяти переменной i=2 — auto. Область */

          /* действия i=2 — блок 2, время существования — время */

          /* существования блока 2. блок 2, время существования —*/

          /* время существования блока 2. */           printf("%d\n", i);

          /* Программа напечатает i=2. */

          {                               /* Блок уровня 3. */                i+=1; printf("%d\n", i);

              /* Печатается самая внутренняя переменная с именем i,/*

              /* которая после выполнения операции данного блока */

              /* становится равной 3. */

          }

          /* Возвращение к блоку уровня 2. */           printf("%d\n", i);

          /* Опять печатается i=3. */

    }

    /* Возвращение к блоку уровня 1. */     printf("%d", i);

    /* Переменная i=3 исчезает. Теперь самой внутренней переменной */

    /* с именем i будет i=1. */

}

 

#include <stdio.h> int a; main() {

     extern int a;      int P();      a=6; P();

} int P() {

     extern int a;      printf("a=%d",a);

}

 

Результат работы программы: a=6

Областью действия статического внешнего объекта является модуль, в котором описан данный объект. При этом где-либо во внешних описаниях (т. е. вне определения функций) должно быть расположено определение внешнего статического объекта в виде: static <Спецификация типа> <Спецификация данных>;

На основании определения под объект отводится память и может быть произведена инициализация. Статические переменные можно инициализировать только выражениями с константами и с указателями на ранее описанные объекты.

При первом входе в соответствующую локальную область (блок или модуль) статические переменные инициализируются один раз (по умолчанию —  нулем). При последующих входах в данную область статические переменные получают те значения, которые они имели при последнем выходе из области.

По умолчанию все функции данного модуля, расположенные ниже определения статического объекта, включаются в его область действия — в них не обязательно дополнительно описывать объект для получения к нему доступа. Функции, определения которых расположены в модуле выше определения внешнего статического объекта, для получения доступа к нему должны содержать описание этого объекта с классом памяти extern. Константы являются объектами статического класса памяти.

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

#include <stdio.h> main() {

     int count;      int trystat();

     for (count=1; count<=3; count++)

     {

         printf ("Итерация %d:\n", count);          trystat();

     } } trystat() {

     int fade=1;      static int stay=1;

     printf("fade = %d и stay = %d\n", fade++, stay++);

}

 

Результат работы программы:

Итерация 1:

fade = 1 и stay = 1 Итерация 2:

fade = 1 и stay = 2 Итерация 3:

fade = 1 и stay = 3

Если мы лишь немного видоизменим в программе функцию trystat():

trystat() {      int fade=1;      int stay=1;      printf("fade = %d и stay = %d\n", fade++, stay++);

} то получим следующий результат:

Итерация 1:

fade = 1 и stay = 1 Итерация 2:

fade = 1 и stay = 1 Итерация 3: fade = 1 и stay = 1

Функции ввода/вывода

Средства ввода/вывода не являются составной частью языка Си. Имеется ряд библиотечных функций Си, обеспечивающих стандартную систему ввода/вывода для программ на Си. Макроопределения, описания переменных и определения этих функций содержатся в файле стандартных заголовков stdio.h. Поэтому, как указывалось ранее, каждая пользовательская программа должна содержать в начале ссылку:

#include <stdio.h>

В примерах программ мы неоднократно использовали форматные функции ввода (scanf()) и вывода (printf()). Набор стандартных функций ввода и вывода значительно шире и включает большое число функций для работы с данными различного типа, различными устройствами, буферизованного и небуферизованного, форматного и бесформатного ввода и вывода.

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

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

В языке программирования Си файл — это логическое понятие, которое система может относить к чему угодно (от дисковых файлов до терминалов). Поток связывается с конкретным файлом выполнением операции "открыть". Как только файл открывается, можно обмениваться информацией между ним и программой. Закрытие выводимого потока заставляет компьютер записывать содержимое этого потока на внешнее устройство. Этот процесс обычно называется промыванием потока. В начале выполнения программы компьютер открывает три предопределенных текстовых потока stdin, stdout и stderr, связанных со стандартными устройствами ввода/вывода (консоль — клавиатура и дисплей). Допускается переадресация ввода/вывода к другим устройствам.

Простейшими функциями консольного ввода/вывода являются функция getche(), которая читает символ с клавиатуры, и функция putchar(), которая печатает символ на экране. Функция getche() ждет, пока не будет нажата клавиша, а затем возвращает ее значение, автоматически выдавая на экран

"эхо" нажимаемой клавиши. Функция putchar() записывает ее символьный аргумент на экран в текущую позицию курсора.

Далее приводится пример простой программы, которая принимает один символ с клавиатуры и выводит его на экран.

#include <stdio.h> main() {      char ch;      ch = getchar();      putchar(ch);

}

 

Есть две важные версии функции getche(). Первая — getchar() — буферирует ввод до тех пор, пока не введен возврат каретки. Второй версией является функция getch(), которая работает точно так же, как getchar(), за исключением того, что getch() не возвращает на экран эхо введенного символа.

Функции gets() и puts() позволяют читать и писать цепочки символов (строки) с консоли. Функция gets() читает цепочку символов, которая вводится  с клавиатуры (ввод оканчивается возвратом каретки), помещает ее с адреса, который указывает ее аргумент — указатель символа. Функция puts() выводит на экран ее аргумент — цепочку символов, а затем символ новой строки.

 

Например, следующая программа читает цепочку в массив str и тут же печатает ее.

main() {      char str[80];      gets(str);      puts(str);

}

 

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

Таблица 5.5. Некоторые функции буферизованной системы ввода/вывода

Имя	Функция
fopen()	Открывает поток
fclose()	Закрывает поток
putc()	Выводит символ в поток
getc()	Вводит символ из потока
fseek()	Ищет указанный байт в потоке
fprintf()	Форматный вывод в поток
fscanf()	Форматный ввод из потока
feof()	Возвращает истину, если достигается метка EOF (конец файла)
ferror()	Возвращает истину, если встретилась ошибка
rewind()	Устанавливает начальную позицию файла
remove()	Стирает файл

 

Для работы с файлами в Си применяются функции буферизованной системы ввода/вывода, табл. 5.5. Обращение к ним использует указатель файла, который определяет различные характеристики файла, включая его имя, статус и текущую позицию; используется связанным с этим файлом потоком для привязки каждой функции буферированного ввода/вывода к месту, над которым она выполняет свои операции. Указатель файла является переменной типа FILE, которая определяется в файле заголовков stdio.h.

Функция fopen() вызывается так: fopen(<имя_файла>, <режим>);

Имя файла должно быть цепочкой символов, которая составляет правильное имя файла для операционной системы и может включать спецификацию пути. Режим задает желаемый статус открытия, табл. 5.6.

Таблица 5.6. Значения режимов в Турбо Си

Режим	Смысл
"r"	Открыть файл для чтения
"w"	Создать файл для записи
"a"	Добавлять в файл
"r+"	Открыть файл для чтения/записи
"w+"	Создать файл для чтения/записи
"a+"	Открыть или создать файл для чтения/записи

 

Например, для того чтобы открыть файл с именем test для записи, можно написать fp = fopen("test", "w"); где fp — переменная типа FILE*. Переменная fp является указателем файла.

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

if ((fp = fopen("test", "w"))==NULL)

{     puts("Нельзя открыть файл!\n");     exit(1); }

NULL — это макро, которое определяется в файле заголовка stdio.h. Функция putc() в виде putc(<символ>, fp);

используется для записи символа в поток, который предварительно открыт для записи с помощью функции fopen(); fp — возвращаемый функцией fopen() указатель файла.

Функция getc() в виде getc(fp)

используется для чтения символов, которые она возвращает из потока, открытого в режиме чтения функцией fopen(). fp является указателем файла типа FILE, который возвращается функцией fopen(). В тех случаях, когда достигается конец файла, функция getc() возвращает маркер его конца EOF. Например, для чтения текстового файла до маркера конца файла можно использовать следующие операторы:

ch = getc(fp); while(ch!=EOF)

{     ch = getc(fp); }

Функция feof() использует аргумент указателя-файла и возвращает 1, если достигнут конец файла, или 0, если не достигнут. Например, приведенная далее программа читает двоичный файл до тех пор, пока компьютер не встречает маркер конца файла: while(!feof(fp)) ch = getc(fp);

Функцию fclose() используют для закрытия потока, который был открыт с помощью функции fopen(). Все потоки необходимо закрыть перед завершением программы. Аргументом функции является указатель файла, который закрывается.

Функции fopen(), getc(), putc() и fclose() составляют минимальный набор функций ввода/вывода. Простым примером использования функций putc(), fopen() и fclose() является программа, которая приведена далее. Эта программа просто читает символы с клавиатуры и записывает их в дисковый файл до тех пор, пока не введен знак $. Имя выходного файла задается из командной строки. Например, если вы назовете программу ktod ("клавиша — на диск"), то набор на клавиатуре ktod test будет позволять вам вводить строки текста в файл с именем test.

#include .h" main(argc,argv)                  /* ktod — клавиша на диск */ int argc; char *argv[];

{

    FILE *fp;     char ch;     if(argc!=2)

    {         printf("Вы забыли ввести имя файла\n);         exit(1);

    }     if((fp=fopen(argv[1], "w"))== NULL)

    {         printf("не может открыть файл\n);         exit(1);

    }     do     {         ch = getchar();         putc(ch, fp);

    }     while (ch!='s');     fclose(fp);

}

 

Еще одним примером является программа dtos, которая будет читать любой ASCII-файл и выводить его содержимое на экран.

#include "studio.h" main(argc, argv)    /* dtos — диск на экран */ int argc; char *argv[];

{

    FILE *fp;     char ch;     if(argc!=2) {         printf("Вы забыли ввести имя файла\n"};         exit(1);

    }     if((fp=fopen(argv[1], "r"))==NULL){         printf("Не может открыть файл\n"};         exit(1);

    }

    ch=getc(fp);       /* читать один символ */     while(ch!=EOF)

    {         putchar(ch);  /* печать на экран */         ch=getc(fp);

    }     fclose(fp);

}

 

Под управлением буферизованной системы ввода/вывода можно выполнять операции чтения и записи с произвольным доступом с помощью функции fseek(), которая устанавливает файловую позицию.

Например, для чтения 234-го байта в файле с именем test можно использовать следующую функцию:

func1()

{

    FILE *fp;     if((fp=fopen("test" ,"r"))==NULL)

    {          printf("не могу открыть файл\n");          exit(1);

    }     fseek(fp,234L,0);     return getc(fp);  /*читать один символ в 234-й позиции*/ }

В дополнение к рассмотренным до сих пор основным функциям ввода/вывода буферизованная система ввода/вывода включает функции fprintf() и fscanf(). Эти функции ведут себя точно так же, как функции printf() и scanf(), за исключением того, что они работают с дисковыми файлами. Обращения к функциям fprintf() и fscanf() имеют следующий вид:

fprintf(fp,<формат>,<список аргументов>); fscanf(fp,<формат>,<список аргументов>);

где fp является файловым указателем, который возвращается вызовом функции fopen().

Директивы препроцессора

Препроцессор — это программа, которая производит некоторые, иногда весьма значительные, манипуляции с первоначальным текстом программы перед тем, как он подвергается трансляции.

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

Операторы препроцессора могут появляться в любом месте программы и их действие распространяется на весь исходный файл.

Весьма часто используют следующие операторы препроцессора:

#include

#define

Более специфичными являются директивы #pragma, #if, #error и др.

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

Например, чрезвычайно часто в начале программы на языке Си встречается препроцессорная конструкция:

#include <stdio.h>

Когда исходный текст программы обрабатывается препроцессором, на место этой инструкции ставится содержимое расположенного в некоем стандартном месте файла stdio.h, содержащего макроопределения и объявления данных, необходимых для работы функций из стандартной библиотеки ввода/вывода. Для использования различных математических функций необходимо подключать файл описаний math.h. Функции, оперирующие со строками, описаны в файле string.h, функции общего назначения — в stdlib.h, функции даты и времени — в time.h, диагностика — в assert.h и т. д.

Директива #define позволяет дать в программе макроопределения (или задать макросы). Оператор макроопределения имеет вид:

#define <макроимя> <строка лексем> или

#define <макроимя(<список параметров>)> <строка лексем>

Макроимя — это идентификатор. Строка лексем — это последовательность лексем от макроимени до конца строки. Точка с запятой в конце макроопределения не ставится.

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

#define PI 3.14159 #define E 2.711828

препроцессор заменит в программе все имена PI и E на соответствующие числовые константы.

Препроцессор языка Си позволяет переопределять не только константы, но и целые программные конструкции. Например, можно написать определение

#define forever for(;;)

и затем всюду писать бесконечные циклы в виде forever

Определение макроимени с параметрами имеет некоторую специфику. Список параметров макроимени — это список идентификаторов, разделенных запятыми. Следующая после списка параметров строка лексем также может содержать эти параметры, которые при макровызове будут заменены на соответствующие аргументы.

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

В следующих программах иллюстрируются некоторые применения операторов препроцессора.

Пример 1: найти большее из двух чисел.

#include <stdio.h>

#define MAX(X,Y) ((X)>(Y) ? (X) : (Y)) main() {      int x,y;      scanf ("%d %d", &x, &y); printf ("%d", MAX(x, y));

}

 

Результат работы программы:

3 5

5

Пример 2: использование макроимен для задания выражений и вызова функций.

#include <stdio.h>

#define S(x) x*x

#define P(x) printf("х равен %d.\n",x) main() {      int x=4;      int z;

     z = S(x); P(z); z = S(2);

     P(z);

     P(S(x));

     P(S(x+2));

     P(100/S(2));

     P(S(++x));

}

 

Результат работы программы:

x равен 16. x равен 4. x равен 16. x равен 14. x равен 100. x равен 30.

Оператор препроцессора #pragma позволяет записывать самые различные указания компилятору (зависящие от конкретного компилятора). Например, следующие два предложения препроцессора:

#pragma recursive #pragma nonrec

устанавливают режим всех функций программы по умолчанию рекурсивным или нерекурсивным. Указание препроцессора

#pragma optimize time

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

Сравнение языков программирования  Си и Паскаль

При знакомстве с языком Си, особенно после изучения Паскаля, погружение в детали его изобразительных средств может затушевать важную мысль: хотя на Си можно написать практически любую прикладную программу, он изначально для этого не предназначен. Си является результатом эволюционного развития языков создания системных программных средств. Если в прикладном программировании эволюция шла от Фортрана к Алголу, Коболу, Паскалю и т. д., то в системном — от Ассемблеров, привязанных к архитектуре компьютера, к Си, для которого созданы трансляторы, делающие его хоть и независимым от архитектуры, но не меняющим основного предназначения.

С помощью Си можно сделать то, что на Паскале сделать невозможно (или почти невозможно), — например, написать фрагмент операционной системы (или новую операционную систему), утилиты и т. п. Так, ряд трансляторов с Паскаля написаны на Си; обратное невозможно представить. В то же время не раз отмечалось, что прикладные программы, написанные на Паскале, отличаются большей надежностью, чем написанные на Си; их легче читать, передавать от одного программиста другому для совершенствования и сопровождения. Это связано с тем, что Паскаль содержит существенно больше ограничений и является языком более высокого уровня с сильной типизацией данных. Для языка же, который предназначен для разработки системного программного обеспечения, чем меньше ограничений, тем лучше; так, в Си возможны неявные преобразования всех базовых типов данных и указателей друг в друга, что крайне желательно при создании системных средств, но при не- внимательности программиста приводит к ошибкам, не улавливаемым транслятором с Си (Паскаль же подобные недопустимые операции пресекает немедленно).

Разумеется, сказанное не следует абсолютизировать. Программисты, привыкшие к Си, успешно пишут на нем программы различных классов. Это касается не только Си. Даже на Бейсике можно писать экспертные системы.  В то же время при массовом программировании придерживаться "разделения труда" между языками представляется более естественным.

 

Контрольные вопросы

 

1.       Охарактеризуйте назначение и особенности языка Си.

2.       Какие символы образуют алфавит языка Си?

3.       Что называется лексемами, идентификаторами, литералами? Приведите примеры.

4.       Какие типы данных используются в Си? Приведите примеры описания  переменных.

5.       Охарактеризуйте арифметические, логические и битовые операции Си.

6.       Какие разновидности оператора присваивания имеются в Си?

7.       Как на языке Си можно описать ветвление?

8.       Охарактеризуйте возможности цикла for. Приведите примеры.

9.       Какие логические циклы имеются в Си? Приведите примеры их использования.

10.   Какие операторы управления имеются в Си?

11.   Какова структура программы на Си? Что такое функция?

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

13.   Для чего в качестве аргументов функций используются указатели? Приведите примеры.

14.   Для чего в Си существуют классы памяти?

15.   Что такое потоки и файлы в Си?

16.   Охарактеризуйте стандартные функции ввода и вывода в Си.

17.   Что такое препроцессор Си? Приведите примеры директив препроцес- сора.

 

 

 Темы для рефератов и докладов

1.    История возникновения и развития языка Си.

2.    Системы программирования на Си.

3.    С, С++ и ObjectC.

 

 

Вопросы для обсуждения

 

1.    Какой язык вам больше понравился, Паскаль или Си? Почему?

2.    Почему в программе на Си труднее найти ошибки, чем в программе на Паскале?

 

Задачи и упражнения

 

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

2.           Определить, является ли треугольник, заданный длинами его сторон, остроугольным.

3.           Вычислить периметр и площадь прямоугольного треугольника по длинам двух катетов.

4.           По координатам трех вершин некоторого треугольника найти его площадь и периметр.

5.           По длинам двух сторон некоторого треугольника и углу (в градусах) между ними найти длину третьей стороны и площадь этого треугольника.

6.           Найти произведение цифр заданного четырехзначного числа.

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

8.           Определить, равна ли сумма двух первых цифр заданного четырехзначного числа сумме двух его последних цифр.

9.           Даны три произвольных числа. Определить, можно ли построить треугольник с такими длинами сторон.

10.       Даны координаты (как целые от 1 до 8) двух полей шахматной доски. Определить, может ли конь за 1 ход перейти с одного из полей на другое.

11.       Не пользуясь вспомогательными переменными, перераспределить значения переменных x и _y так, чтобы в x оказалось большее из этих значений, а в _y — меньшее.

12.       Переменной ^k присвоить номер четверти плоскости, в которой находится точка с координатами x, _y ,  ( _{x y}* <>0).

Вычислить:

max(x y z, , ) − 2x⋅min(x y z, , ) y ⁼      sin2 + max(x y z, , )/min(x y z, , )

13.       Даны числа a b c a b c_{1 1 1 2 2 2}, _{, , , , .} Напечатать координаты точки пересечения прямых, описываемых уравнениями a x b y c₁ ⁺ ₁ ⁼ _{1 ,} a x b y c₂ ⁺ ₂ ⁼ ₂, либо сообщить, что прямые совпадают, не пересекаются или вообще не существуют.

14.       Дано целое k от 1 до 180. Определить, какая цифра находится в k -й позиции последовательности 10111213...9899, в которой выписаны подряд все двузначные числа.

15.       Даны действительные числа x x x y y y_{1 2 3 1}, _{, , , 2}, ₃. Определить, принадлежит ли начало координат треугольнику с вершинами (x y_{1 1}, ), (x y_{2 2}, ) ,

          (x y_{2 2}, ) .

16.       Дано натуральное число n< 9999. Является ли это число "перевертышем" (палиндромом)?

17.       На поле (k,1) шахматной доски расположен ферзь. Угрожает ли он полю (^{m n}, ) ?

18.       Выяснить, являются ли поля (k,1) и (m n, ) шахматной доски полями одного цвета.

19.       Проверить, является натуральное число ^k степенью 3 или нет.

20.       Дано 10 вещественных чисел. Вычислить разность между максимальным и минимальным из них.

21.       Даны целое n>0 и последовательность из n вещественных чисел, среди которых есть хотя бы одно отрицательное число. Найти величину наибольшего среди отрицательных чисел этой последовательности.

22.       Вычислить по алгоритму Горнера _{y x}= ¹⁰ + 2_x⁹ + 3_x⁸ + +... 10_x+11;

                        10            9          8

                    y=11x +10x +9x + + +...   2x 1.

23.       Дана непустая последовательность различных натуральных чисел, за которой следует 0. Определить порядковый номер наименьшего из них.

24.       Даны натуральное число n и вещественные числа t a_{, 0 1}, a _,..., a_n. Вычис-

лить значение многочлена a x₀ ^{n +}a x₁ ^{n−1+ +}... a x a_n−₁ ⁺ _n и его производ-

2 ной в точке t + 0,5 .

25.       Пусть задано значение x. Найти первое из чисел sin _x , sinsin _x , sinsinsin _x ,..., меньшее по модулю 10^–4.

26.       Вычислить s — сумму всех чисел Фибоначчи, которые не превосходят 1000.

27.       Вычислить для заданного n

n

∑sin(kn)

k=1

28.       Выяснить, можно или нет натуральное число n представить в виде суммы трех полных квадратов.

29.       Даны n — натуральное и вещественные пары x y_{1 1}, ,..., x y_n, _n. Определить радиус наименьшего круга с центром в начале координат, внутрь которого попадают эти точки.

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

31.       Дано 10 целых чисел. Определить, сколько из них принимает наибольшее значение.

32.       Вычислить ^k — число точек с целочисленными координатами, попадающих в круг радиуса R .

33.       Дано 10 вещественных чисел. Определить, образуют ли они возрастающую последовательность.

34.       Дана последовательность положительных целых чисел, за которой следует 0 (признак конца последовательности). Вычислить среднее геометрическое этих чисел.

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

36.       Получить сумму нечетных отрицательных элементов последовательности целых чисел a a_{1 2}, ,..., a_n.

37.       Дано натуральное число n. Вычислить 1 2⋅         + 2 3 4⋅ ⋅            +...+ _{n n}⋅( +1) ... 2 .⋅      ⋅ _n

38.       Преобразовать массив ^X , расположив его элементы в обратном порядке.

39.       Преобразовать массив по следующему правилу (воспользовавшись массивом _y как вспомогательным): все отрицательные элементы массива _x перенести в его начало, а все остальные — в конец, сохраняя исходное взаимное расположение всех элементов (отрицательных в том числе).

40.       Дано натуральное n. Сколько различных цифр встречается в его записи?

41.       Переменной ^k присвоить либо номер первого вхождения _y в массив x, либо число n+1, если _y не входит в x_.

42.       Вычислить для массива из n элементов:

          y x= 1 + x x1 2⋅  + x x x1 2⋅ ⋅ 3 +...+ x x x x1 2 3⋅ ⋅            ... m,

где m — либо номер первого отрицательного элемента массива x, либо число n, если в массиве x нет отрицательных элементов.

43.       Элементы целочисленного массива x упорядочены по возрастанию. Требуется присвоить переменной ^k номер элемента массива x, равного числу _y , или 0, если такого элемента нет.

44.       Даны действительные числа a a_{1 2},           ,..., a_n, b b_{1 2},      _,..., b_n. Вычислить

         (a b1 + n) (⋅ a2 +bn−1) ... (⋅ ⋅ an +b1).

45.       Проверить, имеется ли среди элементов массива x хотя бы одно число Фибоначчи.

46.       Рассматривая массивы x, _y и ^z как представление некоторых множеств из объектов типа индекс ( x k[ ] 1⁼ , если элемент ^k принадлежит множеству x, и x k[ ] 0⁼ иначе), реализовать следующие операции над этими массивами-множествами:

^•               z — объединение множеств x и _y ;

^•               z — пересечение множеств x и _y ;

^•               z — разность множеств x и _y .

47.       Дана последовательность из 10 целых чисел. Определить число инверсий в этой последовательности.

48.       Дана последовательность из 10 целых чисел. Найти сумму чисел этой последовательности, расположенных между максимальным и минимальным числами (в сумму включить и оба этих числа).

49.       Рассматривая массивы x и _y как представление некоторых множеств из объектов типа индекс ( x k[ ] 1⁼ , если элемент ^k принадлежит множеству x, и x k[ ] 0⁼ иначе), проверить, что множество x является подмножест-

вом множества _y .

50.       Даны координаты n точек на плоскости: x y_{1 1}, _,..., x y_n, _n (n⁼20). Найти номера двух точек, расстояние между которыми наибольшее (считать, что такая пара точек единственная).

51.       Даны вещественные числа a a_{0 1},               _,..., a₁₅. Найти коэффициенты многочле-

на (^{x a x a−} 0)( ⁻ 1)...(^{x a−} 15).

52.       Даны целые числа a a_{0 1}, _,..., a_n. Получить новую последовательность, выбросив из исходной все члены, равные max(a a_{0 1}, ,..., a_n).

53.       В последовательности a a_{0 1}, _,..., a_n поменять местами наибольший и наименьший члены.

54.       Даны целые числа a a_{0 1}, _,..., a_n. Получить новую последовательность, заменяя a_i нулями, если a_i не равно max(a a_{0 1}, ,..., a_n), и единицами в противном случае.

55.       Даны целые числа a a_{0 1}, _,..., a_2n. Получить

max(a a a a1+ 2n, 2 + 2 1n− ,..., a an + n+1).

56.       Определить число различных элементов массива X_.

57.       Заполнить массив A следующим образом:

1          2 . . .10

 11 12 . . .20

 21 22 . . .30

 . . . . . . . . . .

 91 92 . . .100

58.       Дана вещественная матрица порядка n m_{× .} Упорядочить ее строки по неубыванию их наибольших элементов.

59.       Определить, симметрична ли заданная целая квадратная матрица n-го порядка (относительно главной диагонали)

60.       Дана вещественная матрица n m^× _, все ее элементы различны. Найти скалярное произведение строки с наибольшим элементом матрицы на столбец с наименьшим элементом.

61.       Определить, является ли магическим квадратом заданная целая квадратная матрица n-го порядка (т. е. таким, где суммы элементов во всех строках и столбцах одинаковы).

62.       Дана матрица n m_{× .} Переставляя ее строки и столбцы, переместить наибольший элемент в верхний левый угол.

63.       Заполнить массив ^A следующим образом:

1          2 3 . . .10

 0 1 2 . . . 9

 0 0 1 . . . 8

 . . . . . . . . .

 0 0 0 . . . 1

64.       Получить массив ^B из массива ^A удалением n-й строки и ^k -го столбца.

65.       В заданной квадратной целочисленной матрице указать индексы всех элементов с наибольшим значением.

66.       Дана вещественная матрица n m^× _. Упорядочить ее строки по неубыванию суммы их элементов.

67.       Преобразовать массив ^S , поворачивая его вокруг центра на 90 градусов против часовой стрелки.

68.       Cедловая точка — элемент матрицы, наименьший в своей строке и одновременно наибольший в своем столбце или наоборот. Для заданной матрицы n m^× найти индексы всех ее седловых точек.

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

70.       Все элементы с наибольшим значением в данной целочисленной матрице заменить нулями.

71.       Найти номера строк квадратной целочисленной матрицы, элементы в каждой из которых одинаковы.

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

73.       Напечатать в одну строку все буквы между 'A' и 'Z', включая и эти буквы.

74.       Проверить, правильно ли в текст входят круглые скобки. Ответ ДА или

НЕТ.

75.       Удалить из текста все буквы 'b'.

76.       Удалить из текста все буквы 'k', идущие сразу за буквой 'n'.

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

78.       Подсчитать число слов в тексте, содержащих букву 'd'.

79.       Подсчитать число слов в тексте, содержащих 1 букву 'a' и 2 буквы 'b'.

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

81.       Если в заданный текст входит каждая из букв слова 'key', напечатать yes, иначе no.

82.       Напечатать букву, которая идет в тексте непосредственно за буквой 'a'.

83.       Удалить из текста все пары букв 'oo'.

84.       Напечатать все слова в тексте задом наперед.

85.       Подсчитать число слов в тексте, оканчивающихся буквой 'w'.

86.       Проверить, является ли данное слово перевертышем.

87.       Подсчитать число слов в тексте, содержащих ровно 3 буквы 'е'.

88.       Значениями литерных переменных являются цифры. Присвоить составленное из них число целой переменной.

89.       Удалить из слов в тексте все гласные буквы.

90.       Если слово нечетной длины, удалить из него среднюю букву.

91.       Рассортировать английские слова в алфавитном порядке.

92.       Подсчитать частоты вхождения букв в текст.

93.       Заменить в тексте строчные буквы прописными, а прописные строчными.

94.       Найти в тексте самое большое целое число.

95.       Определить наибольший общий делитель трех натуральных чисел.

96.       Получить число 2⁵⁰⁰, выводя его по одной цифре.

97.       Вывести таблицу зависимости от n количества целых чисел взаимно простых с n_.

98.       Даны коэффициенты многочленов P x( ), Q x( ) и число a . Вычислить P a Q a P a( + ( ) ( +1)).

99.       Три прямые заданы уравнениями. Если они попарно пересекаются и образуют треугольник, то найти его площадь.

100.    Даны координаты вершин двух треугольников. Определить, какой из них имеет наибольшую площадь.

101.    Получить число 1!+2!+...+100!, выводя его по одной цифре.

102.    Получить число 1!+2!+...100!, выводя по n цифр.

103.    Вывести таблицу зависимости от n  количества положительных делителей числа n_.

104.    Напечатать пары дружественных чисел, не превосходящих n_.

105.    Найти наименьшее общее кратное четырех заданных натуральных чисел.

106.    Даны координаты вершин треугольника и точки внутри него. Найти расстояние от этой точки до ближайшей стороны.

107.    Дано m n-мерных матриц. Выбрать из них матрицу с наименьшим следом.

108.    Заменить члены последовательности a_i величинами a_iⁱ_.

109.    Даны координаты вершин треугольника и точка. Определить, принадлежит ли эта точка треугольнику.

110.    Заменить полные квадраты в матрице их квадратными корнями, остальные элементы — нулями.

111.    Найти периметр десятиугольника, заданного координатами вершин.

112.    Для четного числа n>2 проверить гипотезу Гольдбаха.

113.    Составить функцию, заменяющую в тексте буквы их номерами по порядку в алфавите.

 

 

Лабораторные работы

 

Лабораторная работа 1. Выражения, ветвление.

1.    Определить, есть ли среди первых трех цифр из дробной части заданного положительного вещественного числа цифра 0.

2.    Определить, есть ли среди цифр заданного трехзначного числа одинаковые.

3.    Определить, равен ли квадрат заданного трехзначного числа кубу суммы цифр этого числа.

 

Лабораторная работа 2. Циклы и ветвления.

1.    Подсчитать ^k — число цифр в десятичной записи целого неотрицательного числа n_.

2.    Дано не менее трех различных натуральных чисел, за которыми следует нуль. Определить три наибольших числа среди них.

3.    Напечатать в возрастающем порядке все трехзначные числа, в десятичной записи которых нет одинаковых цифр (деления не использовать!).

 

Лабораторная работа 3. Одномерные массивы.

1.    В целочисленном массиве ^A содержится 10 чисел от 0 до 9 включительно, а в целочисленном массиве ^B — 2  целых числа от 0 до 9. Переменной x

bb^{1 2} присвоить вещественное число 0._{a a a0 1}... ₉ ^⋅10               .

2.    По массиву ^t , где указана температура каждого дня некоторого невисокосного года, определить m — название месяца с наибольшей среднемесячной температурой.

'

3.    Преобразовать массив ^X по следующему правилу ( x_k — значение ^k -го

' элемента массива после преобразования): x_k ⁼ max( )x_i при 1< <i      k.

 

Лабораторная работа 4. Двумерные массивы.

1.    Заполнить массив A по правилу: A X_ij ^{= i}_j, где массив X задан.

2.    Определить ^k — число "особых" элементов массива C_, считая элемент "особым", если он больше суммы остальных элементов своего столбца.

3.    Определить k — число различных элементов матрицы C (т. е. повторяющиеся элементы считать один раз)

 

Лабораторная работа 5. Литеры и строки.

1.    Подсчитать число слов в тексте, начинающихся и заканчивающихся одной и той же буквой.

2.    Удалить из слова повторяющиеся буквы.

3.    Подсчитать частоты длин слов в тексте.

 

Лабораторная работа 6. Функции.

1.    Получить число 2⁵⁰⁰, выводя по n цифр.

2.    Написать функцию, приводящую дробь к несократимому виду.

3.    Составить функцию сжатия исходной последовательности символов (для повторяющихся символов ввести число повторений: aaaaaa a→ (6) ).