Programirovanie na c by EKSMO.DIY EKSMO.DIY

ОГЛАВЛЕНИЕ

Предисловие .................................................................................................................................................... 12 Глава 1. Введение в программирование .............................................................................................. 14 1.1. Программирование...................................................................................................................... 14 Старт программы ............................................................................................................... 14 1.1.1. Ввод, компиляция, запуск ................................................................................... 16 1.1.2. Алгоритм .................................................................................................................... 17 1.1.4. Язык C++ ................................................................................................................... 18 1.1.5. Контрольные вопросы .......................................................................................... 23 1.2. Основа программы ...................................................................................................................... 23 1.2.1. Комментарии ............................................................................................................ 24 1.2.2. Команды ..................................................................................................................... 27 1.2.3. Блоки ........................................................................................................................... 27 1.3. Переменные .................................................................................................................................... 28 1.3.1. Объявление переменных ..................................................................................... 29 1.3.2. Область действия ................................................................................................... 30 1.3.3. Правила именования и синтаксис .................................................................... 32 1.3.4. Типы переменных ................................................................................................... 34 1.3.5. Синтаксис объявления переменных................................................................ 46 1.3.6. Константы ................................................................................................................. 47 1.4. Обработка ........................................................................................................................................ 56 1.4.1. Присваивание........................................................................................................... 57 1.4.2. Мастер вычислений ............................................................................................... 58 1.4.3. Сокращения .............................................................................................................. 59 1.4.4. Понятие «функция» на примере функции случайных чисел ................ 62 1.4.5. Преобразование типа ............................................................................................ 64 1.5. Ввод и вывод .................................................................................................................................. 65 1.5.1. Потоковый вывод командой cout .................................................................... 66 1.5.2. Форматированный вывод.................................................................................... 68 1.5.3. Потоковый ввод командой cin.......................................................................... 68 1.6. Практические задания ............................................................................................................... 69 Глава 2. Циклическое программное управление ............................................................................. 70 2.1. Ветвление......................................................................................................................................... 71 2.1.1. По условию: if ........................................................................................................ 71 2.1.2. Иначе: else ............................................................................................................... 73 2.1.3. Вариант за вариантом: switch case ............................................................... 77 2.1.4. Короткая проверка с помощью символа вопросительного знака............... 82 2.2. Булевы выражения...................................................................................................................... 83 2.2.1. Переменные и константы .................................................................................... 84 2.2.2. Операторы ................................................................................................................. 84 2.2.3. Объединение булевых выражений .................................................................. 87

Оглавление

2.3. Постоянные повторения: циклы ........................................................................................... 94 2.3.1. Цикл с предусловием: while .............................................................................. 94 2.3.2. Цикл с постусловием: do-while ....................................................................... 98 2.3.3. Шаг за шагом: for................................................................................................... 99 2.3.4. Выходы из цикла: break и continue.............................................................102 2.3.5. Грубый скачок: goto ............................................................................................105 2.4. Примеры.........................................................................................................................................106 2.4.1. Простые числа .......................................................................................................106 2.4.2. Наибольший общий делитель..........................................................................112 2.5. Упражнения ..................................................................................................................................115 Глава 3. Типы данных и структур.........................................................................................................116 3.1. Массив.............................................................................................................................................116 3.1.1. Сортировка методом «пузырька» ...................................................................121 3.1.2. Присваивание в массивах ..................................................................................125 3.1.3. Символьные последовательности языка C .................................................127 3.1.4. Пример: определение числового значения введенного символа ........128 3.1.5. Многомерный массив .........................................................................................131 3.1.6. Пример: игра «Бермуда» ....................................................................................132 3.2. Указатель и адрес........................................................................................................................135 3.2.1. Косвенный доступ ................................................................................................139 3.2.2. Массивы и указатели ..........................................................................................140 3.2.3. Арифметика для указателей .............................................................................142 3.2.4. Константный указатель ......................................................................................144 3.2.5. Анонимный указатель.........................................................................................145 3.3. Объединение переменных: struct.....................................................................................146 3.3.1. Пример: игра «Бермуда» ....................................................................................150 3.4. Динамические структуры.......................................................................................................152 3.4.1. Выделение и освобождение памяти...............................................................152 3.4.2. Создание массивов во время выполнения программы ...........................154 3.4.3. Связанные списки ................................................................................................154 3.5. Объединение ................................................................................................................................157 3.6. Перечисляющий тип enum......................................................................................................158 3.7. Определение типов....................................................................................................................160 Глава 4. Функции ........................................................................................................................................161 4.1. Параметры .....................................................................................................................................166 4.1.1. Прототипы...............................................................................................................169 4.1.2. Указатель в качестве параметра ......................................................................170 4.1.3. Массив в качестве параметра ...........................................................................172 4.1.4. Ссылочный параметр ..........................................................................................174 4.1.5. Пример: стек ...........................................................................................................176 4.1.6. Предопределенные параметры ........................................................................178 4.1.7. Параметры функции main .................................................................................179 4.1.8. Переменное количество параметров .............................................................181 4.2. Перегрузка функций.................................................................................................................183 4.3. Коротко и быстро: встроенные функции.........................................................................183 4.4. Нисходящий метод....................................................................................................................185 4.4.1. Пример: игра «Бермуда» ....................................................................................186

Оглавление

4.5. Область действия переменных ............................................................................................191 4.5.1. Глобальные переменные ....................................................................................191 4.5.2. Локальные переменные ......................................................................................192 4.5.3. Статические переменные ...................................................................................193 4.6. Рекурсивные функции.............................................................................................................195 4.6.1. Область действия .................................................................................................197 4.6.2. Пример: бинарное дерево ..................................................................................198 4.6.3. Игра «Ханойская башня» ..................................................................................202 4.6.4. Пример: калькулятор ..........................................................................................204 4.7. Указатель функции....................................................................................................................211 Глава 5. Классы.............................................................................................................................................213 5.1. Классы и структуры данных .................................................................................................214 5.1.1. Союз функции и структуры данных..............................................................215 5.1.2. Доступ к элементам класса ...............................................................................219 5.2. Создание и удаление объекта ...............................................................................................220 5.2.1. Конструктор и деструктор ................................................................................220 5.2.2. Конструктор и параметры .................................................................................222 5.3. Доступная и скрытая области...............................................................................................225 5.3.1. private и public ..................................................................................................225 5.3.2. Пример: стек ...........................................................................................................229 5.3.3. Друзья .......................................................................................................................232 5.4. Конструктор копирования .....................................................................................................233 5.5. Перегрузка элементных функций ......................................................................................237 5.6. Выбор: перегрузка операторов .............................................................................................238 5.6.1. Сложение .................................................................................................................240 5.6.2. Глобальные операторные функции................................................................242 5.6.3. Инкремент и декремент .....................................................................................243 5.6.4. Оператор присваивания .....................................................................................245 5.6.5. Оператор сравнения ............................................................................................249 5.6.6. Оператор вывода...................................................................................................251 5.6.7 Оператор индекса ..................................................................................................252 5.6.8. Оператор вызова () .............................................................................................254 5.6.9. Оператор конвертирования ..............................................................................255 5.7. Атрибуты........................................................................................................................................256 5.7.1. Статические переменные и функции в классах ........................................256 5.7.2. Константы ...............................................................................................................258 5.8. Наследование ...............................................................................................................................261 5.8.1. Доступ к предкам ..................................................................................................265 5.8.2. Конструкторы и присваивание........................................................................269 5.8.3. Многократное наследование ............................................................................271 5.8.4. Полиморфизм посредством виртуальных функций ...............................272 5.9. Определение классов и синтаксический граф ..............................................................283 Глава 6. Инструменты программирования ......................................................................................285 6.1. Компилятор C++........................................................................................................................285 6.1.1. Вызов компилятора .............................................................................................285 6.1.2. Свойства компилятора .......................................................................................286 6.1.3. Сообщения об ошибках ......................................................................................287

Оглавление

6.2. Препроцессор...............................................................................................................................289 6.2.1. Связывание файлов: #include ........................................................................290 6.2.2. Константы и макросы: #define .........................................................................290 6.2.3. Опросы: #if ............................................................................................................293 6.2.4. Предопределенные макросы ............................................................................294 6.2.5. Другие препроцессорные команды ................................................................295 6.3. Разделение исходного кода....................................................................................................296 6.3.1. Пример: игра «Бермуда» ....................................................................................296 6.3.2. Распознавание файлов........................................................................................299 6.3.3. Объявление и определение ...............................................................................300 6.3.4. Заголовочные файлы ..........................................................................................301 6.3.5. Статические функции .........................................................................................303 6.3.6. Скрытая реализация ............................................................................................303 6.4. Компоновщик и библиотеки.................................................................................................305 6.4.1. Подключение статических библиотек ..........................................................305 6.4.2. Динамические библиотеки ...............................................................................306 6.5. Программа make ..........................................................................................................................309 6.5.1. Макросы в make-файле ......................................................................................312 6.5.2. Несколько строк....................................................................................................314 6.6. Отладка с помощью GNU Debugger ..................................................................................314 Глава 7. Другие элементы языка C++ ................................................................................................317 7.1. Обобщенное программирование .........................................................................................317 7.1.1. Шаблонные функции ..........................................................................................318 7.1.2. Шаблоны классов .................................................................................................321 7.1.3. Макропрограммирование с помощью команды #define ........................325 7.2. Пространство имен....................................................................................................................327 7.2.1. Определение пространства имен ....................................................................328 7.2.2. Доступ .......................................................................................................................329 7.2.3. Особые пространства имен ...............................................................................329 7.2.4. Анонимное пространство имен .......................................................................330 7.2.5. Граф синтаксиса ....................................................................................................331 7.3. Защита от сбоев при помощи ключевых слов try и catch .....................................332 7.3.1. Создание собственных исключительных ситуаций ................................333 7.3.2. Разработка классов ошибок ..............................................................................337 7.3.3. Исключения стандартных библиотек ...........................................................341 7.4. Низкоуровневое программирование .................................................................................347 7.4.1. Битовые операторы..............................................................................................347 7.4.2. Операторы сдвига .................................................................................................350 7.4.3. Доступ по аппаратным адресам.......................................................................351 7.4.4. Битовые структуры ..............................................................................................352 Глава 8. Библиотеки ...................................................................................................................................354 8.1. Символьные последовательности и строки ...................................................................354 8.1.1. Стандартный класс string ...............................................................................355 8.1.2. Другие библиотеки строк ..................................................................................368 8.1.3. Классические функции языка C .....................................................................369 8.2. Класс iostream для продвинутых......................................................................................376 8.2.1. Ввод командой cin ...............................................................................................376 8.2.2. Манипуляторы ......................................................................................................378

Оглавление

8.3. Операции с файлами ................................................................................................................381 8.3.1. Открытие и закрытие ..........................................................................................382 8.3.2. Чтение и запись .....................................................................................................384 8.3.3. Наблюдение состояния ......................................................................................390 8.3.4. Доступ к файлам в стандарте ANSI C ...........................................................392 8.3.5. Команды файловой системы ............................................................................395 8.3.6. Получение свойств файла .................................................................................398 8.4. Математические функции .....................................................................................................401 8.4.1. Стандартная математическая библиотека ..................................................401 8.4.2. Комплексные числа .............................................................................................404 8.5. Функции времени ......................................................................................................................405 8.5.1. Дата и время ...........................................................................................................405 8.5.2. Остановка времени ..............................................................................................407 Глава 9. Стандартная библиотека шаблонов (STL) .....................................................................410 9.1. Контейнер класса vector .......................................................................................................410 9.1.1. Изменение размера ..............................................................................................412 9.1.2. Итераторы ...............................................................................................................414 9.1.3. Другие функции ....................................................................................................415 9.2. Контейнер класса deque..........................................................................................................417 9.3. Контейнер класса list ............................................................................................................420 9.3.1. Добавление и удаление элементов .................................................................421 9.3.2. Перемещение элементов: splice....................................................................423 9.3.3. Добавление отсортированного списка..........................................................424 9.3.4. Сортировка и последовательность .................................................................425 9.4. Контейнер классов set и multiset ...................................................................................427 9.4.1. Добавление и удаление.......................................................................................427 9.4.2. Поиск и сортировка .............................................................................................428 9.5. Контейнер классов map и multimap ...................................................................................430 9.6. Контейнер-адаптер ....................................................................................................................432 9.6.1. Контейнер-адаптер stack..................................................................................433 9.6.2. Контейнер-адаптер queue..................................................................................434 9.6.3. Контейнер-адаптер priority_queue ............................................................435 9.7. Типы итераторов.........................................................................................................................436 9.8. Алгоритмы библиотеки STL .................................................................................................437 9.8.1. Поиск: find()...........................................................................................................437 9.8.2. Сортировка .............................................................................................................438 9.8.3. Двоичный поиск....................................................................................................440 9.8.4. Копирование: copy() ..........................................................................................440 9.8.5. Перестановка: reverse() ..................................................................................441 9.8.6. Заполнение: fill()................................................................................................441 9.8.7. Функция equal().................................................................................................442 9.8.8. Функция в качестве параметра: find_if() ..................................................442 9.8.9. Функция for_each ..............................................................................................446 9.9. Класс шаблона bitset .............................................................................................................447 Приложение А. Язык C++ для тех, кто торопится.......................................................................448 А.1. Программа ....................................................................................................................................448 А.2. Условия и циклы........................................................................................................................452

Оглавление

А.2.1. Условия и булевы выражения .........................................................................453 А.2.2. Цикл while.............................................................................................................455 А.2.3. Цикл for .................................................................................................................456 А.3. Массивы ........................................................................................................................................457 А.4. Функции .......................................................................................................................................462 А.4.1. Разделение программ .........................................................................................462 А.4.2. Возвращаемое значение ....................................................................................465 А.4.3. Параметры ..............................................................................................................466 А.5. Классы ............................................................................................................................................470 А.5.1. Конструктор...........................................................................................................474 А.5.2. Наследование ........................................................................................................479 А.5.3. Полиморфизм .......................................................................................................481 А.6. Шаблоны.......................................................................................................................................483 Приложение Б. Устройство компилятора ........................................................................................486 Б.1. KDevelop .......................................................................................................................................486 Б.1.1. Новый проект ........................................................................................................486 Б.1.2. Компиляция и старт ...........................................................................................488 Б.2. Bloodshed Dev-C++ ..................................................................................................................489 Б.2.1. Установка ................................................................................................................489 Б.2.2. Создание проекта .................................................................................................489 Б.2.3. Компиляция и старт ...........................................................................................492 Б.3. Cygwin ............................................................................................................................................493 Приложение В. Примеры решений задач ........................................................................................495 Контрольные вопросы .....................................................................................................................495 Функция ggt() ...................................................................................................................................495 Программа НДС .................................................................................................................................496 Программа НДС с проверкой ввода ..........................................................................................497 Сложный процент..............................................................................................................................498 Угадывание чисел...............................................................................................................................498 Отсортированные числа лото .......................................................................................................499 Оптимизированная сортировка методом «пузырька» ......................................................501 Ввод дроби ............................................................................................................................................502 Функция swap .....................................................................................................................................503 Локальный стек...................................................................................................................................504 Игра «Бермуда»: поиск кораблей ...............................................................................................506 Поиск в бинарном дереве ...............................................................................................................507 Калькулятор для float......................................................................................................................508 Вопрос к знаку минус.......................................................................................................................510 Буфер: FIFO .........................................................................................................................................511 Пример стека в качестве списка ..................................................................................................513 Функция atof() с десятичной запятой...................................................................................515 Приложение Г. Глоссарий........................................................................................................................517 Приложение Д. Литература....................................................................................................................524 Предметный указатель .............................................................................................................................526

Глава 2 ЦИКЛИЧЕСКОЕ ПРОГРАММНОЕ УПРАВЛЕНИЕ Игра пришла в движенье.

До сих пор программы состояли только из следующих друг за другом команд. Даже указания по приготовлению кофе можно было описать последовательностью действий: Поставить новый одноразовый бумажный фильтр в кофеварку Насыпать 6 ложек молотого кофе в фильтр Налить в кофеварку 1 литр воды Включить кофеварку Подождать Выключить кофеварку Взять кофейник с напитком На самом деле это далеко не полное описание процесса. На практике действия выполняются в зависимости от состояния переменных и отдельные блоки повторяются. Подробное описание процесса приготовления кофе выглядит следующим образом: Если в кофеварке находиться уже использованный одноразовый бумажный фильтр { Вынуть его из кофеварки Выкинуть в мусорный бак } Вынуть новый фильтр из пачки фильтров Вставить фильтр в кофеварку Повторить 6 раз: { Насыпать ложку молотого кофе в фильтр

Циклическое программное управление

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

2.1. Ветвление Есть различные причины, из-за которых программа, в зависимости от значения определенных переменных, не должна выполнять те или иные операции. Приведу несколько типичных примеров: •

Совершенно очевидно, что программа не должна производить деление, когда знаменатель равен 0.

•

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

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

2.1.1. По условию: if С помощью команды if1 можно исключить выполнение отдельных частей кода. Синтаксис команды if описан на рис. 2.1. 1

В пер. с англ. «если» или «в случае». Прим. ред.

Глава 2

Рис. 2.1. Синтаксис команды if

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

Рис. 2.2. Граф блока команд

Надежнее всего команды и блоки команд, следующие после условия или объявления цикла, отделять от основного кода. Некоторые редакторы делают это автоматически. Для отделения можно использовать табуляцию или пробелы. Если используются несколько различных редакторов или систем, лучше производить разделение с помощью знаков пробела, поскольку табуляцию различные редакторы интерпретируют по-разному. В первом примере показано деление двух переменных. Если бы делитель был равен 0, это привело бы к сбою программы. Поэтому осторожный программист перед расчетом организует проверку, равен ли делитель 0. Знак неравенства состоит из символов !=. if (denominator != 0) result = numerator / denominator; Листинг 2.1. Проверка

Деление будет произведено только в том случае, если условие выполняется, то есть делитель не равен нулю. После команды if может стоять еще одно условие. Оно будет проверено только в том случае, если выполняется первое. Такие последова-

Циклическое программное управление

тельности называются вложением. В следующем примере представлены вложения операторов if. Здесь переменные проверяются на равенство. Знак равенства состоит из символов ==, это сделано для того, чтобы можно было легко отличать проверку от операции присваивания. c=2; if (a==0) if (b==0) c=0; cout << c << endl; Листинг 2.2. Вложения оператора if

Проверка, содержит ли переменная b ноль, будет выполнена только в том случае, если переменная a содержит 0. И только если значения обеих переменных равны 0, переменной c тоже будет присвоен 0. Иначе ее значение будет и в дальнейшем равняться 2.

2.1.2. Иначе: else Вернемся к примеру с делением. Было бы здорово, если бы программа не только проверяла, равен ли делитель 0, но и информировала бы пользователя о том, что деление в таком случае не было произведено. Это сообщение должно появляться только тогда, когда условие не выполняется. Такой результат можно получить при использовании двух конструкций if. if (denominator != 0) result = numerator / denominator; if (denominator == 0) cout << "Делитель равен 0! Расчет невозможен!"; Листинг 2.3. Проверка двух противоположных условий

Когда то и дело требуются такие конструкции, язык C++ предлагает особую команду для случаев, когда условие в скобках оператора if не выполняется. Команда обозначается ключевым словом else.

Глава 2

if (denominator != 0) result = numerator / denominator; else cout << "Делитель равен 0! Расчет невозможен!"; Листинг 2.4. Упрощенная проверка противоположного условия

На рис. 2.3 показан полный граф синтаксиса для if - else.

Рис. 2.3. Граф синтаксиса if - else

Структурные диаграммы Код программ, в которых часто используются вложенные условия и циклы, быстро становится плохо читаемым. Чтобы процесс выполнения программы представить наглядно, используются различные диаграммы. В этой книге используется диаграмма Насси-Шнейдермана. Такие диаграммы являются чем-то вроде дизайнерского инструмента для разработки четко структурированных программ. В диаграмме Насси-Шнейдермана программа представлена в виде большого прямоугольника. Каждая часть программы начинается сверху и заканчивается внизу. Никаких других выходов из программы больше нет. Программа, в которой нет проверок какого-либо условия и структур контроля, выглядит как кирпичная стена (рис. 2.4).

Рис. 2.4. Простая структурная диаграмма

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

Циклическое программное управление

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

Рис. 2.5. Вложенное условие if в виде структурной диаграммы

Рассмотрим структурную диаграмму на примере программы для отдела банка. Обычно клиент получает 3% от вклада. Если деньги лежат на счете больше трех лет, клиент получает 4%, а если больше шести лет — 5%.

Рис. 2.6. Начисление процентов в виде структурной диаграммы

Эта диаграмма может сразу же быть описана программно:

ПРЕДМЕТНЫЙ УКАЗАТЕЛЬ

ASCII, 40 bool, 84

map, 430 multiset, 427 mutable, 260

case, 79

new, 138, 152

catch, 332 char, 40 cin, 68, 377 class, 214 const, 55 continue, 104 cout, 66 C-строка, 374

default, 80 double, 43 do-while, 98

else, 73 end of file, 377 enum, 158 exeption, 341 explicit, 224 extern, 301

false, 84 float, 42 for, 100 friend, 232

if, 71 include, 66 inline, 184 int, 29 list, 419, 420 long, 36

make, 289, 309

526

priority_queue, 433 private, 225 protected, 265 public, 225 queue, 433 return, 161 set, 427 short, 36 stack, 433 static, 256, 303 STL, 410 string, 127 struct, 146 switch, 79

this, 219 throw, 333 true, 84 try, 332 typedef, 160 typename, 318 unsigned, 36 vector, 411 virtual, 275 void, 163

wchar_t, 40 while, 94

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

Абстрактные базовые классы, 279, 280 Алгоритм, 18 Анонимное пространство имен, 330

Базовый класс, 261 Байт, 35 Бибилиотека, 17 Бинарное дерево, 198 Бит, 35 Блок, 27 Булевые выражения, 83 Двусвязный список, 420 Декремент, 243 Деструктор, 220 Инкремент, 243 Интерфейс, 229

Класс, 214

Объявление, 300 Оператор адреса, 137 Оператор вызова, 254 Оператор индекса, 252 Определение, 300 Отладчик, 165

Параметры, 163 Перегрузка операторов, 240 Переменная, 28 Полиморфизм, 278 Предикат, 423 Предопределенные параметры, 178 Препроцессор, 16, 291 Префикс, 61, 243 Присваивание, 57 Пространство имен, 66, 328 Прототип, 165, 288 Рекурсия, 195

Классы ошибок, 337 Комментарии, 24 Компановщик, 17, 289 Компилятор, 16 Константа, 47 Конструктор, 220 Конструктор копирования, 234 Контейнер, 410 Контейнер-адаптер, 433

Связанный список, 155

Макрос, 291, 321 Манипулятор, 68 Массив, 116 Математические функции, 401 Многомерный массив, 131

Указатель, 135 Указатель функции, 211

Символьная последовательность, 127 Сортировка методом пузырька, 122 Сортировка пузырьком, 122 Ссылка, 174 Стандартный конструктор, 220 Статические переменные, 193 Стек, 165

Файл, 381

Наследование, 261

Файл объекта, 16 Форматированный вывод, 68 Функция, 62, 161

Общение. См. Обсуждение

Цикл, 94

Объектно-ориентированное программирование, 21, 213

Элементная функция, 216