Учебное пособие: Методические указания к выполнению контрольных работ по дисциплине "Основы программирования"

Методические указания к выполнению контрольных работ по дисциплине "Основы программирования"

Основы программирования"

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

Для выполнения контрольной работы необходимо использовать учебное пособие [1] и практикум [2] (см. список литературы).

Основные темы, которые входят в данную дисциплину:

1. Основные понятия алгоритмизации.

2. Особенности алгоритмов.

3. Форма записи алгоритмов. Блок-схема алгоритма.

4. Понятие алгоритма в терминах математической теории множеств.

5. Математические методы, используемые при анализе алгоритмов.

6. Методы доказательства корректности алгоритма.

Задания для контрольных работ

Студент должен выполнить самостоятельно задание. Номер задачи для каждого студента определяется числом i – номером варианта. Номер варианта – это номер студента в журнале. Если это число больше 15, то для оп­ределения номера задачи от числа iнужно вычесть 15 или 30.

Например, по выбору преподавателя необходимо выполнить задание 1-1 или задание 1-3.

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

В задании 1-3 необходимо найти формулу для нахождения n-го слагаемого представленного числового ряда. Доказать, что эта формула верна. Составить алгоритм нахождения суммы числового ряда с заданной точностью. Алгоритм представить в виде блок-схемы.

Список литературы

Основная:

1. Емельянов А.А., Власова Е.А., Денисов Д.В., Емельянова Н.З. Основы программирования для информатиков и инженеров: Часть 1 / Под ред. А.А. Емельянова. – М.: ММИЭИФП, 2004. – 208 с.

2. Емельянов А.А., Власова Е.А., Емельянова Н.З. Практикум по основам программирования для информатиков и инженеров / Под ред. А.А. Емельянова. – М.: ММИЭИФП, 2004. – 162 с.

3. Вирт Н. Алгоритмы и структуры данных: Пер. с англ. – М.: Мир, 1989. – 360 с.

4. Кнут Д. Искусство программирования для ЭВМ: в 3т. – М.: Мир, 1978.

Дополнительная:

5. Зелковиц М., Шоу А., Гэннон Дж. Принципы разработки программного обеспечения: Пер. с англ. – М.: Мир, 1982. – 386 с.

6. Лэнгсам И., Огенстайн М., Тененбаум А. Структуры данных для персо­нальных ЭВМ. – М.: Мир, 1989.

7. Сибуя М., Ямамото Т. Алгоритмы обработки данных. – М.: Мир, 1986.

8. Фокс Дж. Программное обеспечение и его разработка: Пер. с англ. – М.: Мир, 1985. – 368 с.

УЧЕБНАЯ ПРОГРАММА

Цель дисциплины, её место в учебном процессе

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

Задачи: составлять программы на алгоритмическом языке С++, знать принципы работы в среде программирования VisualC ++, работать с массивами, структурами, списками, осуществлять отладку программ в среде программирования VisualC ++.

Сфера профессионального использования

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

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

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

Для изучения данной дисциплины студент должен знать:

· математика;

· информатика (школьный курс);

· основы программирования.

Содержание дисциплины

Тема 1 . Обзор языка С++

Структура программы на языке С++. Среда программирования Visual C++. Переменные и константы. Оператор цикла. Работа с массивами. Массивы символов. Функции.

Тема 2. Типы операции и выражения

Имена переменных. Типы и размеры данных. Константы. Описания Арифметические операции. Операции отношения и логические операции. Преобразование типов. Операции увеличения и уменьшения. Побитовые логические операции. Операции и выражения присваивания. Условные выражения. Старшинство и порядок вычисления.

Тема 3.Поток управления

Операторы и блоки. Конструкция if-else. Конструкция else-if. Переключатель switch. Циклы while и for. Цикл do-while. Оператор break. Оператор continue. Оператор goto и метки.

Тема 4.Функции и структура программ

Основные сведения. Функции, возвращающие нецелые значения. Аргументы функций. Внешние переменные. Правила, определяющие область действия. Статические переменные. Регистровые переменные. Рекурсия. Препроцессор языка «C». Заголовочные файлы.

Тема 5. Указатели и массивы

Указатели и адреса. Указатели и аргументы функций. Указатели и массивы. Адресная арифметика. Указатели символов и функции. Многомерные массивы. Массивы указателей; указатели указателей. Указатели и многомерные массивы. Командная строка аргументов. Указатели на функции.

Тема 6. Структуры

Основные сведения. Структуры и функции. Массивы структур. Указатели на структуры. Структуры, ссылающиеся на себя; двоичные деревья. Поиск в таблице. Битовые поля. Объединения.

Тема 7. Динамическое распределение памяти. Работа со списками

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

Тема8. Ввод, вывод и форматные преобразования данных

Стандартный ввод и вывод. Форматный ввод и вывод. Форматные преобразования в памяти. Доступ к файлам. Обработка ошибок. Ввод и вывод строк. Проверка вида символов и преобразования. Обращение к системе. Управление памятью.

Учебно-методическая и научная литература

3.1. Емельянов А.А., Власова Е.А., Денисов Д.В., Емельянова Н.З. Основы программирования для информатиков и инженеров: Часть 1 / Под ред. А.А. Емельянова. – М.: ММИЭИФП, 2004. – 208 с.

3.2. Березин Б.И., Березин С.Б. Начальный курс С и С++. – М.: ДИАЛОГ-МИФИ, 1996. – 288 с.

3.3. Джехани Н. Программирование на языке Си. - М.: Радио и связь, 1988.3.4. Керниган Б., Ритчи Д. Язык программирования Си.\ Пер. с англ., 3-е изд. испр. - СПб.: «Невский Диалект», 2001. – 352 с.

3.5. Крупник А. Изучаем С++. – СПб.:Питер, 2003. – 251 с.

3.6.Культин Н.Б. С/С++ в задачах и примерах. – СПб.: БХВ-Петербург, 2003. – 288 с.

3.7. Подбельский В.В. Язык Си++. - М.: Финансы и статистика, 1995.

3.8. Уэйт М., Прата С., Мартин Д. Язык.Си. Руководство для начинающих: Пер. с англ. - М.: Мир, 1988. - 512 с.

УЧЕБНОЕ ПОСОБИЕ

В первой части книги в систематической форме излагаются основы теории алгоритмизации и практики программирования на языке «С».

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

В следующих двух частях будут изложены объектно-ориентированное программирование на С++ и программирование Windows-приложений на С/С++.

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

СОДЕРЖАНИЕ

ПРЕДИСЛОВИЕ . 6

ВВЕДЕНИЕ 8

В.1. Том Сойер рисует на заборе . 8

В.2. Сид выполняет команды .. 9

В.3. Программисты .. 10

В.4. Язык С++ . 11

1. ТЕОРЕТИЧЕСКИЕ ОСНОВЫ АЛГОРИТМИЗАЦИИ И .. 12

ПРОГРАММИРОВАНИЯ .. 12

1.1. Основные понятия алгоритмизации . 12

1.2. Особенности алгоритмов. Программы .. 16

1.3. Математическая индукция . 23

1.4. Обобщенный алгоритм Евклида . 26

2. ПЕРВЫЕ ШАГИ «НАЧИНАЮЩИХ» . 33

2.1. Давайте начнем, пожалуй! 34

2.2. Переменные и арифметика . 37

2.3. Оператор for 42

2.4. Символические константы .. 43

2.5. Набор полезных программ . 44

2.6. Массивы .. 52

2.7. Функции . 55

2.8. Аргументы: вызов по значению .. 57

2.9. Массивы символов . 58

2.10. Область действия: внешние переменные . 61

2.11. Некоторые оптимистичные выводы .. 64

3. ТИПЫ, ОПЕРАЦИИ И ВЫРАЖЕНИЯ .. 66

3.1. Имена переменных . 66

3.2. Типы и размеры данных . 66

3.3. Константы .. 68

3.4. Описания . 70

3.5. Арифметические операции . 71

3.6. Операции отношения и логические операции . 72

3.7. Преобразование типов . 73

3.8. Операции увеличения и уменьшения . 77

3.9. Побитовые логические операции . 80

3.10. Операции и выражения присваивания . 82

3.11. Условные выражения . 83

3.12. Старшинство и порядок вычисления . 85

4. ПОТОК УПРАВЛЕНИЯ .. 88

4.1. Операторы и блоки . 88

4.2. Конструкция if-else . 88

4.3. Конструкция else-if 90

4.4. Переключатель switch . 92

4.5. Циклы while и for 94

4.6. Цикл do-while . 98

4.7. Оператор break . 99

4.8. Оператор continue . 100

4.9. Оператор goto и метки . 101

5. ФУНКЦИИ И СТРУКТУРА ПРОГРАММ .. 103

5.1. Основные сведения . 103

5.2. Функции, возвращающие нецелые значения . 107

5.3. Еще об аргументах функций . 110

5.4. Внешние переменные . 111

5.5. Правила, определяющие область действия . 116

5.6. Статические переменные . 120

5.8. Блочная структура . 122

5.9. Инициализация . 123

5.10. Рекурсия . 126

5.11. Препроцессор языка «C» . 128

5.12. Заголовочные файлы .. 130

6. УКАЗАТЕЛИ И МАССИВЫ .. 132

6.1. Указатели и адреса . 132

6.2. Указатели и аргументы функций . 134

6.3. Указатели и массивы .. 136

6.4. Адресная арифметика . 139

6.5. Указатели символов и функции . 143

6.6. Указатели – не целые . 146

6.7. Многомерные массивы .. 147

6.8. Массивы указателей; указатели указателей . 150

6.9. Инициализация массивов указателей . 154

6.10. Указатели и многомерные массивы .. 155

6.11. Командная строка аргументов . 156

6.12. Указатели на функции . 160

7. СТРУКТУРЫ .. 164

7.1. Основные сведения . 164

7.2. Структуры и функции . 166

7.3. Массивы структур . 169

7.4. Указатели на структуры .. 174

7.5. Структуры, ссылающиеся на себя; двоичные деревья . 176

7.6. Поиск в таблице . 181

7.7. Битовые поля . 184

7.8. Объединения . 186

7.9. Определение «нового» типа данных . 188

8. ДИНАМИЧЕСКОЕ РАСПРЕДЕЛЕНИЕ ПАМЯТИ. 190

РАБОТА СО СПИСКАМИ .. 190

8.1. Динамическое выделение и освобождение памяти . 190

8.2. Понятие списка; основные виды списковых образований . 191

8.3. Создание и удаление списка . 194

8.4. Программы позиционирования для работы со списками . 197

9. ВВОД, ВЫВОД И ФОРМАТНЫЕ ПРЕОБРАЗОВАНИЯ .. 200

ДАННЫХ .. 200

9.1. Обращение к стандартной библиотеке . 200

9.3. Форматный вывод: функция printf 203

9.4. Форматный ввод: функция scanf 205

9.5. Форматные преобразования в памяти . 208

9.6. Доступ к файлам . 209

9.7. Обработка ошибок: stderr и exit 212

9.8. Ввод и вывод строк . 213

9.9. Несколько разнообразных функций . 215

ЛИТЕРАТУРА .. 217

ПРЕДИСЛОВИЕ

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

Практика показывает, что в последнее время большинство таких работ проводится с применением языка «С++» (по-русски произносится как «си плюс плюс»), который в настоящее время является одним из самых популярных языков программирования. Это универсальный язык, для которого характерны экономичность выражения, современный поток управления и структуры данных, богатый набор операторов. Язык «C++» не является ни языком «очень высокого уровня», ни «большим» языком, и не предназначается для некоторой специальной области применения, но отсутствие ограничений и общность языка делают его более удобным и эффективным для многих задач, чем языки, предположительно более мощные. По разнообразному количеству средств, предоставляемых программистам, его можно считать одним из самых эффективных языков, но, иногда, – и самых эффектных, и самых сложных. Все перечисленные обстоятельства объясняют, почему нами этот язык выбран в качестве базового.

В язык «C++» в качестве основного, базового средства включен более старый язык «C» (по-русски произносится как «си», поэтому некоторые авторы пишут его название как «Си»), который первоначально предназначался для написания операционной системы U nix ; он был разработан и реализован Деннисом Ричи. Операционные системы U nix и Windows , компиляторы с языка «C++» и большинство прикладных программных систем сейчас создаются на языке «C++». Этот язык, однако, не связан с какими-либо определенными аппаратными средствами или системами, и на нем легко писать программы, которые можно пропускать без изменений на любом компьютере или ЭВМ, имеющей C-компилятор.

Целью первого учебного курса «Основы алгоритмизации и программирования» является обучение основам программирования. В это время студент, не будучи асом алгоритмизации, не сможет по достоинству оценить возможности объектно-ориентированного программирования, предоставляемые «C++». Поэтому сначала обучение ведется на классическом языке «С» (он входит в состав любой версии «С++) с минимальным привлечением дополнительных средств, имеющихся в «C++».

В результате второго учебного курса студенты, получившие изрядный опыт по описанию алгоритмов средствами традиционного языка «C», совершенствуют свое мастерство, и средствами объектно-ориентированного программирования языка «C++» делают программы более эффективными и компактными.

Третий учебный курс «Программирование приложений для Windows » предназначен для развития навыков реализации реальных проектов, создания Windows-приложений (Windows applications). При этом используются все ранее изученные средства. В соответствии с этими тремя курсами учебно-методическое обеспечение также разделено на 3 части.

Мы не претендуем на оригинальность изложения теоретического материала по программированию. При создании данного учебного пособия нами использовались хрестоматийным образом данные из книг, пособий и справочников известных авторов: М.И. Болски, Б. Кернигана, Д. Кнута, Д. Дж. Круглински, А.Б. Крупника, Д. Ритчи, Г. Шилдта.

В качестве основного методического приема используется прагматический подход, изложенный в знаменитой книге Б. Кернигана и Д. Ритчи «Язык программирования Си», – это обучение на «живых» примерах.

Однако имеется и оригинальный материал. Например, глава 8 «Динамическое распределение памяти. Работа со списками» (в первой части книги), а также весь практикум по программированию.

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

Редактор, п рофессор А.А. Емельянов

ВВЕДЕНИЕ ^*

В.1. Том Сойер рисует на заборе

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

Марк Твен, «Приключения Тома Сойера »

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

1 1 0 1 0 0 1 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0

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

2 ´ 2 ´ 2 ´ 2 ´ 2 ´ 2 ´ 2 ´ 2 = 2⁸ = 256 способами.

Иными словами, в восьми битах можно уместить 256 разных чисел (от 0 до 255, например), а этого вполне достаточно, чтобы закодировать любую букву. Поскольку «забор» в нашем примере состоит из 24 досок (цифр), он пригоден для того, чтобы закодировать сразу три буквы.

Какие же буквы показаны на заборе? Ответ на этот вопрос зависит от договоренности: какому числу соответствует та или иная буква. Первое число (11010010) на заборе равно (в привычном нам десятичном представлении) 210, второе (11001110) – это 206, третье (11001100) равно 204. И вся эта тройка соответствует в операционной системе Windows , скорее всего установленной у вас на компьютере, слову «ТОМ».

В.2. Сид выполняет команды

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

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

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

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

Представим себе, что перед выполнением программы в пятнадцатой ячейке хранится число 10. Раз оно больше нуля, Сид перейдет к двадцатому байту, выполнит команды, записанные в ячейках с номерами 21¸30, и, если содержимое 15-й ячейки не изменилось, 31-й байт вновь отошлет его назад, и так он будет крутиться, пока хватит сил. Если же команды, хранящиеся в байтах 21¸30, после многих пробежек Сида запишут нуль в ячейку 15, тот вместо двадцатого байта перейдет к следующей команде, начало которой хранится в ячейке 32. Иными словами, Сид будет выполнять команды последовательно, одну за другой, пока ему не прикажут перейти к иной ячейке, и после очередной пробежки вдоль забора он снова начнет выполнять команды последовательно. И так будет продолжаться до тех пор, пока он не наткнется на команду «Стоп».

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

В.3. Программисты

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

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

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

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

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

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

Поэтому вслед за ассемблерами были изобретены компиляторы – программы, которые воспринимали язык программирования, понятный человеку и не зависящий от конкретного процессора. Чтобы такое стало возможным, нужно было один раз «помучиться» и написать (на языке ассемблера) компилятор для данного процессора, а затем уже пользоваться языком, понятным и человеку, и компилятору, или, как говорят, языком высокого уровня. К числу таких языков относятся Pascal, Fortran, С и, конечно же, C++.

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

В.4. Язык С++

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

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

Разработка программы на языке C++ обычно начинается с тщательного анализа задачи, выделения в ней объектов и разработки соответствующих интерфейсов. Далее каждый объект можно создавать независимо от других. Остальные программисты, занятые использованием самих объектов, вовсе не обязаны ждать, пока их создадут. Им достаточно знать только интерфейс этих пока не существующих объектов и спокойно писать свою часть программы. Это значит, что C++ позволяет разбить сложную задачу на множество мелких и наладить промышленное, почти конвейерное, производство больших программ.

1. ТЕОРЕТИЧЕСКИЕ ОСНОВЫ АЛГОРИТМИЗАЦИИ И

ПРОГРАММИРОВАНИЯ

1.1. Основные понятия алгоритмизации

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

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

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

Августа Ада, графиня Лавлейс (1844 )

Основоположницей программирования считают Августу Аду – дочь великого английского поэта Дж. Г. Байрона. В 19 веке в Англии впервые появилось настоящее арифметическое устройство – аналитическая машина Бэббиджа: с регистрами, сумматором и другими атрибутами, присущими процессору современного компьютера. Программы для такого устройства расписывались на бумаге. Каждая операция совершалась поворотом особой ручки или нажатием рычага такой машины. Большинство идей и принципов программирования для аналитической машины Бэббиджа было рассмотрено в книге Августы Ады^* «Комментарии». Позднее появился особый вид деятельности – программирование, а в последствии возникла профессия программиста.

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

Историки-математики обнаружили истинное происхождение этого слова: оно берет начало от имени автора знаменитого персидского учебника по математике, Абу Абд Аллах Мухаммед ибн Муса аль-Хорезми (ок. 825 г.). Аль-Хорезми написал знаменитую книгу «Книга о восстановлении и противопоставлении» (перс. Китаб аль-джебр валь-мукабала ). От названия этой книги, которая была посвящена решению линейных и квадратных уравнений, произошло еще одно слово – «алгебра».

В старинном немецком математическом словаре Vollstandiges mathematisches Lexicon (Лейпциг, 1747) дается следующее толкосание латинского слова algorithmus : «Этот термин включает в себя понятие о четырех типах арифметических операций, а именно: о сложении, умножении, вычитании и делении». Латинское выражение algorithmus infinitesimalis в то время использовалось для определения способов выполнения действий с бесконечно малыми величинами, открытых великим математиком Лейбницем.

Пример 1-1 . Алгоритм Евклида.

Приблизительно через 100 лет после появления аналитической машины Бэббиджа была создана первая электронная вычислительная машина – специально для выполнения атомного проекта в Лос-Аламосе (США). В это время (конец 40-х – начало 50-х годов 19 века) слово «алгоритм» чаще всего ассоциировалось с алгоритмом Евклида, который представляет собой процесс нахождения наибольшего общего делителя двух чисел. Этот алгоритм далее будем называть «алгоритмом Е».

Сущность алгоритма Е : даны два целых положительных числа т и п. Требуется найти их наибольший общий делитель, т.е. наибольшее целое положительное число, которое нацело делит оба числа т и п . Алгоритм состоит из трех элементарных типовых действий: Е1, Е2 и Е3 (рис. 1.1).

Действие Е1. Нахождение остатка.

Разделим m на п , и пусть остаток от деления будет равен r , где .

Действие Е2. Сравнение с нулем.

Если r = 0, то выполнение алгоритма прекращается; п – это искомое значение.

Действие Е3. Замещение.

Присвоить m ¬ n , n ¬ r и вернуться к шагу E1. ô

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

Каждому рассматриваемому алгоритму присваивается идентифицирующая буква (в предыдущем примере использовалась буква Е), а шагам алгоритма – эта же буква в сочетании с числом (El, Е2, ЕЗ).

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

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

Стрелка «¬», используемая на шаге ЕЗ, обозначает важнейшую операцию замещения, которую иногда называют присвоением или подстановкой: запись m ¬ n указывает, что значение переменной т замещается текущим значением переменной п . В начале работы алгоритма Е, т и п – это заданные первоначальные значения, но по окончании его работы эти переменные будут иметь, вообще говоря, совершенно другие значения.

Стрелка используется для того, чтобы отличать операцию замещения от отношения равенства. Мы не будем говорить: «Установим т = п », а, вероятно, спросим: «Действительно ли т = п ?». Знак «=» обозначает условие, которое можно проверить, а знак «¬» – действие, которое можно выполнить. Операция увеличение п на единицу обозначается через п ¬ п +1 и читается так: «п замещается значением п +1» или «п принимает значение п +1». Вообще говоря, запись «переменная ¬ формула» означает, что формула будет вычислена на основании текущих значений всех входящих в нее переменных, а полученный результат будет присвоен переменной, стоящей слева от стрелки (таким образом, вычисленный по формуле результат заменит собой предыдущее значение переменной слева). Лица, не имеющие достаточного опыта программирования, иногда говорят, что «п переходит в п+ 1» и для обозначения операции увеличения п на единицу используют запись п ® п+ 1. Такая система обозначений и формулировок противоречит стандартным соглашениям и может привести только к путанице, поэтому ее следует избегать.

Обратите внимание, что на шаге ЕЗ очень важен порядок действий. Действительно, две записи:

1) «присвоить m ¬ n , n ¬ r »

и

2) «присвоить n ¬ r , m ¬ n »

– это совсем не одно и то же.

Из второй записи следует, что предыдущее значение n будет потеряно до того, как его смогут присвоить т. На самом деле эквивалентом второй записи будет «присвоить n ¬ r , т ¬ r ». Когда нескольким переменным присваивается одно и то же значение, в одном выражении можно использовать несколько стрелок. Так, например, операцию « n ¬ r , т ¬ r » можно записать как « n ¬ т ¬r ».

Операцию взаимного обмена значениями двух переменных можно записать так: «Обмен т « n ». Ее можно записать и с помощью новой переменной t следующим образом: "Присвоить t ¬ т , т ¬ п , п ¬ t .

Выполнение алгоритма начинается с шага, имеющего наименьший номер (обычно это шаг 1). Затем последовательно выполняются следующие шаги, если нет каких-либо указаний, нарушающих естественный порядок выполнения. На шаге ЕЗ указание «Вернуться к шагу Е1» явным образом определяет порядок вычислений. На шаге Е2 действию предшествует условие «Если r = 0» и если r # 0, то оставшаяся часть предложения не применяется и нет указаний на выполнение в этом случае каких-либо действий. Конечно, мы могли бы добавить дополнительное предложение «Если r # 0, то перейти к шагу ЕЗ», но это совершенно излишне.

Жирная вертикальная черточка «ô », помещенная в конце шага ЕЗ, обозначает окончание алгоритма и продолжение текста.

Итак, мы обсудили практически все соглашения об обозначениях, которые используются в алгоритмах, приведенных в книге. Осталось выяснить только, как обозначать величины с индексами (или «подстрочными» индексами), которые являются элементами упорядоченного массива. Предположим, у нас есть п величин: v ₁ , v ₂ , …, v_n . Для обозначения j -го элемента вместо записи v_j часто используется запись v [j ]. Аналогично массив иногда предпочитают обозначать как а [i , j ], вместо того чтобы использовать два подстрочных индекса, как в записи a_ij . Иногда для обозначения переменных используются имена, состоящие из нескольких букв, обычно прописных. Например, TEMP может быть именем переменной, использующейся для временного хранения вычисленного значения, a PRIME [К] может обозначать k -е простое число, и т.д.

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

Итак, давайте в качестве примера разберем алгоритм Е. Предположим, что m = 119 и n = 544.

Начнем с шага Е1. Деление m на n в этом случае выполняется просто, даже очень просто, так как частное равно нулю, а остаток – это 119. Таким образом, r ¬ 119. Переходим к шагу Е2. Поскольку r # 0, на этом шаге никакие действия не выполняются.

На шаге ЕЗ присваиваем т ¬ 544, п ¬ 119. Очевидно, что если первоначально m < п , то частное на шаге Е1 всегда оказывается равным нулю и в ходе выполнения алгоритма всегда происходит взаимный обмен значений переменных тип, хотя и таким громоздким способом. Поэтому можно добавить дополнительный шаг:

Действие Е0. Гарантировать, что m > п .

Если m < п , то выполнить взаимный обмен т « n .

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

Вернемся к шагу Е1. Находим, что

.

Поэтому r ¬ 68. В результате на шаге Е2 снова не выполняются никакие действия, а на шаге ЕЗ присваиваем т ¬ 119, п ¬ 68.

В следующих циклах сначала получаем r ¬ 51 и т ¬ 68, п ¬ 51, а затем: r ¬ 17 и т ¬ 51, п ¬ 17.

Наконец, в результате деления 51 на 17 получаем: r ¬ 0. Таким образом, на шаге Е2 выполнение алгоритма прекращается. Наибольший общий делитель 119 и 544 равен 17.

Вот что такое алгоритм.

1.2. Особенности алгоритмов. Программы

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

1. Конечность. Алгоритм всегда должен заканчиваться после выполнения конечного числа шагов. Алгоритм Е удовлетворяет этому условию, потому что после шага Е1 значение r меньше, чем п. Поэтому если r # 0, то в следующем цикле на шаге Е1 значение п уменьшается. Убывающая последовательность положительных целых чисел имеет конечное число членов, поэтому шаг Е1 может выполняться только конечное число раз для любого первоначально заданного значения п. Но нужно иметь в виду, что количество шагов может быть сколь угодно большим; выбор слишком больших значений тип приведет к тому, что шаг Е1 будет выполняться более миллиона раз.

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

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

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

Рассмотрим в качестве примера алгоритм Е. Применительно к шагу Е1 критерий определенности означает, что читатель обязан точно понимать, что значит разделить т на п и что такое остаток. Но в действительности нет никакого общепринятого соглашения по поводу того, что это означает, если m и п не являются целыми положительными числами. Каким будет остаток от деления -8 на -p ? Что понимать под остатком от деления 59/13 на нуль? Поэтому в данном случае критерий определенности означает следующее: мы должны быть уверены, что в каждом случае выполнения шага Е1 значениями т и п всегда будут целые положительные числа. Если сначала по предположению это верно, то после шага Е1 r – это целое неотрицательное число; при условии перехода к шагу ЕЗ оно является также ненулевым. Таким образом, поставленное требование выполнено и т и п – это действительно целые положительные числа.

3. Ввод . Алгоритм имеет некоторое (возможно, равное нулю) число входных данных, т.е. величин, которые задаются до начала его работы или определяются динамически во время его работы. Эти входные данные берутся из определенного набора объектов. Например, в алгоритме Е есть два входных значения, а именно m и п , которые принадлежат множеству целых положительных чисел.

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

Можно легко доказать, что это число действительно является наибольшим общим делителем. После шага Е1 имеем:

,

где q – некоторое целое число.

Если r = 0, то т кратно п и, очевидно, в этом случае n – наибольший общий делитель для m и п.

Если r # 0, то любой делитель обоих чисел m и п должен быть также делителем для

,

а любой делитель для п и r – также делителем для:

.

Таким образом, множество делителей чисел {т , п } совпадает с множеством делителей чисел {п , r }. Следовательно, пары чисел {т , п } и {п , r } имеют один и тот же наибольший общий делитель. Таким образом, шаг ЕЗ не изменяет ответа исходной задачи.

5. Эффективность. Алгоритм обычно считается эффективным, если все его операторы достаточно просты для того, чтобы их можно было точно выполнить в течение конечного промежутка времени с помощью карандаша и бумаги. В алгоритме Е используются только следующие операции: деление одного целого положительного числа на другое, сравнение с нулем и присвоение одной переменной значения другой. Эти операции являются эффективными, так как целые числа можно представить на бумаге с помощью конечного числа знаков и так как существует по меньшей мере один способ деления одного целого числа на другое – «алгоритм деления». Но те же самые операции были бы неэффективными, если бы они выполнялись над действительными числами, представляющими собой бесконечные десятичные дроби, либо над величинами, выражающими длины физических отрезков прямой, которые нельзя измерить абсолютно точно. Приведем еще один пример неэффективного шага: «Если 4 – это наибольшее целое n , при котором существует решение уравнения wⁿ + xⁿ + yⁿ = zⁿ для целых положительных чисел w , x , y и z , то перейти к шагу Е4». Подобная операция не может считаться эффективной до тех пор, пока кто-либо не разработает алгоритм, позволяющий определить, действительно ли 4 является наибольшим целым числом с требуемым свойством.

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

· входные данные (такие, например, как яйца, мука и т.д.),

· выходные данные (обед «на скорую руку» и т.п.),

· но хорошо известно, что ему не хватает определенности.

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

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

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

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

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

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

Прежде всего необходимо убедиться в том, что задача имеет смысл, поскольку нам предстоит найти среднее при бесконечно большом количестве значений т. Но совершенно очевидно, что после первого выполнения шага Е1 значение будет иметь только остаток от деления т на п. Поэтому все, что мы должны сделать для нахождения значения Т_п , – это испытать алгоритм для m = 1, m = 2, .. ., m = п , подсчитать суммарное число выполнений шага Е1 и разделить его на п.

А теперь рассмотрим еще один важный вопрос, касающийся поведения Т_п как функции от п : можно ли ее аппроксимировать, например, функцией

или ?

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

,

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

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

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

Формально определим метод вычислений как четверку ( Q , I , W, f ), где Q – это множество, содержащее подмножества I и W, а f – функция, переводящая множество Q в себя. Кроме того, f оставляет неподвижными точки множества W, т.е. f (q ) равно q для всех элементов q из множества W. Эти четыре элемента Q , I , W и f представляют соответственно состояния вычисления, ввод, вывод и правило вычислений. Каждое входное значение х из множества I определяет вычисляемую последовательность x ₀ , x ₁ , x ₂ , … следующим образом:

x ₀ = х и x_{k +1} = f (x_k ) для k ³ 0. (1.1)

Говорят, что вычисляемая последовательность заканчивается через k шагов, если k – это наименьшее целое число, для которого x_k принадлежит W, и что она дает выходное значение x_k для заданного х. (Заметим, что если x_k принадлежит W, то и x_{k +1} принадлежит W, так как в этом случае x_{k +1} = x_k ). Некоторые вычисляемые последовательности могут никогда не заканчиваться, но алгоритм – это метод вычислений, который заканчивается через конечное число шагов для всех х из I .

Например, алгоритм Е в этих терминах можно формализовать следующим образом. Пусть элементами множества Q будут все величины (n ), все упорядоченные пары (m ,n ) и все упорядоченные четверки (m ,n ,r ,1), (m ,n ,r ,2) и (m ,n ,p ,3), где m , n и р – это целые положительные числа, а r – неотрицательное целое число. Пусть I – это подмножество всех пар (m ,n ), а W – подмножество всех величин (n ). Определим функцию f следующим образом:

(1.2)

Соответствие между данной записью и алгоритмом Е очевидно.

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

Пусть А – это ограниченное множество букв, а L – множество всех строк, определенных на множестве А (т.е. множество всех упорядоченных последовательностей x ₀ , x ₁ , x ₂ , …, где n ³0 и x_j принадлежит А для 1 £ j £ п. Идея заключается в следующем: закодировать состояния вычисления таким образом, чтобы они были представлены строками из множества L.

Теперь пусть N – целое неотрицательное число, а Q – множество всех пар (s, j ), где s принадлежит L, a j – целое число, 0 £ j £ N.

Пусть I – подмножество пар из Q , для которых j = 0, а W – подмножество пар из Q , для которых j = N. Если q и s – строки из L, то мы будем говорить, что q входит в s, если s имеет вид aqw, где a и w – некоторые строки.

И в завершение определим функцию f с помощью строк q_j , f_j и целых чисел a_j , b_j , 0 £ j £ N , следующим образом:

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

Упражнение 1.1 . В тексте показано, как взаимно заменить значения переменных типе помощью символа замены, а именно – полагая t ¬ m , m ¬ п , п ¬ t . Покажите, как в результате ряда замен можно преобразовать четверку переменных (a ,b ,c ,d ) в (b ,c ,d ,a ). Другими словами, новое значение переменной а должно стать равным первоначальному значению 6 и т.д. Постарайтесь выполнить преобразование с помощью минимального числа замен.

Упражнение 1.2 . Докажите, что в начале выполнения шага El m всегда больше п , за исключением, возможно, только первого случая выполнения этого шага.

Упражнение 1.3 . Измените алгоритм Е (из соображений эффективности) таким образом, чтобы исключить из него все тривиальные операции замены типа « m ¬ n ». Запишите этот новый алгоритм в стиле алгоритма Е и назовите его алгоритмом F.

Упражнение 1.4 . Чему равен наибольший общий делитель чисел 2 166 и 6 099?

Упражнение 1.5 . Чему равно T ₅ (среднее число случаев выполнения шага Е1 при n = 5)?

Упражнение 1.6 . Пусть т известно, а n – любое целое положительное число. Пусть U_m – среднее число случаев выполнения шага Е1 из алгоритма Е. Покажите, что U_m четко определено. Существует ли какая-либо связь между U_m и T_m ?

Упражнение 1.7 . Придумайте эффективный формальный алгоритм вычисления наибольшего общего делителя целых положительных чисел т и п , определив соответствующим образом q_j , f_j , a_j , b_j (как в формулах (1.3)). Пусть входные данные представлены строкой a^m bⁿ , т.е. за а , взятым т раз, следует b , взятое n раз. Постарайтесь найти самое простое решение, насколько это возможно.

Указание : воспользуйтесь алгоритмом Е, но вместо деления на шаге El присвойте r ¬ | т - п |, п ¬ min(m , п ).

1.3. Математическая индукция

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

Пусть Р (п ) – это некоторое утверждение, касающееся целого числа п , например:

«n умножить на (n + 3) – четное число» или «если п ³ 10, то 2ⁿ > n ³ ». Предположим, нам нужно доказать, что утверждение Р(п) верно для всех положительных целых чисел п. Существует важный метод доказательства этого факта, который состоит в следующем:

(а) Доказать, что Р(1) верно.

(b) Доказать, что «если Р (1), Р (2), ..., Р (п ) справедливы, то Р (п+ 1) также справедливо»; это доказательство должно иметь силу для любого целого положительного числа п .

Пример 1-2 . Нечетные числа в сумме дают квадрат.

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

В общем виде эти равенства можно записать следующим образом:

1 + 3 + ××× + (2n – 1) = n ² . (1.5)

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

(а) «Р(1) верно, так как 1 = 1² »

(b) «Если все утверждения Р(1), ..., Р(п ) справедливы, то, в частности, верно и Р(п ); следовательно, выполняется соотношение (1.5). Добавляя к обеим частям этого уравнения 2п + 1, получаем:

1 + 3 + ××× + (2п - 1) + (2п + 1) = п ² + 2 п + 1 = (п + 1)² .

Таким образом, утверждение Р(п + 1) также справедливо».

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

Алгоритм I (Построить доказательство ). Для заданного целого положительного числа n этот алгоритм
(рис. 1.2) выдаст доказательство того, что утверждение Р (п ) верно.

Действие I 1. Доказать Р(1).

Присвоить k ¬ 1 и в соответствии с п. (а) выдать доказательство утверждения Р(1).

Действие I 2. k = n ?

Если k = n , закончить выполнение алгоритма; требуемое доказательство выдано.

Действие I 3. Доказать P (k + 1).

Согласно п. (b) выдать доказательство того, что «Если все утверждения Р (1), ..., P (k ) справедливы, то P (k + 1) также справедливо». Вывести фразу «Мы уже доказали, что если утверждения Р (1 ), ..., P (k ) верны, то верно и P (k +1)».

Действие I 4. Увеличить k . Увеличить k на 1 и перейти к шагу I 2. ô Поскольку этот алгоритм выдает доказательство утверждения Р (п ) для любого заданного п, метод доказательства, сформулированный в пп. (а) и (b), логически обоснован. Он называется доказательством методом математической индукции.

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

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

1 + 1 + 1 + 1 + 1 = 2 + 1 + 1 + 1 = 2 + 2 + 1 = 3 + 1 + 1 = 3 + 2 = 4 + 1 = 5 ,

то р(5) = 7. На самом деле установить первые пять значений функции р (п ) довольно легко:

р (1) = 1, р (2) = 2, р (3)=3, р (4) = 5, р (5) = 7.

Замечание . На этом основании мы могли бы предварительно сформулировать по индукции некорректное предположение о том, что последовательность р (2), р (3), ... пробегает множество простых чисел. Для проверки данной гипотезы продолжаем вычисления и находим р(6) = 11. – Ура! – Это подтверждает наше предположение. Но, к сожалению, оказывается, что р (7) равно 15. Увы, все идет насмарку, и приходится начинать сначала. Из математической литературы известно, что значения р (n ) отличаются довольно сложным поведением.

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

Есть еще одно доказательство соотношения (1.5). На рис. 1.3 для п = 6 показано, что п ² клеток разбиты на группы 1 + 3 + (2n – 1) клеток. Но, в конечном счете, этот рисунок можно считать «доказательством» только в случае, если мы покажем, что данное построение можно выполнить для любого п . А это, в сущности, и будет доказательством по индукции.

В нашем доказательстве соотношения (1.5) был использован только частный случай (b); мы просто показали, что из справедливости Р (п ) следует справедливость Р (п+ 1). Это очень важный случай, который встречается довольно часто, но в следующем примере будут проиллюстрированы более широкие возможности метода математической индукции.

Пример 1-3 . Числа Фибоначчи.

Определим последовательность Фибоначчи F ₀ , F ₁ , F ₂ , ... , F ₂ с помощью такого правила: F ₀ = 0, F ₁ = 1, а каждый последующий член равен сумме двух предыдущих. Таким образом, первые члены этой последовательности выглядят так: 0, 1, 1, 2, 3, 5, 8, 13, ... . Далее введем обозначение:

. (1.6)

Докажем, что неравенство справедливо для всех целых положительных чисел n . Назовем эту формулу утверждением P (n ).

Если n = 1, то F ₁ = 1 = f⁰ = f ^{n – 1} , поэтому п. (а) выполнен.

Переходя к п. (б), заметим сначала, что Р (2) также справедливо, поскольку F ₁ = 1 < 1.6 < f¹ = f ^{2 – 1} . А теперь, если все Р (1), Р (2), ..., Р (п ) справедливы и п > 1, то мы знаем, в частности, что справедливы Р (п – 1) и Р (п ). Поэтому и . Складывая данные неравенства, получаем:

. (1.7)

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

1 + f = f² . (1.8)

Подставив (1.8) в (1.7), получим , а это и есть утверждение Р (п+ 1). Таким образом, п. (b) выполнен, и формула (1.6) доказана методом математической индукции. Обратите внимание, что п. (b) мы выполняли двумя различными способами: непосредственно доказали Р (п + 1) при п= 1 и использовали индуктивный метод при п > 1. Это было необходимо, так как при п= 1 ссылка на Р (п – 1) = Р (0) была бы незаконной.

1.4. Обобщенный алгоритм Евклида

Пример 1-4 . Математическую индукцию можно использовать также для доказательства фактов, касающихся алгоритмов. Давайте рассмотрим следующее обобщение алгоритма Евклида.

Алгоритм Е (обобщенный алгоритм Евклида ). Даны два целых положительных числа m и b . Требуется найти их наибольший общий делитель d и два целых числа а и b , таких, что am + bn = d .

Действие E l. Инициализация.

Присвоить а ' ¬ b ¬ 1, а ¬ b ' ¬ 0, с ¬ т , d ¬ n .

Действие Е 2. Деление.

Пусть q и r – это частное и остаток от деления с на d соответственно. Тогда

с = qd + r , где 0 £ r < d .

Действие Е З. Остаток – это нуль?

Если r = 0, то выполнение алгоритма прекращается; в этом случае имеем

am + bn = d ,

как и требовалось.

Действие Е 4. Повторение цикла.

Присвоить

с ¬ d , d ¬ r , t ¬ а ', а ' ¬ а , а ¬ (t – qa ), t ¬ b ' , b ' ¬ b , b ¬ (t – qb )

и вернуться к шагу Е2.

Если изъять из алгоритма переменные а , b , а ' и b ' и использовать m и n в качестве вспомогательных переменных с и d , то получим старый алгоритм Е (см. параграф 1.1). В новой версии алгоритма выполняется немного больше вычислений, так как необходимо определить коэффициенты a и b . Предположим, что m = 1769 и n = 551. Тогда последовательно (после шага Е 2) имеем:

Проверяя полученные результаты, убеждаемся в том, что все правильно, так как 5 ´ 1769 - 16 ´ 551 = 8845 - 8816 = 29, т.е. мы получили наибольший общий делитель чисел 1769 и 551.

Теперь нужно доказать, что рассматриваемый алгоритм работает правильно при любых т и п. Для этого попробуем применить метод математической индукции к следующему утверждению Р (п ): «Алгоритм Е дает правильное решение для заданного n и всех целых m ». Но провести подобное доказательство не так-то просто, поэтому нужно доказать сначала несколько дополнительных фактов. После некоторого изучения проблемы выясняется, что нужно доказать какой-то факт, связанный с коэффициентами а , b , а ' и b '. Этот факт заключается в том, что равенства

а'т + b 'п = с , am + bn = d (1.9)

верны в каждом случае выполнения шага Е2. Данные равенства можно доказать непосредственно, заметив, что они безусловно справедливы после первого выполнения шага Е2, и что шаг Е4 не меняет это положение вещей (см. упражнение 1.17).

Теперь мы готовы индукцией по п доказать, что алгоритм Е работает правильно. Если т кратно п , то очевидно, что алгоритм работает правильно, поскольку его работа заканчивается на шаге ЕЗ в первом же цикле и мы получаем верный результат. Это происходит всегда, когда n = 1. Поэтому остается провести доказательство для случая, когда п > 1 и т не является кратным п . В такой ситуации в первом цикле осуществляется переход к шагу Е4 и выполняются операции присвоения с ¬ п , d ¬ r . И так как r < п , по индукции можно предположить, что окончательное значение d – наибольший общий делитель чисел п и r . Из доказательства, приведенного в параграфе 1.2. следует, что пары {т ,п } и {п ,r } имеют одинаковые наибольшие общие делители и, в частности, один и тот же наибольший общий делитель. Значит, d – это наибольший общий делитель чисел m и n и согласно (1.9) am + bn = d .

Фраза, которая в приведенном выше доказательстве выделена курсивом, является иллюстрацией того общепринятого условного языка, который так часто используется в доказательствах методом индукции. Например, выполняя п. (b), вместо того чтобы сказать «Теперь предположим, что утверждения Р (1), Р (2), ..., Р (п ) справедливы, и на этом основании докажем справедливость утверждения Р (п + 1)», мы будем говорить просто «Теперь докажем утверждение Р (п ); по индукции мы можем предположить, что P (k ) верно для любого 1 £ k < n » .

Если хорошо вдуматься и посмотреть на все вышесказанное с несколько иной точки зрения, то перед нами предстанет общий метод доказательства корректности любого алгоритма. Идея состоит в том, чтобы взять блок-схему некоторого алгоритма и к каждой стрелке добавить примечание о текущем состоянии дел в тот момент, который соответствует стрелке. На рис. 1.4 эти примечания (мы их будем называть также утверждениями) обозначены через A l, A 2, ..., А 6. В утверждении А 1 даются первоначальные предположения о входных данных алгоритма, а в А 4 формулируется положение о том, что мы хотим доказать по поводу выходных значений а , b и d .

Если доказать утверждение (1.10) для каждого блока, то все примечания к стрелкам будут верны в любом случае выполнения алгоритма. Теперь мы можем применить индукцию по числу шагов, т. е. по числу стрелок в блок-схеме. При прохождении первой стрелки (той, которая выходит из блока «Начало») утверждение А 1 верно, поскольку мы всегда исходим из предположения, что входные значения удовлетворяют заданным условиям. Таким образом, утверждение, которое соответствует первой стрелке, верно. Если утверждение, которое соответствует n -й стрелке, верно, то согласно (1.10) утверждение, которое соответствует (n + 1)-й стрелке, тоже верно.

Исходя из этого общего метода доказательство правильности заданного алгоритма, очевидно, сводится к нахождению правильных утверждений, соответствующих стрелкам блок-схемы. Как только данное начальное препятствие будет преодолено, останется лишь рутинная работа, связанная с доказательством того, что каждое утверждение на входе в блок влечет за собой утверждение на выходе из блока. В действительности после того как вы придумаете самые трудные из этих утверждений, найти все остальные уже не составит труда. Скажем, если даны утверждения А 1, А 4 и А 6, уже понятно, какими должны быть утверждения А 2, А З и А 5. В нашем примере самых больших творческих усилий потребует доказательство утверждения А 6; все остальное, в принципе, должно получиться автоматически.

Этот подход к доказательству корректности алгоритма имеет и другой, еще более важный аспект: он отражает способ нашего понимания алгоритма. Нужно проверять работу алгоритма на примере одного-двух наборов входных данных. И это не случайно, так как пробная «прогонка» алгоритма поможет вам мысленно сформулировать утверждения, соответствующие стрелкам на блок-схеме. Уверенность в корректности алгоритма приходит только тогда, когда мысленно сформулированы все утверждения, приведенные на рис. 1.4. Отсюда следуют важные психологические выводы, касающиеся передачи алгоритма от одного лица к другому. Речь идет о том, что, объясняя алгоритм кому-либо другому, всегда следует явно формулировать основные утверждения, которые трудно получить автоматически. Например, в случае алгоритма Е нужно обязательно упомянуть утверждение А 6.

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

(Например, заметим, что алгоритм Е по-прежнему имеет смысл, если его переменные m , n , с , d и r принимают значения типа

,

где параметры и и v – целые числа^* .

Переменные q , а , b , а ', b ' должны по-прежнему принимать целые значения. Если, например, на вход подать значения и , то на выходе будет получен «наибольший общий делитель» и коэффициенты a = +2, b = – 1. Даже при таком расширении исходных предположений доказательства утверждений от А 1 до А 6 остаются в силе. Следовательно, на любом этапе выполнения этой процедуры все утверждения верны. Но если начать со значений m = 1 и , то вычисления никогда не закончатся (см. упражнение 1.15). Следовательно, из доказательства утверждений А 1¸А 6 еще не следует, что алгоритм конечен.)

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

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

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

Упражнение 1.8 . Объясните, как можно модифицировать идею доказательства методом математической индукции в случае, если некоторое утверждение Р (п ) нужно доказать для всех неотрицательных целых чисел, т.е. для n = 0, 1, 2, ... , а не для n = 1, 2, 3, ... .

Упражнение 1.9 . Найдите ошибку в следующем доказательстве.

«Теорема . Пусть a – любое положительное число. Для всех целых положительных чисел п имеем .

Доказательство. Если п = 1, то . По индукции, предполагая, что теорема верна для 1, 2, ..., п , имеем

;

следовательно, теорема верна также для n + 1.»

Упражнение 1.9 . Следующее доказательство по индукции выглядит корректным, но по непонятной причине для п = 6 левая часть уравнения дает , а правая дает . В чем же ошибка? «Теорема .

.

Доказательство. Используем индукцию по п. Для п = 1 доказательство очевидно: 3/2 – 1/п = 1/(1 ´ 2). Предполагая, что теорема верна для п , имеем:

.

Упражнение 1.10 . Докажите, что числа Фибоначчи удовлетворяют не только соотношению (1.6), но и неравенству .

Упражнение 1.11 . Простое число – это целое число, большее единицы, которое делится только на 1 и на само себя. Используя данное определение и метод математической индукции, докажите, что любое целое число, большее единицы, можно записать как произведение одного или нескольких простых чисел. (Для удобства будем считать, что простое число – это «произведение» одного простого числа, т.е. его самого.)

Упражнение 1.12 . Докажите по индукции, что если 0 < a < 1, то .

Упражнение 1.13 . Докажите по индукции, что если п > 10, то .

Упражнение 1.14 . Найдите и докажите простую формулу для следующей суммы:

.

Упражнение 1.15 . Покажите, как можно обобщить алгоритм Е, чтобы, как было указано в тексте, для него допускались входные значения вида , где и и v – это целые числа, и вычисления по-прежнему выполнялись элементарным образом (т.е. не выражая иррациональное число бесконечной десятичной дробью). Докажите, что при т = 1 и выполнение алгоритма никогда не закончится.

Упражнение 1.16 . Обобщите алгоритм Е, введя новую переменную Т и добавив в начале каждого шага операцию Т ¬ Т+ 1. (Таким образом, переменная Т – это счетчик выполненных шагов.)

Предположим, что первоначальное значение Т равно нулю, поэтому утверждение А 1 на рис. 1.4 примет вид m > 0, n > 0, Т = 0. Аналогично к А 2 следует добавить дополнительное условие Т = 1. Покажите, как добавить к утверждениям дополнительные условия таким образом, чтобы из любого утверждения А 1, А 2, ..., А 6 следовало, что Т < 3n , и чтобы можно было провести доказательство по индукции. (Следовательно, вычисления должны закончиться максимум через 3n шагов.)

Упражнение 1.17 . Докажите, что если соотношения (1.9) справедливы непосредственно перед выполнением шага Е4, то они верны и после его выполнения.

2. ПЕРВЫЕ ШАГИ «НАЧИНАЮЩИХ»

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

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

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

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

2.1. Давайте начнем, пожалуй!

Единственный способ освоить новый язык программирования – писать на нем программы. Первая программа, которая должна быть написана, – одна для всех языков: напечатать слова: «Здравствуй, Мир!».

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

Пример 2-1 . Программа печати «Здравствуй, Мир !» на языке «C» имеет вид:

main()

{

printf("Здравствуй, Мир !\n");

}

Как пропустить эту программу, зависит от используемой вами системы. Чаще всего первые опыты с «C» осуществляют в одной из двух операционных систем: Unix или Windows XP .

1. В операционной системе Unix вы должны завести исходную программу в файле, имя которого оканчивается суффиксом «.с» , например, Hello.c , и затем скомпилировать ее по команде cc Hello.c .

Если вы не допустили какой-либо небрежности, такой как пропуск символа или неправильное написание, компиляция пройдет без сообщений и будет создан исполняемый файл с именем а.out . Прогон его по команде а.out приведет к выводу слов «Здравствуй, Мир !». – Это самый примитивный способ создания выполняемой программы в Unix .

Замечание : на самом деле Unix не всегда поддерживает национальные алфавиты в консольном режиме, в т.ч. «кириллицу». Поэтому можно увидеть вместо фразы на русском языке какие-то символы и значки, не имеющие смысла.

2. В операционной системе Windows XP будем использовать оболочку Visual Studio и среду программирования Visual C++. Предположим, что вы хотите на диске c:\ в папке Консоль01 создать проект Test01, в рамках которого будет работать наша программа, причем нужно обеспечить внешнее сходство с операционной системой Unix . В папке c:\Консоль01\ создадим файл Hello.cpp, причем суффикс «.сpp» говорит о том, что мы работаем в среде C++.

Далее в основном меню Visual Studio создадим новый проект в режиме «Консольное приложение» (рис. 1.1.). Этот режим соответствует рассмотренному способу создания программы в операционной системе Unix :

File ® New ® Project ® Win32 ® Console Application .

Проект Test01 расположим (Location) расположим в той же папке

c:\Консоль01\ . После этого автоматически будет создана вложенная папка Test01 и более вложенная – папка Debug.

Далее нужно выйти в режим просмотра файлов (File View) и включить в проект (Add Files to Folder) единственный файл Hello.cpp. После этого структура проекта примет вид, показанный на рис 2.1.

Через главное меню нужно выполнить компиляцию и сборку выполняемой программы Test01.exe:

Build ® Rebuild All .

Эта программа появится в папке c:\Консоль01\Test01\Debug. Далее нужно войти в эту папку, используя Проводник , и выполнить программу Test01.exe с помощью команды Test01.exe > a.txt .

Результат можно посмотреть помощью Блокнота Notepad операционной системы Windows (рис. 2.2.) или стандартного редактора Visual Studio в файле a.txt.

Замечание : в других системах соответствующие правила будут иными. Проконсультируйтесь с местным «авторитетом».

Упражнение 2-1. Пропустите эту программу на вашей системе. Попробуйте не включать различные части программы и посмотрите какие сообщения об ошибках вы при этом получите.

Теперь некоторые пояснения к самой программе. Любая «C»-программа, каков бы ни был ее размер, состоит из одной или более «функций», указывающих фактические операции компьютера, которые должны быть выполнены. Функции в языке «C» подобны функциям и подпрограммам ФОРТРАНА и процедурам PL/1, ПАСКАЛЯ и т.д. В нашем примере такой функцией является main. Обычно вы можете давать функциям любые имена по вашему усмотрению, но main – это особое имя; выполнение вашей программы начинается сначала с функции main. Это означает, что каждая программа должна в каком-то месте содержать функцию с именем main. Для выполнения определенных действий функция main обычно обращается к другим функциям, часть из которых находится в той же самой программе, а часть – в библиотеках, содержащих ранее написанные функции.

Одним способом обмена данными между функциями является передача посредством аргументов. Круглые скобки, следующие за именем функции, заключают в себе список аргументов; здесь main – функция без аргументов, что указывается как ( ). Операторы, составляющие функцию, заключаются в фигурные скобки { }, которые аналогичны DO-END в PL/1 или BEGIN-END в АЛГОЛЕ, ПАСКАЛЕ и т.д. Обращение к функции осуществляется указанием ее имени, за которым следует заключенный в круглые скобки список аргументов. здесь нет никаких операторов CALL, как в ФОРТРАНЕ или PL/1. Круглые скобки должны присутствовать и в том случае, когда функция не имеет аргументов.

Строка

printf("Здравствуй, Мир !\n");

является обращением к функции, которое вызывает функцию с именем printf и аргуметом ("Здравствуй, Мир !\n". Функция printf является библиотечной функцией, которая выдает выходные данные на терминал (если только не указано какое-то другое место назначения). В данном случае печатается строка символов, являющаяся аргументом функции.

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

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

printf("Здравствуй, Мир !\n

");

то «C»-компилятор будет печатать злорадные диагностические сообщения о недостающих кавычках.

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

main()

{

printf("Здравствуй, ");

printf("Мир !");

printf("\n");

}

Подчеркнем, что \n представляет только один символ. Условные (или «эскайп») последовательности, подобные \n , дают общий и допускающий расширение механизм для представления трудных для печати или невидимых символов. Среди прочих символов в языке «C» предусмотрены следующие: \t – для табуляции, \b – для возврата на одну позицию (символ «забоя»), \" – для двойной кавычки, \\ – для самой обратной косой черты.

Упражнение 2-2 . Проведите эксперименты для того, чтобы узнать что произойдет, если в строке, являющейся аргументом функции printf, будет содержаться \x, где x – некоторый символ, не входящий в вышеприведенный список.

2.2. Переменные и арифметика

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

.

Теперь сама программа:

// Напечатать таблицу Фаренгейт-Цельсий

main()

{

int lower, upper, step;

float fahr, celsius;

lower = 0; // Нижний предел таблицы

upper = 300; // Верхний предел таблицы

step = 20; // Размер шага

fahr = lower;

while (fahr <= upper)

{

celsius = (5.0/9.0) * (fahr -32.0);

printf("%4.0f %6.1f\n", fahr, celsius);

fahr = fahr + step;

}

}

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

// Напечатать таблицу Фаренгейт-Цельсий

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

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

int lower, upper, step;

float fahr, celsius;

Тип int означает, что все переменные списка целые; тип float предназначен для чисел с плавающей точкой, т.е. для чисел, которые могут иметь дробную часть. Точность как int, так и float зависит от конкретной машины, на которой вы работаете. На PDP-11, например, тип int соответствует 16-битовому числу со знаком, т.е. числу, лежащему между -32768 и +32767. Число типа float – это 32-битовое число, имеющее около семи значащих цифр и лежащее в диапазоне от 1.0е–38 до 1.0е+38. В главе 3 приводится список размеров для других машин.

В языке «C» предусмотрено несколько других основных типов данных, кроме int и float:

· char символ (один байт);

· short короткое целое;

· long длинное целое;

· double плавающее с двойной точностью.

Размеры этих объектов тоже машинно-независимы; детали приведены в главе 3. Имеются также массивы, структуры и объединения этих основных типов, указатели на них и функции, которые их возвращают; со всеми ними мы встретимся в свое время.

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

lower = 0;

upper = 300;

step = 20;

fahr = lower;

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

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

while (fahr <= upper)

{

... // Тело оператора while

}

проверяется условие в круглых скобках. Если оно истинно (fahr меньше или равно upper), то выполняется тело цикла – все операторы, заключенные в фигурные скобки { }. Затем вновь проверяется это условие и, если оно истинно, опять выполняется тело цикла. Если же условие не выполняется (fahr превосходит upper ), цикл заканчивается и происходит переход к выполнению оператора, следующего за оператором цикла. Так как в настоящей программе нет никаких последующих операторов, то выполнение программы завершается.

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

while (i < j)

i = 2 * i;

В обоих случаях операторы, управляемые оператором while, сдвинуты на одну табуляцию, чтобы вы могли с первого взгляда видеть, какие операторы находятся внутри цикла. Такой сдвиг подчеркивает логическую структуру программы. Хотя в языке «C» допускается совершенно произвольное расположение операторов в строке, подходящий сдвиг и использование пробелов значительно облегчают чтение программ. Мы рекомендуем писать только один оператор на строке и (обычно) оставлять пробелы вокруг операторов. Расположение фигурных скобок менее существенно; мы выбрали один из нескольких популярных стилей. Выберите подходящий для вас стиль и затем используйте его последовательно.

Основная часть работы выполняется в теле цикла. Температура по Цельсию вычисляется и присваивается переменной celsius оператором

celsius = (5.0/9.0) * (fahr-32.0);

причина использования выражения 5,0 / 9,0 вместо выглядящего проще 5/9 заключается в том, что в языке «C», как и во многих других языках, при делении целых происходит усечение, состоящее в отбрасывании дробной части результата. Таким образом, результат операции 5/9 равен нулю, и, конечно, в этом случае все температуры оказались бы равными нулю. Десятичная точка в константе указывает, что она имеет тип с плавающей точкой, так что, как мы и хотели, 5.0 / 9.0 равно 0.5555... .

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

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

fahr = lower

и проверка

while (fahr <= upper)

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

Этот же пример сообщает чуть больше о том, как работает printf. Функция printf фактически является универсальной функцией форматных преобразований, которая будет полностью описана в главе 9. Ее первым аргументом является строка символов, которая должна быть напечатана, причем каждый знак % указывает, куда должен подставляться каждый из остальных аргументов /второй, третий, .../ и в какой форме он должен печататься. Например, в операторе:

printf("%4.0f %6.1f\n", fahr, celsius);

спецификация преобразования %4.0f говорит, что число с плавающей точкой должно быть напечатано в поле шириной по крайней мере в четыре символа без цифр после десятичной точки; спецификация %6.1f описывает другое число, которое должно занимать по крайней мере шесть позиций с одной цифрой после десятичной точки, аналогично спецификациям F6.1 в ФОРТРАНЕ. Различные части спецификации могут быть опущены: спецификация %6f говорит, что число будет шириной по крайней мере в шесть символов; спецификация %2 требует двух позиций после десятичной точки, но ширина при этом не ограничивается; спецификация %f говорит только о том, что нужно напечатать число с плавающей точкой. Функция printf также распознает следующие спецификации: %d – для десятичного целого, %о – для восьмеричного числа, %х – для шестнадцатиричного, %с – для символа, %s – для символьной строки и %% - для самого символа %.

Каждая конструкция с символом % в первом аргументе функции printf сочетается с соответствующим вторым, третьим, и т.д. Аргументами; они должны согласовываться по числу и типу; в противном случае вы получите бессмысленные результаты.

Между прочим, функция printf не является частью языка «C»; в самом языке «C» не определены операции ввода-вывода. Нет ничего таинственного и в функции printf; это – просто полезная функция, являющаяся частью стандартной библиотеки подпрограмм, которая обычно доступна «C»-программам. Чтобы сосредоточиться на самом языке, мы не будем подробно останавливаться на операциях ввода-вывода до главы 9. В частности, мы до тех пор отложим форматный ввод. Если вам надо ввести числа – прочитайте описание функции scanf в главе 9, раздел 9.4. Функция scanf во многом сходна с printf, но она считывает входные данные, а не печатает выходные.

Упражнение 2-3 . Преобразуйте программу перевода температур таким образом, чтобы она печатала заголовок к таблице.

Упражнение 2-4 . Напишите программы печати соответствующей таблицы перехода от градусов Цельсия к градусам Фаренгейта.

2.3. Оператор for

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

main() // Напечатать таблицу Фаренгейт-Цельсий

{

int fahr;

for (fahr = 0; fahr <= 300; fahr = fahr + 20)

printf("%4d %6.1f\n",fahr,(5.0/9.0)*(fahr-32.0));

}

Эта программа выдает те же самые результаты, но выглядит безусловно по-другому. Главное изменение – исключение большинства переменных; осталась только переменная fahr , причем типа int (это сделано для того, чтобы продемонстрировать преобразование %d в функции printf). Нижняя и верхняя границы и размер щага появляются только как константы в операторе for , который сам является новой конструкцией, а выражение, вычисляющее температуру по Цельсию, входит теперь в виде третьего аргумента функции printf, а не в виде отдельного оператора присваивания.

Последнее изменение является примером вполне общего правила языка «C» – в любом контексте, в котором допускается использование значения переменной некоторого типа, вы можете использовать выражение этого типа. Так как третий аргумент функции printf должен иметь значение с плавающей точкой, чтобы соответствовать спецификации %6.1f, то в этом месте может встретиться любое выражение плавающего типа.

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

fahr = 0

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

fahr <= 300

это условие проверяется и, если оно истинно, то выполняется тело цикла (в данном случае только функция printf ). Затем выполняется шаг реинициализации:

fahr =fahr + 20 ,

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

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

Упражнение 2-5 . Модифицируйте программу перевода температур таким образом, чтобы она печатала таблицу в обратном порядке, т.е. От 300 градусов до 0.

2.4. Символические константы

Последнее замечание, прежде чем мы навсегда оставим программу перевода температур. Прятать «магические числа», такие как 300 и 20, внутрь программы – это неудачная практика; они дают мало информации тем, кто, возможно, должен будет разбираться в этой программе позднее, и их трудно изменять систематическим образом. К счастью в языке «C» предусмотрены два способа, позволяющие избежать таких «магических чисел».

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

#define lower 0 // Нижний предел таблицы

#define upper 300 // Верхний предел таблицы

#define step 20 // Размер шага

main () // Напечатать таблицу Фаренгейт-Цельсий

{

int fahr;

for (fahr =lower; fahr <= upper; fahr =fahr + step)

printf("%4d %6.1f\n",fahr,(5.0/9.0)*(fahr-32));

}

Величины lower, upper и step являются константами и поэтому они не указываются в описаниях. Символические имена обычно пишут прописными буквами, чтобы их было легко отличить от написанных строчными буквами имен переменных.

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

Второй способ . После появления стандарта ANSI на объектно-ориентированное программирование в языке «C++» появился новый спецификатор для задания констант – const. В «C++» он может использоваться вместо конструкции #define.

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

const int true = 1;

const double pl = 4*atan(1.0);

const int size = 5000;

char const *name1 = "Ричард С. Вайнер";

const char *name2 = "Лэвис Дж. Пинсон";

Четвертое объявление указывает, что name – это константный указатель на char, т.е. это адрес не может быть изменен.

Последнее объявление указывает, что строка «Лэвис Дж. Пинсон» является константой. Указатель name2 константой не является и может быть затем изменен.

2.5. Набор полезных программ

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

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

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

Функция putchar(c) является дополнением к getchar: в результате обращения putchar(c) содержимое переменной c выдается на некоторый выходной носитель, обычно опять на терминал. Обращение к функциям putchar и printf могут перемежаться; выдача будет появляться в том порядке, в котором происходят обращения.

Как и функция printf, функции getchar и putchar не содержат ничего экстраординарного. Они не входят в состав языка «C», но к ним всегда можно обратиться.

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

Пример 2-4 . Простейшим примером может служить программа посимвольного копирования вводного файла в выводной. Общая схема имеет вид:

ввести символ;

while (символ не является признаком конца файла)

{

вывести только что прочитанный символ;

ввести новый символ;

}

Программа, написанная на языке «C», выглядит следующим образом:

main() // Копировать ввод-вывод; 1-я версия

{

int c;

c = getchar();

while (c != eof)

{

putchar(c);

c = getchar();

}

}

Оператор отношения != означает «не равно».

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

#define eof -1 ,

либо

#define eof 0 .

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

Мы также описали переменную c как int , а не char , с тем чтобы она могла хранить значение, возвращаемое getchar. Как мы увидим в главе 3, эта величина действительно int, так как она должна быть в состоянии в дополнение ко всем возможным символам представлять и eof.

Программистом, имеющим опыт работы на «C», программа копирования была бы написана более сжато. В языке «C» любое присваивание, такое как

c = getchar()

может быть использовано в выражении; его значение – просто значение, присваиваемое левой части.

Пример 2-5 . Если присваивание символа переменной c поместить внутрь проверочной части оператора while , то программа копирования файла запишется в виде:

main() // Копировать ввод-вывод; 2-я версия

{

int c;

while ((c = getchar()) != eof)

putchar(c);

}

Программа извлекает символ, присваивает его переменной c, и затем проверяет, не является ли этот символ признаком конца файла. Если нет – выполняется тело оператора while, выводящее этот символ. Затем цикл while повторяется. Когда, наконец, будет достигнут конец файла ввода, оператор while завершается, а вместе с ним заканчивается выполнение и функции main .

В этой версии централизуется ввод – в программе только одно обращение к функции getchar – и ужимается программа. Вложение присваивания в проверяемое условие – это одно из тех мест языка «C», которое приводит к значительному сокращению программ. Однако, на этом пути можно увлечься и начать писать недоступные для понимания программы. Эту тенденцию мы будем пытаться сдерживать.

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

c = getchar() != eof

эквивалентен оператору

c = (getchar() != eof)

Это, вопреки нашему желанию, приведет к тому, что c будет принимать значение 0 или 1 в зависимости от того, натолкнется или нет getchar на признак конца файла. Подробнее об этом будет сказано в главе 3.

2.5.3. Подсчет символов.

Пример 2-6 . Следующая программа подсчитывает число символов; она представляет собой небольшое развитие программы копирования.

main() // Подсчет вводимых символов

{

long nc;

nc = 0;

while (getchar() != eof )

++nc;

printf("%1d\n", nc);

}

Оператор

++nc;

демонстрирует новую операцию, ++, которая означает увеличение на единицу. Вы могли бы написать nc=nc+1, но ++nc более кратко и зачастую более эффективно. Имеется соответствующая операция -- уменьшение на единицу. Операции ++ и -- могут быть либо префиксными (++nc), либо постфиксными (nc++); эти две формы, как будет показано в главе 3, имеют в выражениях различные значения, но как ++nc, так и nc++ увеличивают nc. Пока мы будем придерживаться префиксных операций.

Программа подсчета символов накапливает их количество в переменной типа long, а не int . На PDP-11 максимальное значение равно 32767, и если описать счетчик как int, то он будет переполняться даже при сравнительно малом файле ввода; на языке «C» для HONEYWELL и IBM типы long и int являются синонимами и имеют значительно больший размер. Спецификация преобразования %1d указывает printf, что соответствующий аргумент является целым типа long. Чтобы справиться с еще большими числами, вы можете использовать тип double (float двойной длины).

Пример 2-7 . Используем оператор for вместо while с тем, чтобы проиллюстрировать другой способ записи цикла.

main() // Подсчет вводимых символов

{

double nc;

for (nc = 0; getchar() != eof; ++nc)

;

printf("%.0f\n", nc);

}

Функция printf использует спецификацию %f как для float, так и для double. Спецификация %.0f подавляет печать несуществующей дробной части. Тело оператора цикла for здесь пусто, так как вся работа выполняется в проверочной и реинициализационной частях. Но грамматические правила языка «C» требуют, чтобы оператор for имел тело. Изолированная точка с запятой, соответствуюшая пустому оператору, появляется здесь, чтобы удовлетворить этому требованию. Мы выделили ее на отдельную строку, чтобы сделать ее более заметной.

Прежде чем мы распростимся с программой подсчета символов, отметим, что если файл ввода не содержит никаких символов, то условие в while или for не выполнится при самом первом обращении к getchar , и, следовательно, программа выдаст нуль, т.е. Правильный ответ. Это важное замечание. Одним из приятных свойств операторов while и for является то, что они проверяют условие в начале цикла, т.е. До выполнения тела. Если делать ничего не надо, то ничего не будет сделано, даже если это означает, что тело цикла никогда не будет выполняться. программы должны действовать разумно, когда они обращаются с файлами типа «никаких символов». Операторы while и for помогают обеспечить правильное поведение программ при граничных значениях проверяемых условий.

2.5.4. Подсчет строк.

Пример 2-8 . Напишем программу подсчета количества строк в файле ввода. Предполагается, что строки ввода заканчиваются символом новой строки \n, скрупулезно добавленным к каждой выписанной строке.

main() // Подсчет вводимых строк

{

int c,nl;

nl = 0;

while ((c = getchar()) != eof)

if (c =='\n')

++nl;

printf("%d\n", nl);

}

Тело while теперь содержит оператор if , который в свою очередь управляет оператором увеличения ++nl. Оператор if проверяет заключенное в круглые скобки условие и, если оно истинно, выполняет следующий за ним оператор (или группу операторов, заключенных в фигурные скобки). Мы опять использовали сдвиг вправо, чтобы показать, что чем управляет.

Удвоенный знак равенства == является обозначением в языке «C» для «равно» (аналогично .EQ. в ФОРТРАНЕ). Этот символ введен для того, чтобы отличать проверку на равенство от одиночного =, используемого при присваивании. Поскольку в типичных «C»-программах знак присваивания встречается примерно в два раза чаще, чем проверка на равенство, то естественно, чтобы знак оператора был вполовину короче.

Любой отдельный символ может быть записан внутри одиночных кавычек, и при этом ему соответствует значение, равное численному значению этого символа в машинном наборе символов; это называется символьной константой. Так, например, 'A' - символьная константа; ее значение в наборе символов ASCII (американский стандартный код для обмена информацией) равно 65, внутреннему представлению символа A. Конечно, 'A' предпочтительнее, чем 65: его смысл очевиден и он не зависит от конкретного машинного набора символов.

Условные последовательности, используемые в символьных строках, также занимают законное место среди символьных констант. Так в проверках и арифметических выражениях '\n' представляет значение символа новой строки. Вы должны твердо уяснить, что '\n' – отдельный символ, который в выражениях эквивалентен одиночному целому; с другой стороны "\n" – это символьная строка, которая содержит только один символ. Вопрос о сопоставлении строк и символов обсуждается в главе 3.

Упражнение 2-6 . Напишите программу для подсчета пробелов, табуляций и новых строк.

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

Упражнение 2-8 . Напишите программу, копирующую вводимые символы в выходной поток с заменой символа табуляции /t и символа забоя \b на символ обратной косой черты \\ . Это сделает видимыми все символы табуляции и забоя.

2.5.5. Подсчет слов.

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

#define yes 1

#define no 0

main() // Подсчет строк, слов и символов

{

int c, nl, nw, inword;

inword = no;

nl = nw = nc = 0;

while((c = getchar()) != eof)

{

++nc;

if (c == '\n')

++nl;

if (c==' ' || c=='\n' || c=='\t')

inword = no;

else if (inword == no)

{

inword = yes;

++nw;

}

}

printf("%d %d %d\n", nl, nw, nc);

}

Каждый раз, когда программа встречает первый символ слова, она увеличивает счетчик числа слов на единицу. Переменная inword следит за тем, находится ли программа в настоящий момент внутри слова или нет; сначала этой переменной присваивается «не в слове», чему соответствует значение no. Мы предпочитаем символические константы yes и no литерным значениям 1 и 0, потому что они делают программу более удобной для чтения. Конечно, в такой крошечной программе, как эта, это не приводит к заметной разнице, но в больших программах увеличение ясности вполне стоит тех скромных дополнительных усилий, которых требует следование этому принципу с самого начала. Вы также обнаружите, что существенные изменения гораздо легче вносить в те программы, где числа фигурируют только в качестве символьных констант.

Строка:

nl = nw = nc = 0;

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

nc = (nl = (nw = 0));

операция || означает OR (логическое «или») , так что строка:

if( c==' ' || c=='\n' || c=='\t')

говорит «если в символьной переменной с – пробел, или символ новой строки, или табуляция ...» (условная последовательность \t является изображением символа табуляции).

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

Этот пример также демонстрирует оператор else языка «C», который указывает то действие, которое должно выполняться, если условие, содержащееся в операторе if, окажется ложным. Общая форма такова:

if (выражение)

оператор-1;

else

оператор-2;

Выполняется один и только один из двух операторов, связанных с конструкцией if-else.

Если выражение истинно, то выполняется оператор-1; если нет – выполняется оператор-2. Фактически каждый оператор может быть довольно сложным. В программе подсчета слов оператор, следующий за else , является опертором if, который управляет двумя операторами в фигурных скобках.

Упражнение 2-9 . Как бы вы стали проверять программу подсчета слов? Kакие имеются ограничения?

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

Упражнение 2-11 . Переделайте программу подсчета слов, используя лучшее определение «слова»; считайте, например словом последовательность букв, цифр и апострофов, начинающуюся с буквы.

2.6. Массивы

Пример 2-10 . Давайте напишем программу подсчета числа появлений каждой цифры, символов пустых промежутков (пробел, табуляции, новая строка) и всех остальных символов. Конечно, такая задача несколько искусственна, но она позволит нам проиллюстрировать в одной программе сразу несколько аспектов языка «C».

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

// Подсчет всех цифр,

// промежутков (пробел, табуляции, новая строка)

// и всех остальных символов

main()

{

int c, i, nwhite, nother;

int ndigit[10];

nwhite = nother = 0;

for (i = 0; i < 10; ++i)

ndigit[i] = 0;

while ((c = getchar()) != eof)

if (c >= '0' && c <= '9')

++ndigit[c-'0'];

else if(c== ' ' || c== '\n' || c== '\t')

++nwhite;

else

++nother;

printf("digits =");

for (i = 0; i < 10; ++i)

printf(" %d", ndigit[i]);

printf("\nwhite space = %d, other = %d\n",

nwhite, nother);

}

Описание:

int ndigit[10];

объявляет, что ndigit является массивом из десяти целых. В языке «C» индексы массива всегда начинаются с нуля (а не с 1, как в ФОРТРАНЕ или PL/1/, так что элементами массива являются:

ndigit[0], ndigit[1], ..., ndigit[9].

Эта особенность отражена в циклах for , которые инициализируют и печатают массив.

Индекс может быть любым целым выражением, которое, конечно, может включать целые переменные, такие как I , и целые константы.

Эта конкретная программа сильно опирается на свойства символьного представления цифр. Так, например, в программе проверка:

if( c >= '0' && c <= '9')...

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

c - '0' .

Такой способ работает только в том случае, если значения символьных констант '0', '1' и т.д. Положительны, расположены в порядке возрастания и нет ничего, кроме цифр, между константами '0' и '9'. К счастью, это верно для всех общепринятых наборов символов.

По определению перед проведением арифметических операций, вовлекающих переменные типа char и int, все они преобразуются к типу int, Tак что в арифметических выражениях переменные типа CHAR по существу идентичны переменным типа int. Это вполне естественно и удобно. Например:

c - '0'

- это целое выражение со значением между 0 и 9 в соответствии с тем, какой символ от '0' до '9' хранится в переменной c, и, следовательно, оно является подходящим индексом для массива ndigit.

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

if (c >= '0' && c <= '9')

++ndigit[c-'0'];

else if(c == ' ' || c == '\n' || c == '\t')

++nwhite;

else

++nother;

Конструкция

if (условие)

оператор-1;

else if (условие)

оператор-2;

else

оператор-3;

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

Программа просто движется сверху вниз до тех пор, пока не удовлетворится какое-нибудь условие; тогда выполняется соответствующий «оператор»^*) , и вся конструкция завершается.

Если ни одно из условий не удовлетворяется, то выполняется «оператор», стоящий после заключительного else, если оно присутствует. Если последнее else и соответствующий «оператор» опущены (как в программе подсчета слов), то никаких действий не производится. Между начальным if и конечным else может помещаться произвольное количество групп:

else if (условие)

оператор .

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

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

Упражнение 2-12 . Напишите программу, печатающую гистограмму длин слов из файла ввода. Самое легкое – это начертить гистограмму горизонтально; вертикальная ориентация требует больших усилий.

2.7. Функции

В языке «C» функции эквивалентны подпрограммам или функциям в ФОРТРАНЕ или процедурам в PL/1, ПАСКАЛЕ и т.д. Функции дают удобный способ заключения некоторой части вычислений в черный ящик, который в дальнейшем можно использовать, не интересуясь его внутренним содержанием. Использование функций является фактически единственным способом справиться с потенциальной сложностью больших программ. Если функции организованы должным образом, то можно игнорировать то, как делается работа; достаточно знание того, что делается. Язык «C» разработан таким образом, чтобы сделать использование функций легким, удобным и эффективным. Вам будут часто встречаться функции длиной всего в несколько строчек, вызываемые только один раз, и они используются только потому, что это проясняет некоторую часть программы.

До сих пор мы использовали только предоставленные нам функции типа printf, getchar и putchar; теперь пора написать несколько наших собственных. так как в «C» нет операции возведения в степень, подобной операции ** в ФОРТРАНЕ или PL/1.

Давайте проиллюстрируем механику определения функции на примере функции power(m,n), возводящей целое m в целую положительную степень n. Так значение power(2,5) равно 32. Конечно, эта функция не выполняет всей работы операции **, поскольку она действует только с положительными степенями небольших чисел, но лучше не создавать дополнительных затруднений, смешивая несколько различных вопросов.

Пример 2-11 . Ниже приводится функция power и использующая ее основная программа, так что вы можете видеть целиком всю структуру.

main() // Испытание функции возведения в степень

{

int i;

for(i = 0; i < 10; ++i)

printf("%d %d %d\n",i,power(2,i),power(-3,i));

}

power(int x, int n) // Возведение x в степень n, n>0

{

int i, p;

p = 1;

for (i =1; i <= n; ++i)

p = p * x;

return (p);

}

Все функции имеют одинаковый вид:

имя (список аргументов, если они имеются)

описание аргументов, если они имеются

{

описания

операторы

}

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

Функция power вызывается дважды в строке

printf("%d %d %d\n",i,power(2,i),power(-3,i));

при каждом обращении функция power, получив два аргумента, возвращает целое значение, которое печатается в заданном формате. В выражениях power(2,i) является точно таким же целым, как 2 и i. (Однако не все функции выдают целое значение; мы займемся этим вопросом в главе 5).

Аргументы функции power должны быть описаны соответствующим образом, так как их типы известны. Это сделано в строке

int x,n;

которая следует за именем функции.

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

Это верно и для переменных i и p; i в функции power никак не связано с i в функции main.

Значение, вычисленное функцией power, передаются в main с помощью оператора return, точно такого же, как в PL/1. Внутри круглых скобок можно написать любое выражение. Функция не обязана возвращать какое-либо значение; оператор return, не содержащий никакого выражения, приводит к такой же передаче управления, как «сваливание на конец» функции при достижении конечной правой фигурной скобки, но при этом в вызывающую функцию не возвращается никакого полезного значения.

Упражнение 2-13 . Напишите программу преобразования прописных букв из файла ввода в строчные, используя при этом функцию ower(c), которая возвращает значение – переменную c, если символ в c – не буква, и значение соответствующей строчной буквы, если c – это буква.

2.8. Аргументы: вызов по значению

Один аспект в «C» может оказаться непривычным для программистов, которые использовали другие языки, в частности, ФОРТРАН и PL/1. В языке «C» все аргументы функций передаются «по значению». Это означает, что вызванная функция получает значения своих аргументов с помощью временных переменных (фактически через стек), а не их адреса. Это приводит к некоторым особенностям, отличным от тех, с которыми мы сталкивались в языках типа ФОРТРАНА и PL/1, использующих (вызов по ссылке), где вызванная процедура работает с адресом аргумента, а не с его значением.

Главное отличие состоит в том, что в «C» вызванная функция не может изменить переменную из вызывающей функции; она может менять только свою собственную временную копию.

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

Пример 2-12 . Рассмотрим вариант функции power, использующей данное обстоятельство

power(int x, int n)

{

int p;

for (p = 1; n > 0; --n)

p = p * x;

return (p);

}

Аргумент n используется как временная переменная; из него вычитается единица до тех пор, пока он не станет нулем. Переменная i здесь больше не нужна. чтобы ни происходило с n внутри power это никак не влияет на аргумент, с которым первоначально обратились к функции power.

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

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

2.9. Массивы символов

Пример 2-13 . По-видимому самым общим типом массива в «C» является массив символов. Чтобы проиллюстрировать использование массивов символов и обрабатывающих их функций, давайте напишем программу, которая читает набор строк и печатает самую длинную из них. Основная схема программы достаточно проста:

while (имеется еще строка)

if (эта строка длиннее самой длинной из предыдущих)

запомнить эту строку и ее длину,

напечатать самую длинную строку.

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

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

Как минимум getline должна передавать сигнал о возможном появлении конца файла; более общий полезный вариант мог бы передавать длину строки или нуль, если встретится конец файла.

Нуль не может быть длиной строки, так как каждая строка содержит по крайней мере один символ; даже строка, содержащая только символ новой строки, имеет длину 1.

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

Наконец, нам нужна основная программа для управления функциями getline и copy. Вот результат:

#define maxline 1000 // Максимальная длина строки

main() // Найти самую длинную строку

{

int len; // Длина текущей строки

int max; // Максимальная длина

char line[maxline]; // Текущая строка ввода

char save[maxline]; // Самая длинная строка

max = 0;

while ((len = getline(line, maxline)) > 0)

if (len > max)

{

max = len;

copy(line, save);

}

if (max > 0) // Это была строка

printf("%s", save);

}

getline(char s[], int lim) // Поместить строку в s,

// возвратить длину

{

int c, i;

for(i=0;i<lim-1 && (c=getchar())!=eof

&& c!='\n';++i)

s[i] = c;

if (c == '\n')

{

s[i] = c;

++i;

}

s[i] = '\0';

return(i);

}

copy(char s1[],char s2[]) // Копировать s1 в s2

{ // Полагаем, что s2 достаточно велика

int i;

i = 0;

while ((s2[i] = s1[i] != '\0')

++i;

}

Функция main и getline общаются как через пару аргументов, так и через возвращаемое значение. Аргументы getline описаны в строках:

char s[];

int lim;

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

Длина массива s не указана, так как она определена в main. Функция getline использует оператор return для передачи значения назад в вызывающую программу точно так же, как это делала функция power. Одни функции возвращают некоторое нужное значение; другие, подобно copy, используются из-за их действия и не возвращают никакого значения.

Чтобы пометить конец строки символов, функция getline помещает в конец создаваемого ей массива символ \0 (нулевой символ, значение которого равно нулю). Это соглашение используется также компилятором с языка «C»: когда в «C»-программе встречается строчная константа типа

"Hello\n"

то компилятор создает массив символов, содержащий символы этой строки, и заканчивает его символом \0, с тем чтобы функции, подобные printf, могли зафиксировать конец массива:

Спецификация формата %s указывает, что printf ожидает строку, представленную в такой форме. Проанализировав функцию COPY, вы обнаружите, что и она опирается на тот факт, что ее входной аргумент оканчивается символом \0, и копирует этот символ в выходной аргумент s2. (Все это подразумевает, что символ \0 не является частью нормального текста).

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

Пользователь функции getline никак не может заранее узнать, насколько длинной окажется вводимая строка. Поэтому в getline включен контроль переполнения. в то же время пользователь функции copy уже знает (или может узнать), каков размер строк, так что мы предпочли не включать в эту функцию дополнительный контроль.

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

Упражнение 2-15 . Напишите программу печати всех строк длиннее 80 символов.

Упражнение 2-16 . Напишите программу, которая будет удалять из каждой строки стоящие в конце пробелы и табуляции, а также строки, целиком состоящие из пробелов.

Упражнение 2-17 . Напишите функцию reverse(s), которая располагает символьную строку s в обратном порядке. С ее помощью напишите программу, которая обратит каждую строку из файла ввода.

2.10. Область действия: внешние переменные

Переменные в main (line, save и т.д.) являются внутренними или локальными по отношению к функции main, потому что они описаны внутри main и никакая другая функция не имеет к ним прямого доступа. Это же верно и относительно переменных в других функциях; например, переменная i в функции getline никак не связана с i в copy. Каждая локальная переменная существует только тогда, когда произошло обращение к соответствующей функции, и исчезает, как только закончится выполнение этой функции. По этой причине такие переменные, следуя терминологии других языков, обычно называют автоматическими. Мы впредь будем использовать термин автоматические при ссылке на эти динамические локальные переменные. (В главе 5 обсуждается класс статической памяти, когда локальные переменные все же оказываются в состоянии сохранить свои значения между обращениями к функциям).

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

В качестве альтернативы к автоматическим переменным можно определить переменные, которые будут внешними для всех функций, т.е. глобальными переменными, к которым может обратиться по имени любая функция, которая пожелает это сделать. (Этот механизм весьма сходен с COMMON в ФОРТРАНЕ и EXTERNAL в PL/1). Так как внешние переменные доступны всюду, их можно использовать вместо списка аргументов для передачи данных между функциями. Кроме того, поскольку внешние переменные существуют постоянно, а не появляются и исчезают вместе с вызываемыми функциями, они сохраняют свои значения и после того, как функции, присвоившие им эти значения, завершат свою работу.

Пример 2-14 . Внешняя переменная должна быть определена вне всех функций; при этом ей выделяется фактическое место в памяти. Такая переменная должна быть также описана в каждой функции, которая собирается ее использовать; это можно сделать либо явным описанием extern, либо неявным по контексту. Чтобы сделать обсуждение более конкретным, давайте перепишем программу поиска самой длинной строки, сделав line, save и max внешними переменными. Это потребует изменения описаний и тел всех трех функций, а также обращений к ним.

#define maxline 1000 // Максимальная длина строки

char line[maxline]; // Вводимая строка

char save[maxline]; // Самая длинная строка

int max; // Длина самой длинной строки

main() // Поиск длиннейшей строки: специальная версия

{

int len;

extern int max;

extern char save[];

max = 0;

while ( (len = getline()) > 0 )

if ( len > max )

{

max = len;

copy();

}

if ( max > 0 ) // Это была строка

printf( "%s", save );

}

getline() // Специализированная версия

{

int c, i;

extern char line[];

for (i = 0; i < maxline-1 && (c=getchar()) !=eof

&& c!='\n'; ++i)

line[i] = c;

if (c == \n)

{

line[i] = c;

++i;

}

line[i] = '\0'

return(i)

}

copy() // Специализированная версия

{

int i;

extern char line[], save[];

i = 0;

while ((save[i] = line[i]) !='\0')

++i;

}

Внешние переменные для функций main, getline и copy определены в первых строчках приведенного выше примера, которыми указывается их тип и вызывается отведение для них памяти. Синтаксически внешние описания точно такие же, как описания, которые мы использовали ранее, но так как они расположены вне функций, соответствующие переменные являются внешними. Чтобы функция могла использовать внешнюю переменую, ей надо сообщить ее имя. Один способ сделать это – включить в функцию описание extern; это описание отличается от предыдущих только добавлением ключевого слова extern.

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

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

Если программа находится в нескольких исходных файлах, и некоторая переменная определена, скажем в файле 1, а используется в файле 2, то чтобы связать эти два вхождения переменной, необходимо в файле 2 использовать описание extern. Этот вопрос будет обсуждаться в главе 5.

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

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

Упражнение 2-18 . Проверка в операторе for функции getline довольно неуклюжа. Перепишите программу таким образом, чтобы сделать эту проверку более ясной, но сохраните при этом то же самое поведение в конце файла и при переполнении буфера. Является ли это поведение самым разумным?

2.11. Некоторые оптимистичные выводы

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

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

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

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

Упражнение 2-21 . Напишите программу для «сгибания» длинных вводимых строк после последнего отличного от пробела символа, стоящего до столбца n ввода, где n – параметр. Убедитесь, что ваша программа делает что-то разумное с очень длинными строками и в случае, когда перед указанным столбцом нет ни табуляций, ни пробелов.

Упражнение 2-22 . Напишите программу удаления из «C»-программы всех комментариев. Не забывайте аккуратно обращаться с «закавыченными» строками и символьными константами.

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

3. ТИПЫ, ОПЕРАЦИИ И ВЫРАЖЕНИЯ

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

3.1. Имена переменных

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

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

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

3.2. Типы и размеры данных

Языке «C» имеется только несколько основных типов данных:

· char один байт, в котором может находиться один символ из внутреннего набора символов;

· int – целое, обычно соответствующее естественному размеру целых в используемой машине;

· float – с плавающей точкой одинарной точности;

· double – с плавающей точкой двойной точности.

Кроме того имеется ряд квалификаторов, которые можно использовать с типом int: short (короткое), long (длинное) и unsigned (целое без знака). Квалификаторы short и long указывают на различные размеры целых. Числа без знака подчиняются законам арифметики по модулю 2 в степени n, где n – число битов в int; числа без знаков всегда положительны. Описания с квалификаторами имеют вид:

short int x;

long int y;

unsigned int z;

Cлово int в таких ситуациях может быть опущено, что обычно и делается.

Количество битов, отводимых под эти объекты зависит от имеющейся машины. Ниже в таблице 3.1. приведены некоторые характерные значения.

Таблица 3.1.

Размеры объектов данных (бит)

Цель состоит в том, чтобы short и long давали возможность в зависимости от практических нужд использовать различные длины целых; тип int отражает наиболее «естественный» размер разрядной сетки конкретной машины. Как вы видите, каждый компилятор свободно интерпретирует short и long в соответствии со своими аппаратными средствами. Все, на что вы можете твердо полагаться, это то, что short не длиннее, чем long.

3.3. Константы

Константы типа int и float мы уже рассмотрели. Отметим еще только, что как обычная 123.456е–7, так и «научная» запись 0.12е3 для float является законной.

Каждая константа с плавающей точкой считается имеющей тип double, так что обозначение «е» служит как для float, так и для double.

Длинные константы записываются в виде 123l (от англ . long). Обычная целая константа, которая слишком длинна для типа int, рассматривается как long.

Существует система обозначений для восьмеричных и шестнадцатеричных констант: лидирующий 0 (нуль) в константе типа int указывает на восьмеричную константу, а стоящие впереди 0x соответствуют шестнадцатеричной константе. Например, десятичное число 31 можно записать как 037 в восьмеричной форме и как 0x1f в шестнадцатеричной. Шестнадцатеричные и восьмеричные константы могут также заканчиваться буквой l, что делает их относящимися к типу long.

3.3.1. Символьная константа . Символьная константа – это один символ, заключенный в одинарные кавычки, как, например, 'х'. Значением символьной константы является численное значение этого символа во внутреннем машинном наборе символов. Например, в наборе символов ASCII символьный нуль, или '0', имеет значение 48, а в коде EBCDIC – 240, и оба эти значения совершенно отличны от числа 0. Написание '0' вместо численного значения, такого как 48 или 240, делает программу не зависящей от конкретного численного представления этого символа в данной машине. Символьные константы точно так же участвуют в численных операциях, как и любые другие числа, хотя наиболее часто они используются в сравнении с другими символами. Правила преобразования будут изложены позднее.

Некоторые неграфические символы могут быть представлены как символьные константы с помощью эскайп-последовательностей, как, например, \n (новая строка). Хотя они выглядят как два символа, на самом деле являются одним. Кроме того, можно сгенерировать произвольную последовательность двоичных знаков размером в байт, если написать '\ooo', где ooo – от одной до трех восьмеричных цифр (0, 1,…,7), или '\xhh', где hhh – одна, две или более шестнадцатиричных цифр (0, 1, …, F).

Например, в коде ASCII:

#define vtab '013' // Вертикальная табуляция

#define bell '\017' // Звоночек

или в шестнадцатиричном виде:

#define vtab '\xb' // Вертикальная табуляция

#define bell '\x7' // Звоночек

Полный набор эскайп-последовательностей таков:

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

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

#define maxline 1000

char line[maxline+1];

или

seconds = 60 * 60 * hours;

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

"I am a string" // Я - строка

или

"" // Null string – нулевая строка

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

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

Пример 3-1 . Следующая функция strlen(s) вычисляет длину символьной строки s не считая конечный символ \0.

strlen(char s[]) // Возвращает длину строки

{

int i;

i = 0;

while (s[i] != '\0')

++i;

return(i);

}

Будьте внимательны и не путайте символьную константу со строкой, содержащей один символ: 'x' - это не то же самое, что "x". Первое – это отдельный символ, использованный с целью получения численного значения, соответствующего букве х в машинном наборе символов. Второе – символьная строка, состоящая из одного символа (буква х) и \0.

3.4. Описания

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

int lower, upper, step;

char c, line[1000];

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

int lower;

int upper;

int step;

char c;

char line[1000];

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

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

char backslash = '\\';

int i = 0;

float eps = 1.0e–5;

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

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

3.5. Арифметические операции

Бинарными арифметическими операциями являются +, –, *, / и операция деления по модулю %. Имеется унарная операция – , но не существует унарной операции +.

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

x % y

дает остаток от деления x на y и, следовательно, равно нулю, когда х делится на y точно. Например, год является високосным, если он делится на 4, но не делится на 100, исключая то, что делящиеся на 400 годы тоже являются високосными. Поэтому

if(year%4 == 0 && year%100 != 0 || year%400 == 0)

год високосный;

else

год невисокосный;

Операцию % нельзя использовать с типами float или double. Операции + и – имеют одинаковое старшинство, которое младше одинакового уровня старшинства операций *, / и %, которые в свою очередь младше унарного минуса. Арифметические операции группируются слева направо. (Сведения о старшинстве и ассоциативности всех операций собраны в таблице в конце этой главы). Порядок выполнения ассоциативных и коммутативных операций типа + и – не фиксируется; компилятор может перегруппировывать даже заключенные в круглые скобки выражения, связанные такими операциями.

Таким образом, а+(b+c) может быть вычислено как (a+b)+c. Это редко приводит к какому-либо расхождению, но если необходимо обеспечить строго определенный порядок, то нужно использовать явные промежуточные переменные.

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

3.6. Операции отношения и логические операции

Операциями отношения являются

=> > =< < .

Все они имеют одинаковое старшинство. Непосредственно за ними по уровню старшинства следуют операции равенства и неравенства:

== != ,

которые тоже имеют одинаковое старшинство. Операции отношения младше арифметических операций, так что выражения типа i<lim-1 понимаются как i<(lim-1), как и предполагается.

Логические связки && и || более интересны. Выражения, связанные операциями && и ||, вычисляются слева направо, причем их рассмотрение прекращается сразу же как только становится ясно, будет ли результат истиной или ложью. Учет этих свойств очень существенен для написания правильно работающих программ. Рассмотрим, например, оператор цикла в считывающей строку функции getline, которую мы написали в главе 2:

for(i=0;i<lim-1 && (c=getchar())!='\n' && c!=eof; ++i)

s[i]=c;

Ясно, что перед считыванием нового символа необходимо проверить, имеется ли еще место в массиве s, так что условие i<lim-1 должно проверяться первым. И если это условие не выполняется, мы не должны считывать следующий символ.

Так же неудачным было бы сравнение символа в переменной c с eof до обращения к функции getchar: прежде чем проверять символ, его нужно считать.

Старшинство операции && выше, чем у ||, и обе они младше операций отношения и равенства. Поэтому такие выражения, как

i<lim-1 && (c = getchar()) != '\n' && c != eof

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

Но так как операция != старше операции присваивания, то для достижения правильного результата в выражении

(c = getchar()) != '\n'

скобки необходимы.

Унарная операция отрицания ! преобразует ненулевой или истинный операнд в 0, а нулевой или ложный операнд в 1. Обычное использование операции ! заключается в записи

if( ! inword ) вместо if( inword == 0 )

Tрудно сказать, какая форма лучше. Конструкции типа ! inword читаются довольно удобно («если не в слове»). Но в более сложных случаях они могут оказаться трудными для понимания.

Упражнение 3-1 . Напишите оператор цикла, эквивалентный приведенному выше оператору for, не используя операции &&.

3.7. Преобразование типов

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

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

Пример 3-2 . Примером может служить функция atoi, которая ставит в соответствие строке цифр ее численный эквивалент.

atoi(char s[]) // Преобразование s в целое

{

int i, n;

n = 0;

for ( i = 0; s[i]>='0' && s[i]<='9'; ++i)

n = 10 * n + s[i] - '0';

return(n);

}

Kак уже обсуждалось в главе 2, выражение s[i]-'0' имеет численное значение находящегося в s[i]символа, потому что значение символов '0', '1' и т.д. образуют возрастающую последовательность расположенных подряд целых положительных чисел.

Пример 3-3 . Другой пример преобразования char в int дает функция lower, преобразующая данную прописную букву в строчную. Если выступающий в качестве аргумента символ не является прописной буквой, то lower возвращает его неизменным. Приводимая ниже программа справедлива только для набора символов ASCII.

lower(int c) // Преобразование прописных в строчные

{

if ( c >= 'A' && c <= 'Z' )

return( c + 'a' - 'A');

else // @ записано вместо 'a' строчного

return(c);

}

Эта функция правильно работает при коде ASCII, потому что численные значения, соответствующие в этом коде прописным и строчным буквам, отличаются на постоянную величину, а каждый алфавит является сплошным – между a и z нет ничего, кроме букв. Это последнее замечание для набора символов EBCDIC систем IBM 370 оказывается несправедливым, в силу чего эта программа на таких системах работает неправильно – она преобразует не только буквы.

При преобразовании символьных переменных в целые возникает один тонкий момент. Дело в том, что сам язык не указывает, должны ли переменным типа char соответствовать численные значения со знаком или без знака. Может ли при преобразовании char в int получиться отрицательное целое? К сожалению, ответ на этот вопрос меняется от машины к машине, отражая расхождения в их архитектуре. На некоторых машинах (PDP-11, например) переменная типа char, крайний левый бит которой содержит 1, преобразуется в отрицательное целое («знаковое расширение»). На других машинах такое преобразование сопровождается добавлением нулей с левого края, в результате чего всегда получается положительное число.

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

Наиболее типичным примером возникновения такой ситуации является случай, когда значение 1 используется в качестве eof. Рассмотрим программу:

char c;

c = getchar();

if ( c == eof )

...

На машине, которая не осуществляет знакового расширения, переменная c всегда положительна, поскольку она описана как char, а так как eof отрицательно, то условие никогда не выполняется. Чтобы избежать такой ситуации, мы всегда предусмотрительно использовали int вместо char для любой переменной, получающей значение от getchar.

Основная же причина использования int вместо char не связана с каким-либо вопросом о возможном знаковом расширении. просто функция getchar должна передавать все возможные символы (чтобы ее можно было использовать для произвольного ввода) и, кроме того, отличающееся значение eof. Следовательно значение eof не может быть представлено как char, а должно храниться как int.

Другой полезной формой автоматического преобразования типов является то, что выражения отношения, подобные i>j, и логические выражения, связанные операциями && и ||, по определению имеют значение 1, если они истинны, и 0, если они ложны. Таким образом, присваивание:

isdigit = c >= '0' && c <= '9';

полагает isdigit равным 1, если c – цифра, и равным 0 в противном случае. (В проверочной части операторов if, while, for и т.д. «истина» просто означает «не нуль»).

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

1. Типы char и short преобразуются в int, а float в double.

2. Затем, если один из операндов имеет тип double, то другой преобразуется в double, и результат имеет тип double.

3. В противном случае, если один из операндов имеет тип long, то другой преобразуется в long, и результат имеет тип long.

4. В противном случае, если один из операндов имеет тип unsigned, то другой преобразуется в unsigned и результат имеет тип unsigned.

5. В противном случае операнды должны быть типа int, и результат имеет тип int.

Подчеркнем, что все переменные типа float в выражениях преобразуются в double; в языке «C» вся плавающая арифметика выполняется с двойной точностью.

Преобразования возникают и при присваиваниях; значение правой части преобразуется к типу левой, который и является типом результата. Символьные переменные преобразуются в целые либо со знаковым расширением, либо без него, как описано выше. Обратное преобразование int в char ведет себя хорошо – лишние биты высокого порядка просто отбрасываются. Таким образом, если:

int i;

char c;

i = c;

c = i;

то значение символа c не изменяется. Это верно независимо от того, вовлекается ли знаковое расширение или нет.

Если х типа float, а i типа int, то как

х = i;

так и

i = х;

приводят к преобразованиям; при этом float преобразуется в int отбрасыванием дробной части. Тип double преобразуется во float округлением. Длинные целые преобразуются в более короткие целые и в переменные типа char посредством отбрасывания лишних битов высокого порядка.

Так как аргумент функции является выражением, то при передаче функциям аргументов также происходит преобразование типов: в частности, char и short становятся int, а float становится double. Именно поэтому мы описывали аргументы функций как int и double даже тогда, когда обращались к ним с переменными типа char и float.

Наконец, в любом выражении может быть осуществлено («принуждено») явное преобразование типа с помощью конструкции, называемой перевод (cast). В этой конструкции, имеющей вид:

(имя типа) выражение

выражение преобразуется к указанному типу по правилам преобразования, изложенным выше. Фактически точный смысл операции перевода можно описать следующим образом: выражение как бы присваивается некоторой переменной указанного типа, которая затем используется вместо всей конструкции. Например, библиотечная процедура sqrt ожидает аргумента типа double и выдаст бессмысленный ответ, если к ней по небрежности обратятся с чем-нибудь иным. Таким образом, если n – целое, то выражение:

sqrt((double)n)

до передачи аргумента функции sqrt преобразует n к типу double.

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

Упражнение 3-2 . Составьте программу для функции htoi(s), которая преобразует строку шестнадцатеричных цифр в эквивалентное ей целое значение. При этом допустимыми цифрами являются цифры от 1 до 9 и буквы от а до f.

3.8. Операции увеличения и уменьшения

В языке «C» предусмотрены две необычные операции для увеличения и уменьшения значений переменных. Операция увеличения ++ добавляет 1 к своему операнду, а операция уменьшения -- вычитает 1. Мы часто использовали операцию ++ для увеличения переменных, как, например, в

if(c == '\n')

++i;

Необычный аспект заключается в том, что ++ и -- можно использовать либо как префиксные операции (перед переменной, как в ++n), либо как постфиксные (после переменной: n++). Эффект в обоих случаях состоит в увеличении N. Но выражение ++n увеличивает переменную N до использования ее значения, в то время как n++ увеличивает переменную N после того, как ее значение было использовано. Это означает, что в контексте, где используется значение переменной, а не только эффект увеличения, использование ++n и n++ приводит к разным результатам. Если n=5, то:

х = n++;

устанавливает х равным 5, а

х = ++n;

полагает х равным 6. В обоих случаях n становится равным 6. Операции увеличения и уменьшения можно применять только к переменным; выражения типа х=i+j)++ являются незаконными.

В случаях, где нужен только эффект увеличения, а само значение не используется, как, например, в:

if ( c == '\n' )

nal++;

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

Пример 3-4 . Рассмотрим функцию squeeze(s,c), которая удаляет символ 'ж' из строки s, каждый раз, как он встречается. Обращение к функции может быть следующим: squeeze(s,'ж'). Текст функции выглядит так:

squeeze(char s[],int c)

{

int i, j;

for ( i = j = 0; s[i] != '\0'; i++)

if ( s[i] != c )

s[j++] = s[i];

s[j] = '\0';

}

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

if ( s[i] != c )

{

s[j] = s[i];

j++;

}

Пример 3-5 . Подобную конструкцию дает функция getline, которую мы запрограммировали в главе 2, где можно заменить:

if ( c == '\n' )

{

s[i] = c;

++i;

}

более компактной записью

if ( c == '\n' )

s[i++] = c;

Пример 3-6 . Рассмотрим функцию strcat(s,t), которая приписывает строку t в конец строки s, образуя конкатенацию строк s и t. При этом предполагается, что в s достаточно места для хранения полученной комбинации.

strcat(s,t) // Присоединить t к окончанию s

char s[], t[]; // s должна быть достаточно большой

{

int i, j;

i = j = 0;

while(s[i] != '\0') // Поиск «хвоста» s

i++;

while((s[i++]=t[j++]) != '\0') // Копируем t

; // «Пустой» оператор

}

Tак как из t в s копируется каждый символ, то для подготовки к следующему прохождению цикла постфиксная операция ++ применяется к обеим переменным i и j.

Упражнение 3-3 . Напишите другой вариант функции:

squeeze(s1,s2), который удаляет из строки s1 каждый символ, совпадающий с каким-либо символом строки s2.

Упражнение 3-4 . Напишите программу для функции any(s1,s2), которая находит место первого появления в строке s1 какого-либо символа из строки s2 и, если строка s1 не содержит символов строки s2, возвращает значение –1.

3.9. Побитовые логические операции

В языке предусмотрен ряд операций для работы с битами; эти операции нельзя применять к переменным типа float или double.

& – побитовое И (AND);

| – побитовое ИЛИ (включающее OR);

^ – побитовое исключающее ИЛИ;

<< – сдвиг влево;

>> – сдвиг вправо;

~ – побитовое отрицание (дополнение, унарная операция).

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

c = n & 0177

передает в c семь младших битов n, полагая остальные равными нулю.

Операция | (побитовое ИЛИ) используется для включения битов:

c = x | mask

устанавливает на единицу те биты в х , которые равны единице в mask.

Следует быть внимательным и отличать побитовые операции & и | от логических связок && и || , которые подразумевают вычисление значения истинности слева направо. Например, если х=1, а y=2, то значение х&y равно нулю, в то время как значение x&&y равно единице (почему?).

Операции сдвига << и >> осуществляют, соответственно, сдвиг влево и вправо своего левого операнда на число битовых позиций, задаваемых правым операндом. Таким образом, х<<2 сдвигает х влево на две позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению х на 4. Следует отметить, что сдвиг вправо величины без знака заполняет освобождающиеся биты на некоторых машинах, таких как PDP-11, содержанием знакового бита (арифметический сдвиг), а на других – нулем (логический сдвиг).

Унарная операция ~ дает дополнение к целому; это означает , что каждый бит со значением 1 получает значение 0 и наоборот. Эта операция обычно оказывается полезной в выражениях типа:

x & ~077

где последние шесть битов х маскируются нулем. Подчеркнем, что выражение x&~077 не зависит от длины слова и поэтому предпочтительнее, чем, например, x&0177700, где предполагается, что х занимает 16 битов. такая переносимая форма не требует никаких дополнительных затрат, поскольку ~077 является константным выражением и, следовательно, обрабатывается во время компиляции.

Пример 3-7 . Чтобы проиллюстрировать использование некоторых операций с битами, рассмотрим функцию getbits(x,p,n), которая возвращает начинающиеся с позиции р поле переменной х длиной n битов, сдвинутыми к правому краю. Мы предполагаем , что крайний правый бит имеет номер 0, и что n и р – разумно заданные положительные числа. например, getbits(x,4,3) возвращает сдвинутыми к правому краю биты, занимающие позиции 4, 3 и 2.

// Получить n, начиная с p-й позиции

getbits(unsigned x, unsigned p, unsigned n)

{

return((x >> (p+1-n)) & ~(~0 << n));

}

Операция x>>(p+1-n) сдвигает желаемое поле в правый конец слова. Описание аргумента x как unsigned гарантирует, что при сдвиге вправо освобождающиеся биты будут заполняться нулями, а не содержимым знакового бита, независимо от того, на какой машине пропускается программа. Все биты константного выражения ~0 равны 1; сдвиг его на n позиций влево с помощью операции ~0<<n создает маску с нулями в n крайних правых битах и единицами в остальных; дополнение ~ создает маску с единицами в n крайних правых битах.

Упражнение 3-5 . Переделайте getbits таким образом, чтобы биты отсчитывались слева направо.

Упражнение 3-6 . Напишите программу для функции wordlength(), вычисляющей длину слова используемой машины, т.е. Число битов в переменной типа int. Функция должна быть переносимой, т.е. Одна и та же исходная программа должна правильно работать на любой машине.

Упражнение 3-7 . Напишите программу для функции rightrot(n,b), сдвигающей циклически целое n вправо на b битовых позиций.

Упражнение 3-8 . Напишите программу для функции invert(x,p,n), которая инвертирует (т.е. заменяет 1 на 0 и наоборот) n битов x, начинающихся с позиции p, оставляя другие биты неизмененными.

3.10. Операции и выражения присваивания

Такие выражения, как:

i = i + 2 ,

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

i += 2 ,

используя операцию присваивания вида +=.

Большинству бинарных операций (операций подобных +, которые имеют левый и правый операнд) соответствует операция присваивания вида оп =, где оп – одна из операций:

+ - * / % << >> & ^ | .

Если е1 и е2 – выражения, то:

е1 оп = е2

эквивалентно:

е1 = (е1) оп (е2)

за исключением того, что выражение е1 вычисляется только один раз. Обратите внимание на круглые скобки вокруг е2: если:

x *= y + 1 ,

то

x = x * (y + 1) ,

но не

x = x * y + 1 .

Пример 3-8 . В качестве примера приведем функцию bitcount, которая подсчитывает число равных 1 битов у целого аргумента.

// Определить число единичных бит в целом n

bitcount(unsigned n)

(

int b;

for (b = 0; n != 0; n >>= 1)

if (n & 01)

b++;

return(b);

)

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

Мы говорим: «прибавить 2 к i» или «увеличить i на 2», но не «взять i, прибавить 2 и поместить результат опять в i». Итак, i += 2.

Кроме того, в громоздких выражениях, подобных:

yyval[yypv[p3+p4] + yypv[p1+p2]] += 2 ,

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

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

while ((c = getchar()) != eof) .

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

Типом выражения присваивания является тип его левого операнда.

Упражнение 3-9 . В двоичной системе счисления операция x&(x-1) обнуляет самый правый равный 1 бит переменной x (почему?). Используйте это замечание для написания более быстрой версии функции bitcount.

3.11. Условные выражения

Операторы:

if (a > b)

z = a;

else

z = b;

конечно вычисляют в z максимум из a и b. Условное выражение, записанное с помощью тернарной (т.е. имеющей три операнда) операции «?:», предоставляет другую возможность для записи этой и аналогичных конструкций. В выражении:

е1 ? е 2 : е3

сначала вычисляется выражение е1. Если оно отлично от нуля (истинно), то вычисляется выражение е2, которое и становится значением условного выражения. В противном случае вычисляется е3, и оно становится значением условного выражения. Каждый раз вычисляется только одно из выражения е2 и е3. Таким образом, чтобы положить z равным максимуму из а и в, можно написать:

z = (a > b) ? a : b; // z = max(a,b)

Следует подчеркнуть, что условное выражение действительно является выражением и может использоваться точно так же, как любое другое выражение. Если е2 и е3 имеют разные типы, то тип результата определяется по правилам преобразования, рассмотренным ранее в этой главе. Например, если f имеет тип float, а n – тип int, то выражение:

(n > 0) ? f : n

имеет тип double независимо от того, положительно ли n или нет.

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

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

for (i = 0; i < n; i++)

printf("%6d%c",a[i],(i%10==9 || i==n-1) ? '\n' : ' ');

Символ перевода строки записывается после каждого десятого элемента и после n-го элемента. За всеми остальными элементами следует один пробел. Хотя, возможно, это выглядит мудреным, было бы поучительным попытаться записать это, не используя условного выражения.

Упражнение 3-10 . Перепишите программу для функции lower, которая переводит прописные буквы в строчные, используя вместо конструкции if-else условное выражение.

3.12. Старшинство и порядок вычисления

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

Так, например, операции *, / и % имеют одинаковый уровень старшинства, который выше, чем уровень операций + и -.

Операции -> и . (точка) используются для доступа к элементам структур; они будут описаны в главе 7 вместе с sizeof (размер объекта). В главе 6 обсуждаются операции * (косвенное обращение по указателю) и & (получение адреса объекта). Отметим, что уровень старшинства побитовых логических операций &, ^ и | ниже уровня операций == и != . Это приводит к тому, что осуществляющие побитовую проверку выражения, подобные

if ((x & mask) == 0) ...

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

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

Таблица 3.2.

Правила старшинства и ассоциативности операций

В языке «C», как и в большинстве языков, не фиксируется порядок вычисления операндов в операторе. Например, в операторе вида:

x = f() + g();

сначала может быть вычислено f, а потом g, и наоборот; поэтому, если либо f, либо g изменяют внешнюю переменную, от которой зависит другой операнд, то значение x может зависеть от порядка вычислений. Для обеспечения нужной последовательности промежуточные результаты можно опять запоминать во временных переменных.

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

printf("%d %d\n",++n,power(2,n));

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

++n;

printf("%d %d\n",n,power(2,n));

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

a[i] = i++;

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

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

4. ПОТОК УПРАВЛЕНИЯ

Управляющие операторы языка определяют порядок вычислений. В приведенных ранее примерах мы уже встречались с наиболее употребительными управляющими конструкциями языка «C»; здесь мы опишем остальные операторы управления и уточним действия операторов, обсуждавшихся ранее.

4.1. Операторы и блоки

Такие выражения, как x=0, или i++, или printf(...), становятся операторами, если за ними следует точка с запятой, как, например:

x = 0;

i++;

printf(...);

В языке «C» точка с запятой является признаком конца оператора, а не разделителем операторов, как в языках типа АЛГОЛ и ПАСКАЛЬ.

Фигурные скобки { и } используются для объединения описаний и операторов в составной оператор или блок, так что они оказываются синтаксически эквивалентны одному оператору. Один явный пример такого типа дают фигурные скобки, в которые заключаются операторы, составляющие функцию, другой – фигурные скобки вокруг группы операторов в конструкциях if, else, while и for (на самом деле переменные могут быть описаны внутри любого блока; мы поговорим об этом в главе 5). Точка с запятой никогда не ставится после первой фигурной скобки, которая завершает блок.

4.2. Конструкция if-else

Оператор if-else используется при необходимости сделать выбор. Формально синтаксис имеет вид:

if выражение)

оператор-1;

else

оператор-2;

где часть else является необязательной. Сначала вычисляется выражение; если оно «истинно» (т.е. значение выражения отлично от нуля), то выполняется оператор-1. Если оно ложно (значение выражения равно нулю), и если есть часть с else, то вместо оператора-1 выполняется оператор-2.

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

if (выражение)

вместо

if (выражение !=0)

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

То, что часть else в конструкции if-else является необязательной, приводит к двусмысленности в случае, когда else опускается во вложенной последовательности операторов if. Эта неоднозначность разрешается обычным образом: 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 (n > 0)

for (i = 0; i < n; i++)

if (s[i] > 0)

{

printf("...");

return(i);

}

else // Неправильно

printf("Ошибка: n равно нулю\n");

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

Между прочим, обратите внимание, что в:

if (a > b)

z = a;

else

z = b;

после z=a стоит точка с запятой. Дело в том, что согласно грамматическим правилам, за if должен следовать оператор, а выражение типа z=a, являющееся оператором, всегда заканчивается точкой с запятой.

4.3. Конструкция else-if

Конструкция:

if (выражение)

оператор;

else if (выражение)

оператор;

else if (выражение)

оператор;

else

оператор;

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

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

else

оператор;

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

Пример 4-1 . Для иллюстрации выбора из трех возможных вариантов приведем программу функции, которая методом половинного деления определяет, находится ли данное значение х в отсортированном массиве v. Элементы массива v должны быть расположены в порядке возрастания. Функция возвращает номер позиции (число между 0 и n-1), в которой значение х находится в v, и -1, если х не содержится в v.

// Найти x в v[0]<=v[1]<=...<=v[n-1]

binary(int x, int v[], int n)

{

int low, high, mid;

low = 0;

high = n - 1;

while (low <= high)

{

mid = (low + high) / 2;

if (x < v[mid])

high = mid - 1;

else if (x > v[mid])

low = mid + 1;

else /* found match */

return(mid);

}

return(-1);

}

Основной частью каждого шага алгоритма является проверка, будет ли х меньше, больше или равен среднему элементу v[mid]. Использование конструкции else-if здесь вполне естественно.

4.4. Переключатель switch

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

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

if ... else if ... else.

Вот та же самая программа с переключателем:

main() // Подсчет цифр, пробелов и др. символов

{

int c, i, nwhite, nother, ndigit[10];

nwhite = nother = 0;

for (i = 0; i < 10; i++)

ndigit[i] = 0;

while ((c = getchar()) != eof)

{

switch (c)

{

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

ndigit[c-'0']++;

break;

case ' ':

case '\n':

case '\t':

nwhite++;

break;

default :

nother++;

break;

}

}

printf("digits =");

for (i = 0; i < 10; i++)

printf(" %d", ndigit[i]);

printf("\nwhite space = %d, other = %d\n",

nwhite, nother);

return 0;

}

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

Оператор break приводит к немедленному выходу из переключателя. Поскольку случаи служат только в качестве меток, то если вы не предпримите явных действий после выполнения операторов, соответствующих одному случаю, вы провалитесь на следующий случай. Операторы break и return являются самым обычным способом выхода из переключателя. Как мы обсудим позже в этой главе, оператор break можно использовать и для немедленного выхода из операторов цикла while, for и do.

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

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

Упражнение 4-1 . Напишите программу для функции expand(s,t), которая копирует строку s в t, заменяя при этом символы табуляции и новой строки на видимые условные последовательности, как \n и \t. Используйте переключатель.

4.5. Циклы while и for

Мы уже сталкивались с операторами цикла while и for. В конструкции:

while (выражение)

оператор;

вычисляется выражение. Если его значение отлично от нуля, то выполняется оператор и выражение вычисляется снова. Этот цикл продолжается до тех пор, пока значение выражения не станет нулем, после чего выполнение программы продолжается с места после оператора.

Конструкция for вида:

for (выражение 1; выражение 2; выражение 3)

оператор;

эквивалентна конструкции while вида:

выражение 1;

while (выражение 2)

{

оператор;

выражение 3;

}

Грамматически все три компонента в for являются выражениями. Наиболее распространенным является случай, когда выражение 1 и выражение 3 являются присваиваниями или обращениями к функциям, а выражение 2 – условным выражением. Любая из трех частей может быть опущена, хотя точки с запятой при этом должны оставаться. Если отсутствует выражение 1 или выражение 3, то оно просто выпадает из расширения. Если же отсутствует проверка, выражение 2, то считается, как будто оно всегда истинно, так что:

for (;;)

{

...

}

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

Использовать ли while или for – это, в основном дело вкуса. Например в

while ((c = getchar())==' ' || c=='\n' || c=='\t')

; // Пропустить символы-разделители

нет ни инициализации, ни реинициализации, так что цикл while выглядит самым естественным.

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

for (i = 0; i < n; i++) ,

которая является идиомой языка «C» для обработки первых n элементов массива, аналогичной оператору цикла DO в ФОРТРАНЕ и PL/1. Аналогия, однако, не полная, так как границы цикла могут быть изменены внутри цикла, а управляющая переменная сохраняет свое значение после выхода из цикла, какова бы ни была причина этого выхода. Поскольку компонентами for могут быть произвольные выражения, они не ограничиваются только арифметическими прогрессиями. Тем не менее является плохим стилем включать в for вычисления, которые не относятся к управлению циклом, лучше поместить их в управляемые циклом операторы.

Пример 4-3 . В качестве большего по размеру примера приведем другой вариант функции atoi, преобразующей строку в ее численный эквивалент. Этот вариант является более общим; он допускает присутствие в начале символов пустых промежутков и знака + или – . (В главе 5 приведена функция atof, которая выполняет то же самое преобразование для чисел с плавающей точкой).

Общая схема программы отражает форму поступающих данных:

· пропустить пустой промежуток, если он имеется;

· извлечь знак, если он имеется;

· извлечь целую часть и преобразовать ее.

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

int atoi(char s[]) //Преобразовать s в целое; версия 2

{

int i, n, sign;

for(i=0;s[i]==' ' || s[i]=='\n' || s[i]=='\t';i++)

; // Игнорировать символы-разделители

sign = (s[i++]=='-') ? -1 : 1;

if(s[i] == '+' || s[i] == '-') // Пропуск знака

i++;

for( n = 0; s[i] >= '0' && s[i] <= '9'; i++)

n = 10 * n + (s[i] - '0');

return(sign * n);

}

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

void shell(int v[],int n) // Сортировать v[0]...v[n-1]

// в порядке возрастания

{

int gap, i, j, temp;

for (gap = n/2; gap > 0; gap /= 2)

for (i = gap; i < n; i++)

for (j=i-gap; j>=0 && v[j]>v[j+gap]; j-=gap)

{

temp = v[j];

v[j] = v[j+gap];

v[j+gap] = temp;

}

}

Здесь имеются три вложенных цикла. Самый внешний цикл управляет интервалом между сравниваемыми элементами, уменьшая его от n/2 вдвое при каждом проходе, пока он не станет равным нулю. Средний цикл сравнивает каждую пару элементов, разделенных на величину интервала; самый внутренний цикл переставляет любую неупорядоченную пару. Так как интервал в конце концов сводится к единице, все элементы в результате упорядочиваются правильно. Отметим, что в силу общности конструкции for внешний цикл укладывается в ту же самую форму, что и остальные, хотя он и не является арифметической прогрессией.

Пример 4-5 . Последней операцией языка «C» является запятая «,», которая чаще всего используется в операторе for. Два выражения, разделенные запятой, вычисляются слева направо, причем типом и значением результата являются тип и значение правого операнда. Таким образом, в различные части оператора for можно включить несколько выражений, например, для параллельного изменения двух индексов. Это иллюстрируется функцией reverse(s), которая располагает строку s в обратном порядке на том же месте.

void reverse(char s[]) // Расположить строку s

// в обратном порядке

{

int c, i, j;

for(i = 0, j = strlen(s) - 1; i < j; i++, j--)

{

c = s[i];

s[i] = s[j];

s[j] = c;

}

}

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

Упражнение 4-2 . Составьте программу для функции expand(s1,s2), которая расширяет сокращенные обозначения вида а-z из строки s1 в эквивалентный полный список авс...xyz в s2. Допускаются сокращения для строчных и прописных букв и цифр. Будьте готовы иметь дело со случаями типа а-в-с, а-z0-9 и -а-z. (Полезное соглашение состоит в том, что символ – , стоящий в начале или конце s1, воспринимается буквально как минус).

4.6. Цикл do-while

Как уже отмечалось в главе 2, циклы while и for обладают тем приятным свойством, что в них проверка окончания осуществляется в начале, а не в конце цикла. Третий оператор цикла языка «C», do-while, проверяет условие окончания в конце, после каждого прохода через тело цикла; тело цикла всегда выполняется по крайней мере один раз. Синтаксис этого оператора имеет вид:

do

оператор;

while (выражение);

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

Пример 4-6 . Как и можно было ожидать, цикл do-while используется значительно реже, чем while и for, составляя примерно пять процентов от всех циклов. Тем не менее, иногда он оказывается полезным, как, например, в следующей функции itoa, которая преобразует число в символьную строку (обратная функции atoi). Эта задача оказывается несколько более сложной, чем может показаться сначала. Дело в том, что простые методы выделения цифр генерируют их в неправильном порядке. Мы предпочли получить строку в обратном порядке, а затем обратить ее.

itoa(int n, char s[]) // Преобразование n в строку s

{

int i, sign;

if ((sign = n) < 0) // Сохраняем знак

n = -n; // Делаем n > 0

i = 0;

do // Генерируем цифры

{ // в обратном порядке

s[i++] = n % 10 + '0'; // Следующая цифра

}

while ((n /=10) > 0); // Исключить её

if (sign < 0)

s[i++] = '-'

s[i] = '\0';

reverse(s);

}

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

Упражнение 4-3 . При представлении чисел в двоичном дополнительном коде наш вариант itoa не справляется с наибольшим отрицательным числом, т.е. cо значением n, определяемым из соотношения:

,

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

Упражнение 4-4 . Напишите аналогичную функцию itob(n,s), которая преобразует целое без знака n в его двоичное символьное представление в s. Запрограммируйте функцию itoh, которая преобразует целое в шестнадцатеричное представление.

Упражнение 4-5 . Напишите вариант iтоа, который имеет три, а не два аргумента. Третий аргумент – минимальная ширина поля; преобразованное число должно, если это необходимо, дополняться слева пробелами, так чтобы оно имело достаточную ширину.

4.7. Оператор break

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

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

#define maxline 1000

main() // Удалить пробелы, табуляции и новые строки

{

int n;

char line[maxline];

while ((n = getline(line,maxline)) > 0)

{

while (--n >= 0)

if (line[n] != ' ' && line[n] != '\t'

&& line[n] != '\n')

break;

line[n+1] = '\0';

printf("%s\n",line);

}

}

Функция getline возвращает длину строки. Внутренний цикл начинается с последнего символа line (напомним, что --n уменьшает n до использования его значения) и движется в обратном направлении в поиске первого символа, который отличен от пробела, табуляции или новой строки. Цикл прерывается, когда: либо найден такой символ, либо n становится отрицательным (т.е. когда просмотрена вся строка). Советуем вам убедиться, что такое поведение правильно и в том случае, когда строка состоит только из символов пустых промежутков.

В качестве альтернативы к break можно ввести проверку в сам цикл:

while ((n = getline(line,maxline)) > 0)

{

while (--n >= 0 && (line[n] == ' ' ||

line[n] == '\t' || line[n] == '\n'))

;

...

}

Это уступает предыдущему варианту, так как проверка становится труднее для понимания. По возможности следует избегать проверок, которые требуют переплетения &&, ||, ! и круглых скобок.

4.8. Оператор continue

Оператор continue родственен оператору BRеак, но используется реже; он приводит к началу следующей итерации охватывающего цикла (for, while, do ). В циклах while и do это означает непосредственный переход к выполнению проверочной части; в цикле for управление передается на шаг реинициализации.

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

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

for (i = 0; i < n; i++)

{

if (a[i] < 0) // Пропуск отрицательного элемента

continue;

... // Обработка положительного элемента

}

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

Упражнение 4-6 . Напишите программу копирования ввода на вывод, с тем исключением, что из каждой группы последовательных одинаковых строк выводится только одна. (Это простой вариант утилиты U niq системы U nix ).

4.9. Оператор goto и метки

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

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

for ( ... )

for ( ... )

{

...

if (disaster)

goto error;

}

...

error:

... //Ликвидировать беспорядок

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

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

for (i = 0; i < n; i++)

for (j = 0; j < m; j++)

if (v[i][j] < 0)

goto found;

... // Не найден

found:

... // Найден в позиции i, j

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

found = 0;

for (i = 0; i < n && !found; i++)

for (j = 0; j < m && !found; j++)

found = (v[i][j] < 0);

if (found)

... // Найден в позиции i-1, j-1

else

... // Не обнаружен

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

5. ФУНКЦИИ И СТРУКТУРА ПРОГРАММ

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

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

Большинство программистов хорошо знакомы с «библиотечными» функциями для ввода и вывода (getchar, putchar и др.) и для численных расчетов (sin, cos, sqrt и др.). В этой главе мы сообщим больше о написании новых функций.

5.1. Основные сведения

Для начала давайте разработаем и составим программу печати каждой строки ввода, которая содержит определенную комбинацию символов (это – специальный случай утилиты Grep системы Unix ). Например, при поиске комбинации the в наборе строк:

Now is the time

for all good

men to come to the aid

of their party

в качестве выхода мы получим строки:

Now is the time

men to come to the aid

of the ir party

Основная схема выполнения задания четко разделяется на три части:

while (имеется еще строка)

if (строка содержит нужную комбинацию)

... // Вывод этой строки

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

«Пока имеется еще строка» – это getline, функция, которую мы запрограммировали в главе 2, а «вывод этой строки» – это функция printf, которую уже кто-то подготовил для нас. Это значит, что нам осталось только написать процедуру для определения, содержит ли строка данную комбинацию символов или нет. Мы можем решить эту проблему, позаимствовав разработку из PL/1: функция index(s,t) возвращает позицию, или индекс, строки s, где начинается строка t, и -1, если s не содержит t . В качестве начальной позиции мы используем 0, а не 1, потому что в языке «C» массивы начинаются с позиции нуль. Когда нам в дальнейшем понадобится проверять на совпадение более сложные конструкции, нам придется заменить только функцию index; остальная часть программы останется той же самой.

Пример 5-1 . После того, как мы потратили столько усилий на разработку, написание программы в деталях не представляет затруднений. Ниже приводится целиком вся программа, так что вы можете видеть, как соединяются вместе отдельные части. Комбинация символов, по которой производится поиск, выступает пока в качестве символьной строки в аргументе функции index, что не является самым общим механизмом. Мы скоро вернемся к обсуждению вопроса об инициализации символьных массивов и в главе 6 покажем, как сделать комбинацию символов параметром, которому присваивается значение в ходе выполнения программы. Программа также содержит новый вариант функции getline; вам может оказаться полезным сравнить его с вариантом из главы 2.

#define maxline 1000

main() /* find all lines matching a pattern */

{

char line[maxline];

while (getline(line, maxline) > 0)

if (index(line, "the") >= 0)

printf("%s", line);

}

// Поместить строку в s и возвратить длину

int getline(char s[],int lim)

{

int c, i;

i = 0;

while(--lim>0 && (c=getchar()) != eof && c != '\n')

s[i++] = c;

if (c == '\n')

s[i++] = c;

s[i] = '\0';

return(i);

}

// Вернуть индекс t в s, или -1 в противном случае

int index(char s[], char t)

{

int i, j, k;

for (i = 0; s[i] != '\0'; i++)

{

for(j=i,k=0; t[k]!='\0' && s[j]==t[k]; j++,k++)

;

if (t[k] == '\0')

return(i);

}

return(-1);

}

Каждая функция имеет вид имя (список аргументов, если они имеются) описания аргументов, если они имеются, и

{

... // Описания и операторы, если они имеются

}

Как и указывается, некоторые части могут отсутствовать.

Минимальной функцией является:

dummy()

{ } ,

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

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

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

return (выражение) .

Вызывающая функция может игнорировать возвращаемое значение, если она этого пожелает. Более того, после return может не быть вообще никакого выражения; в этом случае в вызывающую программу не передается никакого значения. Управление также возвращется в вызывающую программу без передачи какого-либо значения и в том случае, когда при выполнении мы «проваливаемся» на конец функции, достигая закрывающейся правой фигурной скобки. Eсли функция возвращает значение из одного места и не возвращает никакого значения из другого места, это не является незаконным, но может быть признаком каких-то неприятностей. В любом случае «значением» функции, которая не возвращает значения, несомненно, будет мусор . Отладочная программа Lint проверяет такие ошибки.

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

1. В системе Unix , например, эту работу выполняет команда cc, упомянутая в главе 2. Предположим, что три функции находятся в трех различных файлах с именами main.с, getline.c и index.с . Тогда команда:

cc main.c getline.c index.c

компилирует эти три файла, помещает полученный настраиваемый объектный код в файлы main.o, getline.o и index.o и загружает их всех в выполняемый файл, называемый a.out .

Если имеется какая-то ошибка, скажем в main.c, то этот файл можно перекомпилировать отдельно и загрузить вместе с предыдущими объектными файлами по команде

cc main.c getline.o index.o

Команда cc использует соглашение о наименовании: суффиксы «.с» и «.о» для того, чтобы отличить исходные файлы от объектных.

2. В системe Windous XP при использовании оболочки Visual Studio и среды программирования Visual C++ используется прогрессивный «проектный» подход: в состав «рабочего пространства проекта» – Workspace в число исходных файлов – Source Files (см. рис. 1.1) нужно включить только исходные модули с суффиксами «.сpp»: main.сpp, getline.cpp и index.сpp. Решение о том, что нужно перекомпилировать, а что не нужно, – принимает оболочка Visual Studio , причем без дополнительного набора каких-либо команд, как этого, например, требует Unix .

Упражнение 5.1 . Составьте программу для функции rindex(s,t), которая возвращает позицию самого правого вхождения t в s, и –1, если s не содержит t.

5.2. Функции, возвращающие нецелые значения

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

while (getline(line, maxline) > 0)

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

Но что происходит, если функция должна возвратить значение какого-то другого типа? Многие численные функции, такие как sqrt, sin и cos возвращают double – значение с плавающей точкой, с двойной точностью. Другие специальные функции возвращают значения других типов. Чтобы показать, как поступать в этом случае, давайте напишем и используем функцию atоf(s), которая преобразует строку s в эквивалентное ей плавающее число двойной точности.

Пример 5-2 . Функция atоf является расширением атоi, варианты которой мы написали в главах 3 и 4; она обрабатывает необязательно знак и десятичную точку, а также целую и дробную часть, каждая из которых может как присутствовать, так и отсутствовать (эта процедура преобразования ввода не очень высокого качества; иначе она бы заняла больше места, чем нам хотелось бы).

Во-первых, сама atоf должна описывать тип возвращаемого ею значения, поскольку он отличен от int. Так как в выражениях тип float преобразуется в double, то нет никакого смысла в том, чтобы atоf возвращала float; мы можем с равным успехом воспользоваться дополнительной точностью, так что мы полагаем, что возвращаемое значение типа double. Имя типа должно стоять перед именем функции, как показывается ниже:

// Преобразование строки s в число с двойной точностью

double atof(char s[])

{

double val, power;

int i, sign;

for(i=0;s[i]==' ' || s[i]=='\n' || s[i]=='\t'; i++)

; // Игнорирование символов-разделителей

sign = 1;

if (s[i] == '+' || s[i] == '-') // Знак числа

sign = (s[i++] == '+') ? 1 : -1;

for (val = 0; s[i] >= '0' && s[i] <= '9'; i++)

val = 10 * val + s[i] - '0';

if (s[i] == '.')

i++;

for (power = 1; s[i] >= '0' && s[i] <= '9'; i++)

{

val = 10 * val + s[i] - '0';

power *= 10;

}

return(sign * val / power);

}

Пример 5-3 . Вторым, но столь же важным, является то, что вызывающая функция должна объявить о том, что atof возвращает значение, отличное от int типа. Такое объявление демонстрируется на примере следующего примитивного настольного калькулятора (едва пригодного для подведения баланса в чековой книжке), который считывает по одному числу на строку, причем это число может иметь знак, и складывает все числа, печатая сумму после каждого ввода.

#define maxline 100

main() // Примитивный калькулятор

{

double sum, atof();

char line[maxline];

sum = 0;

while (getline(line, maxline) > 0)

printf("\t=%3.2f\n",sum+=atof(line));

}

Описание:

double sum, atof();

говорит, что sum является переменной типа double , и что atof является функцией, возвращающей значение типа double. Эта мнемоника означает, что значениями как sum, так и atof(...) являются плавающие числа двойной точности.

Если функция atof не будет описана явно в обоих местах, то в «C» предполагается, что она возвращает целое значение, и вы получите бессмысленный ответ. Если сама atof и обращение к ней в main имеют несовместимые типы и находятся в одном и том же файле, то это будет обнаружено компилятором. Но если atof была скомпилирована отдельно /что более вероятно/, то это несоответствие не будет зафиксировано, так что atof будет возвращать значения типа double, с которым main будет обращаться, как с int, что приведет к бессмысленным результатам (программа Lint вылавливает такую ошибку).

Имея функцию atof, мы, в принципе, могли бы с ее помощью написать atoi (преобразование строки в int):

atoi(char s[]) // Преобразование строки в целое число

{

double atof();

return(atof(s));

}

Обратите внимание на структуру описаний и оператор return. Значение выражения в конструкции:

return (выражение)

всегда преобразуется к типу функции перед выполнением самого возвращения. Поэтому при появлении в операторе return значение функции atof, имеющее тип double, автоматически преобразуется в int, поскольку функция atoi возвращает int. (Как обсуждалось в главе 3, преобразование значения с плавающей точкой к типу int осуществляется посредством отбрасывания дробной части).

Упражнение 5-2 . Расширьте atof таким образом, чтобы она могла работать с числами вида 123.45е-6 где за числом с плавающей точкой может следовать «е» и показатель «экспоненты», возможно – со знаком.

5.3. Еще об аргументах функций

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

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

Между прочим, не существует полностью удовлетворительного способа написания переносимой функции с переменным числом аргументов. Дело в том, что нет переносимого способа, с помощью которого вызванная функция могла бы определить, сколько аргументов было фактически передано ей в данном обращении. Таким образом, вы, например, не можете написать действительно переносимую функцию, которая будет вычислять максимум от произвольного числа аргументов, как делают встроенные функции MAX в ФОРТРАНЕ и PL/1.

Обычно со случаем переменного числа аргументов безопасно иметь дело, если вызванная функция не использует аргументов, которые ей на самом деле не были переданы, и если типы согласуются. Самая распространенная в языке «C» функция с переменным числом – это printf. Она получает из первого аргумента информацию, позволяющую определить количество остальных аргументов и их типы. Функция printf работает совершенно неправильно, если вызывающая функция передает ей недостаточное количество аргументов, или если их типы не согласуются с типами, указанными в первом аргументе. Эта функция не является переносимой и должна модифицироваться при использовании в различных условиях.

Если же типы аргументов известны, то конец списка аргументов можно отметить, используя какое-то соглашение; например, считая, что некоторое специальное значение аргумента (часто нуль или –1) является признаком конца аргументов.

5.4. Внешние переменные

Программа на языке «C» состоит из набора внешних объектов, которые являются либо переменными, либо функциями. Термин «внешний» используется главным образом в противопоставление термину «внутренний», которым описываются аргументы и автоматические переменные, определенные внутри функций. Внешние переменные определены вне какой-либо функции и, таким образом, потенциально доступны для многих функций. Сами функции всегда являются внешними, потому что правила языка «C» не разрешают определять одни функции внутри других. По умолчанию внешние переменные являются также и «глобальными», так что все ссылки на такую переменную, использующие одно и то же имя (даже из функций, скомпилированных независимо), будут ссылками на одно и то же. В этом смысле внешние переменные аналогичны переменным COМMON в ФОРТРАНЕ и EXTERNAL в PL/1. Позднее мы покажем, как определить внешние переменные и функции таким образом, чтобы они были доступны не глобально, а только в пределах одного исходного файла.

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

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

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

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

Давайте продолжим обсуждение этого вопроса на большом примере. Задача будет состоять в написании другой программы для калькулятора, лучшей, чем предыдущая. Здесь допускаются операции +, -, ´, / и знак = (для выдачи ответа). Вместо инфиксного представления калькулятор будет использовать обратную польскую нотацию, поскольку ее несколько легче реализовать. В обратной польской нотации знак следует за операндами; инфиксное выражение типа:

(1-2) ´ 4+5)=

записывается в виде

12-45+´= .

круглые скобки при этом не нужны

Реализация оказывается весьма простой. Каждый операнд помещается в стек; когда поступает знак операции, нужное число операндов (два для бинарных операций) вынимается, к ним применяется операция и результат направляется обратно в стек. Так, в приведенном выше примере, числа 1 и 2 помещаются в стек, а затем заменяются их разностью, -1. После этого 4 и 5 вводятся в стек и затем заменяются своей суммой, 9. Далее числа -1 и 9 заменяются в стеке на их произведение, равное -9. Операция = печатает верхний элемент стека, не удаляя его (так что промежуточные вычисления могут быть проверены).

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

while (операция или операнд, но не конец файла)

if (число)

поместить его в стек

еlse if ( операция )

вынуть операнды из стека

выполнить операцию

поместить результат в стек

else

ошибка

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

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

#define maxop 20 // Макс. размер операнда, оператора

#define number '0' // Признак числа

#define toobig '9' // Сигнал, что строка велика

main() // Калькулятор в обратной польской нотации

{

int tupe;

char s[maxop];

double op2,atof(),pop(),push();

while ((tupe=getop(s,maxop)) !=eof);

switch(tupe)

{

case number:

push(atof(s));

break;

case '+':

push(pop()+pop());

break;

case '´':

push(pop()*pop());

break;

case '-':

op2=pop();

push(pop()-op2);

break;

case '/':

op2=pop();

if (op2 != 0.0)

push(pop()/op2);

else

printf("Ошибка: деление на 0\n");

break;

case '=':

printf("\t%f\n",push(pop()));

break;