004.42(075.

4)
 32.973.26
 45

Arnold Willemer
Einstieg in C++
© 2012 by Galileo Press Galileo Computing is an imprint of Galileo Press,
Bonn (Germany), Boston (USA) German Edition first published 2012 by Galileo Press.
Titel of the German Edition “Einstieg in C++” ISBN of the German Edition
978-3-8362-1385-1 All rights reserved. Neither this publication nor any part of it may
be copied or reproduced in any form or by any means or translated into another language,
without the prior consent of Galileo Press, Rheinwerkallee 4, 53227 Bonn, Germany.
Galileo Press makes no warranties or representations with respect to the content hereof
and specifically disclaims any implied warranties of merchantability or fitness
for any partiand specifically disclaims any implied warranties of merchantability
or fitness for any particular purpose. Galileo Press assumes no responsibility
for any errors that may appear in this publication.

 .
 45 
     ++ / .   ; [.  . . . -
]. — . :  , 2013. — 528 . + CD. — (     
).
ISBN 978-5-699-65451-2
, ! "# $, !  "! % 
    ++   &-
     
   %  '  %$,  *  '  
.  
"*%  <          %$,  $ ,  
*  , =      ,    & $, ! % < .  -
  *   %     $  % *    
<   (STL). 
  " * > $  %$   *"
> %$ 

   %.

 004.42(075.4)
 32.973.26

 $ % 
>  *"  %%% $
    

  "? > & .
@ % !  %?
$* %    > F%>   #    $*
       &        * , "*  ' 
 > ! , !% &       $   
    ,  
'   
$< % HHH «J$* « ».

©  . .,    , 2013

ISBN 978-5-699-65451-2 © .  «! «"», 2013
 ОГЛАВЛЕНИЕ

Предисловие .................................................................................................................................................... 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

5
Оглавление

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

6
 Оглавление

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

7
Оглавление

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
 Оглавление

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

9
Оглавление

А.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
 Дорогие читатели, я могу лишь настоятельно порекомендовать эту
книгу, если вы собираетесь изучать язык программирования C++. Она
пригодится и как техническое пособие, дополнительно к учебному кур-
су, и как материал для самостоятельного изучения языка программи-
рования. Эта книга получила множество положительных отзывов от ее
читателей. Так как же можно объяснить такой успех?

Авторы книг для начинающих отказываются от всего, что выглядит

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

Этим и отличается книга Арнольда Виллемера от других вводных

пособий. Шаг за шагом автор сопровождает вас на пути к профессио-
нальному программированию на языке C++: основательно, компетент-
но и, конечно, всегда с примерами.

При этом Арнольд Виллемер всегда работает с наглядной структу-

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

Чтобы гарантировать качество книг, мы всегда ставим высокие тре-

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

Читайте с удовольствием!

Штефан Маттешек,
Галилео Компьютинг
 ПРЕДИСЛОВИЕ

Да, я знаю, уже существует огромное количество книг по C++. Во-

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

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

Предполагаю, вы знаете, что такое компьютер, умеете как-то с ним

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

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

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

Также я использовал диаграмму Насси-Шнейдермана, поскольку

полагаю, что она хорошо передает четко структурированный процесс,
описанный в главе 2.

В приложении вы найдете краткий экскурс в C++. Он предназначен

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

1 Бьерн Страуструп. Язык программирования С++. М.: Бином, 2011. Прим. ред.

12
 Предисловие

темы освещены очень кратко, однако везде указаны ссылки на соответ-

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

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

той или иной программы вы найдете в файле с соответствующим име-
нем на диске, прилагающемся к книге.

Для улучшения читаемости текста применено следующее форма-

тирование: переменные и классы выделены полужирным шрифтом
Courier, команды, функции (например, open()) и листинги программ
выделены шрифтом Courier, функции описываются со скобками после
имени, определения, имена файлов и пути выделены курсивом.

Поскольку я работаю программистом C++, в этой книге везде встре-

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

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

Помимо моих читателей, я также хочу поблагодарить Штефана

Маттешека. Он разрешил мне все последующие вольности. Фреде-
рике Денеке исправил мои ужасные преступления против немецкого
языка. Штефи Ерентраут сделала так, чтобы книга выглядела красиво.
Кристоф Кехер позаботился о втором издании книги. Остается только
упомянуть, что впервые я столкнулся с языком C++ благодаря профес-
сору Марио Дал Син. Он помог мне набраться смелости для этой кни-
ги. Я также благодарю Штефана Энгельманна за его советы. И еще раз
огромное спасибо всем вам, читатели!

Я надеюсь, что эта книга будет хорошим сопровождающим пособием

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

Арнольд Виллемер,
Норгардхольц
 Глава 1
ВВЕДЕНИЕ В ПРОГРАММИРОВАНИЕ
Программирование — вытачивание монумента
без пыли и осколков.

Итак, вы хотите изучать программирование. Вероятно, у вас уже

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

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

Старт программы

Программа — это, прежде всего, файл, содержащий команды, ко-

торым должен следовать компьютер. Этот файл обычно находится на
жестком диске или отдельном носителе. При запуске программы снача-
ла происходит ее загрузка в оперативную память, только там она может
начать выполнение. Запущенная программа называется процессом. Она
будет обработана центральным процессором1. Процессор получает адрес
памяти, где расположена команда, которая будет выполняться следу-
1 CPU: центральный процессорный модуль (Central Processing Unit).

14
 Введение в программирование

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

Оперативная память содержит в себе как данные, так и программы.

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

Если необходимо использовать в программном обеспечении ма-

шинные команды, то на помощь приходит язык ассемблера. Этот язык
с точностью один к одному компилирует команды программы в коман-
ды процессора, и более понятен для человека. Например, команда пере-
хода для процессора 6502 — это число 76. Соответствующая команда
ассемблера — JMP1. Компилятор этого языка, который тоже называется
ассемблер, вырабатывает из понятных для человека команд машинные
коды.

На сегодняшний день языки машинных команд и ассемблера при-

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

15
Глава 1

1.1.1. Ввод, компиляция, запуск

Когда программист пишет программу, он создает текстовый файл,

в котором находятся команды, содержащие описание выполнения
определенных операций на соответствующем языке программирова-
ния. Современные языки состоят в первую очередь из английских слов
и различных символов. Текст (код) программы вводится с помощью ре-
дактора. Редактор — это некоторый обработчик кода, который создан
не для обычного форматирования, а для удобства написания программ.
Исходный код программы для правильной компиляции должен содер-
жать только чистый код, любое форматирование в таком случае может
помешать. Поэтому, к примеру, нельзя использовать в качестве исходно-
го файла программы Word-документ. Если вы все-таки непременно хо-
тите писать программы в Word, нужно следить за тем, чтобы код был
сохранен в чистом виде. Однако для программирования существуют
специальные редакторы. Один такой всегда содержится в среде разра-
ботки. Минимальное требование к нему — отображение номеров строк.
При обнаружении компилятором ошибки, в окне ошибок будет указан
номер соответствующей строки.

Компьютер не понимает исходный код программы в том виде, в ко-

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

В случае языков C и C++ компилятор использует еще один пред-

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

На практике программный проект обычно состоит из несколь-

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

16
 Введение в программирование

щью компоновщика (или линкера). Отсюда следует, что программа со-

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

Рабочий день программиста обычно состоит из написания програм-

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

Рис. 1.1. Путь разработки программы

Некоторые программисты склоняются к тому, что нужно хорошо

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

1.1.2. Алгоритм

После описания пути, как из исходного кода получить программу,

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

17
Глава 1

Язык программирования используется для очень краткого описа-

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

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

Готово? Прекрасно! Итак, для выполнения этого задания надо сде-

лать следующее:
1. Написать число 1 на листе бумаги.
2. Прочитать последнее написанное число.
3. Если это число 10, остановиться.
4. Прибавить к этому числу 1.
5. Написать получившееся число под последним числом.
6. Вернуться к шагу 2.

Можно практиковаться, описывая таким образом повседневные

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

1.1.4. Язык C++

Очевидно, вы выбрали для изучения язык C++, иначе не читали бы

эту книгу. Независимо от того, изучаете вы C++ по собственной инициа-

18
 Введение в программирование

тиве или по требованию работодателя, вы более или менее познакоми-

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

Компилируемый язык

C++ — компилируемый язык. Это означает, что код программы пе-

ред запуском будет переведен в команды процессора, как это описано
в разделе 1.1.

Некоторые другие языки, например Бейсик или сценарные языки,

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

Кроме того, существуют смешанные формы. Известный представи-

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

Каждый из этих способов имеет свои плюсы и минусы. Преимуще-

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

Интерпретатор может остановиться, сообщить программисту о се-

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

19
Глава 1

Происхождение языка C

Бьерн Страуструп разработал C++ на основе языка C, который,

в свою очередь, был придуман в 70-х годах сотрудниками компании
UNIX Брайаном Керниганом и Деннисом Ритчи. До этого для создания
операционных систем использовали язык ассемблера, из-за чего они
были непосредственно связаны с процессором и аппаратным обеспече-
нием компьютера, для которого разрабатывались. Для программистов
UNIX был создан язык, который в первую очередь мог бы стать «пере-
носным ассемблером». Разработанные коды должны были быть бы-
стрыми и компактными. Также учитывалось требование использования
этого языка для написания программ работы непосредственно с аппа-
ратным обеспечением. Именно поэтому только небольшая часть UNIX
реализована на языке ассемблера, а операционную систему можно лег-
ко использовать на различных аппаратных платформах. При разработке
C также учитывался аспект создания нового современного языка. Так,
в C включены разработанные в то время принципы структурированного
и процедурного программирования.
В первоначальном варианте языка еще присутствовали некоторые
недоработанные моменты, которые со временем стали обременительны-
ми. Их окончательно устранили, когда C переделали под стандарт ANSI.
Вместе с тем была добавлена еще пара элементов, некоторые пункты от-
личались, и соответствие стандарта ANSI оказалось неполным, поэтому
он получил название ANSI C или K&R (стандарт Кернигана и Ритчи).
Однако он не используется уже много лет, да и K&R-программы сейчас
вряд ли можно где-либо встретить.
В течение 80-х и 90-х годов язык C развился до стандартного языка
программирования. С того времени все больше операционных систем
было написано на C. Большинство API1 также написаны на C, и с по-
мощью команд этого языка можно получить самый быстрый доступ к их
среде. Но также и в пользовательском программировании все больше
используется C. Во всяком случае, в операционных системах C доказал,
что он пригоден для разработки больших проектов.

Объектно ориентированное программирование

Большие проекты требуют, чтобы в написании программы принима-

ло участие несколько команд разработчиков. Здесь сразу же возникают
1 Сокращение от Application Programming Interface — интерфейсы от прикладных
программ до системных сред.

20
 Введение в программирование

проблемы разграничения областей работы. Проекты, над которыми ра-

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

Чтобы учесть все проблемы больших проектов, разработчики то

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

Структурированное программирование объявило войну диким

прыжкам между разными частями программ. Оно соединило циклы
и условия в блоки так, что команды перехода не только сделались не-
нужными, но даже стали считаться признаком небрежного програм-
мирования. Части программ, которые то и дело повторяются, были
объединены в функции. Классическими структурированными языками
программирования считаются Pascal и C.

Модульное программирование тематически объединило функции

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

В процессе создания объектно ориентированного программирова-

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

21
Глава 1

Поддержка в ООП классовой логики — самый важный аспект, от-

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

C++ и другие языки

Язык C++ хоть и не внедрил в жизнь ООП, однако, без сомнений,

сделал его очень популярным. Приверженцы ООП упрекают язык C++
в гибридности. Это означает, что язык C++ допускает написание не толь-
ко объектно ориентированных программ, но и позволяет программиро-
вать в классическом стиле языка C. Однако это только при желании.
Язык C++ поддерживает ООП, но не принуждает к его использованию.
Бьерн Страуструп видел в этом скорее преимущество. Он хотел создать
такой язык программирования, который поддерживал бы программиста
в следовании его стратегии. Этот прагматический подход — вероятная
причина, почему именно язык C++, а не Java или C# играет существен-
ную роль для профессиональных разработчиков. Начинающий про-
граммист не может написать программу на языке C++, не поняв перед
тем принципы ООП. И именно поэтому язык C++ сделал возможным
успех ООП. Поскольку так программист постепенно знакомится с пре-
имуществами ООП и затем может их использовать.

Еще одно преимущество языка C++ — это скорость. Страуструп

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

Конечно, можно писать на языке C++ портируемые программы, но

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

22
 Введение в программирование

В конце концов нужно было обеспечить языку C++ стабильную по-

зицию на рынке. Язык Java разрабатывался для того, чтобы написанный
код без повторной компиляции можно было использовать на всех аппа-
ратных платформах. Компания Microsoft в свою очередь не хотела здесь
уступать. Концерн многие годы пытался создать равноценный язык.
Последним ударом была разработка отдельного языка-конкурента под
названием C#. Так что руководителям проектов пришлось решать, ис-
пользовать ли язык Java, который работает на всех платформах, но не
поддерживается операционной системой Windows, или же язык C#, ко-
торый поддерживает Windows, а другие операционные системы — нет.
Язык C++ при этом можно рассматривать как золотую середину. В лю-
бом случае, необходимость в разработчиках со знанием языка C++ в по-
следние годы только возросла.

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

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

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

Ответы на два последних вопроса вы найдете на стр. 495.

1.2. Основа программы

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

Программа на языке C++ всегда состоит как минимум из функции

main(). Слово «main» — английское и переводится на русский язык
1 В данном случае под компиляцией подразумевается полный перевод программы,
который состоит из работы компилятора и компоновщика. Если речь идет о компилято-
ре, всегда подразумеваются эти две составляющие.

23
Глава 1

как «главный». Что именно подразумевается в языке C++ под поняти-

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

Главная функция начинается именно там, где открывается фигурная

скобка, и заканчивается там, где скобка закрывается. Между фигурны-
ми скобками друг за другом следуют команды главной функции. Следу-
ющий короткий листинг1 ничего не делает, однако представляет собой
самую короткую программу на языке C++.

int main()
{
}
Листинг 1.1. Самая короткая программа

Эта программа вообще ничего не делает. Если вы в дальнейшем за-

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

1.2.1. Комментарии

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

Можно добавить в программу комментарии, которые компиля-

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

1 Листингом называется исходный код программы.

24
 Введение в программирование

программирования и не сможете вспомнить каждую деталь этой про-

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

Есть два способа оформить код так, чтобы компилятор не расцени-

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

int main()
{
//Здесь начинается комментарий
//Следующая строка
//Ваши собственные комментарии
}
Листинг 1.2. Построчные комментарии

Также существует возможность комментирования большого фраг-

мента кода. Начало комментария обозначается комбинацией символов
/*. Заканчивается комментарий аналогичными символами, но в обрат-
ном порядке */.

int main()
{
/*Здесь начинается комментарий
Следующая строка комментария не нуждается
в собственных символах комментария
*/
}
Листинг 1.3. Блочный комментарий

Многие компиляторы позволяют реализовать иерархию блочных

комментариев. Это означает, что можно обозначить начало коммента-
рия с помощью символов /*, где первая заключающая последователь-
ность символов */ закроет комментарий. Последующий код компиля-
тор просмотрит и попробует перевести.

25
Глава 1

int main()
{
/* Здесь начинается комментарий
/* Следующие строки не требуют
знака комментария
*/
Это компилятор попробует перевести
*/
}
Листинг 1.4. Это некорректное написание!

С помощью символов /* и */ можно комментировать не только

большие блоки, но также и короткие части внутри строки. При исполь-
зовании двойного слеша такая возможность отсутствует, потому что эти
символы комментируют весь код до конца строки.
В следующем примере закрывающая скобка main() вне коммен-
тария.
int main(/* тут может быть что-нибудь написано*/)
{
}

Во многих курсах программирования, а также правилах некоторых

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

ЗОЛОТОЕ ПРАВИЛО КОММЕНТИРОВАНИЯ

Нужно писать в комментарии не то, что делается в этой строке, а по-
чему делается именно так!

Комментарий «два значения увеличиваются» бесполезен. Любой

программист, который знает язык C++ хотя бы немного, может это по-

26
 Введение в программирование

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

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

1.2.2. Команды

Программа состоит не только из скобок и комментариев, но также

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

Команды в языке C++ могут иметь любое форматирование. Нет ни-

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

1.2.3. Блоки

Несколько команд можно объединить в блок. Блок ограничивается

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

Трудно не заметить, что функция main() также имеет фигурные

скобки. Фактически она является блоком, в котором объединены ко-
манды программы.

Для лучшей читаемости кода программы, все команды рекоменду-

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

int main()
{
Здесь находятся команды;
Это тоже относится сюда;
{
Новый блок, заключенный в фигурные скобки;
Мы остаемся на этом уровне;

27
Глава 1

Так может продолжаться вечно;

}
Теперь скобка закрылась;
И блок тоже закончился;
}
Листинг 1.5. Блок, заключенный в фигурные скобки

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

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

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

В любой программе происходит обработка информации. Эта инфор-

мация хранится в памяти. Языки программирования высокого уровня
не получают прямого доступа к этой информации, а используют пере-
менные. В переменных хранятся числа и текст. Переменная имеет три
основных качества:
• Память
Переменные всегда занимают некий объем памяти для хранения ин-
формации. О расположении и размере памяти программист в основ-
ном не должен беспокоиться. Компилятор выделяет необходимый
объем в соответствии с типом переменной.
• Имя
Переменной в программе можно присвоить любое имя, которое
однозначно ее идентифицирует. Разные имена обозначают разные
переменные. Для языка C++ есть разница между строчными и про-

28
 Введение в программирование

писными буквами. Имя Var отличается от имени var. Правила име-

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

1.3.1. Объявление переменных

Следующий пример демонстрирует, как объявить переменные вну-

три главной функции main():

int main()
{
int income;
}
Листинг 1.6. Объявление переменной

Объявление переменной всегда начинается с ее типа. В примере ука-

зан тип int. Это числовой тип со знаком, но без позиций после запятой
(целочисленный). Через пробел следует имя переменной, которое всег-
да нужно выбирать так, чтобы оно было связано с содержимым. Спокой-
но используйте длинные имена. Сокращение хоть и уменьшает объем
работы при наборе кода, однако потом может потребоваться потратить
больше времени, если придется размышлять, что в какой переменной
хранится. Этот прием рекомендован, даже если вы набираете код очень
долго. Еще больше времени потребуется, если нужно будет найти ошиб-
ку, которая появится, если вы перепутаете две переменные, потому что
у них будут схожие имена.
В конце всегда следует точка с запятой (;). Так всегда заканчивается
команда и объявление переменных.
Можно присвоить переменной некоторое значение сразу же после
ее объявления. Для этого после имени переменной указывается знак ра-

29
Глава 1

венства. Это инициализирует переменную со следующим после знака

равенства значением.

int income=0;

Здесь переменной income сразу после инициализации присвоено

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

Вместо знака равенства для инициализации переменных в языке

C++ можно также использовать скобки. Это выглядит так:

int income (0);

Можно объявлять сразу несколько переменных одну за другой, раз-

деляя их запятыми.

int i, j=0, k;

Здесь объявлены переменные i, j, k. Переменная j инициализиро-

вана со значением 0. Нижеприведенные способы объявления равно-
значны:

int i;
int j=0;
int k;

Синтаксис объявления переменных вы найдете на стр. 76

1.3.2. Область действия

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

объявлена в коде программы1.

Компилятор проверяет, можно ли использовать переменную в соот-

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

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

пилятору, что он может использовать эту переменную и какой у нее тип. Объявить ее
можно в другом месте (см. стр. 191).

30
 Введение в программирование

программы. Такая удобная функция может быть коварна. Если назвать

одну переменную DepartmentNumber, а затем написать это имя непра-
вильно — DepartmentNumbe, то компилятор не сообщит об ошибке. Вме-
сто этого получатся две разные переменные, причем разработчик даже
не будет об этом подозревать. В языке C++ такого никогда не случится.
Компилятор сразу начнет ворчать, что переменная DepartmentNumbe
ему вообще не знакома, и откажется вообще что-либо с ней делать. Так
что разработчик будет сразу проинформирован о своей ошибке и смо-
жет ее исправить.

В то время как в языке C объявление переменных разрешалось толь-

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

Если основной блок программы состоит из других блоков, то в них

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

Следующий пример отчетливо иллюстрирует это:

{
int a = 5;
{
// здесь а равно пяти.
}
{
int a = 3;
// здесь а присваивается значение 3.
{
// а все еще равно 3
}
}
//а здесь а опять равно 5
}
Листинг 1.7. Две переменные

31
Глава 1

Каждая переменная, объявленная в блоке, является локальной. Она

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

Переменные, определенные вне всех блоков, называются глобаль-

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

Глобальные переменные инициализируются компилятором C++ со

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

Тема глобальных и локальных переменных рассмотрена подробнее

на стр. 160.

1.3.3. Правила именования и синтаксис

В языке C++ все допустимые имена подчиняются одинаковым пра-

вилам. Эти правила действительны для имен не только переменных, но
и функций и классов. Во многих книгах можно встретить обозначение
этих имен словом «идентификатор». Имя должно начинаться с латин-
ской буквы или символа подчеркивания, и может содержать много букв,
знаков подчеркивания и цифр. Первый знак имени не должен быть циф-
рой, поскольку компилятор в таком случае перепутает имя с числом.
Буквы могут быть прописными и строчными. В языках C и C++ важен
регистр букв. Переменные Anton, ANTON и anton — это абсолютно раз-
ные переменные.

На рис. 1.2 представлено правило именования переменных. Для соз-

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

32
 Введение в программирование

Рис. 1.2. Граф синтаксиса имени

В прямоугольном поле расположен так называемый терминал, вы-

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

Рис. 1.3. Граф использования букв и цифр

Как видно из графа, здесь берутся латинские буквы от A до Z

и от a до z. Использование особых символов и букв, отличных от лати-
ницы (в т. ч. и кириллических), в именах переменных принципиально
запрещено.

И напоследок, в языке C++ нельзя использовать имена команд в ка-

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

33
Глава 1

этого избежать, если будете начинать имя переменной с прописной бук-

вы, так как все команды в языке C++ указываются с маленькой буквы.

Данный список1 содержит ключевые слова языка C++, которые

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

and double not template

and_eq dynamic_cast not_eq this
asm else operator throw
auto enum or true
bitand explicit or_eq try
bitor export private typedef
bool extern protected typeid
break false public typename
case float register union
catch for reinterpret_ unsigned
char friend cast using
class goto return virtual
compl if short void
const inline signed volatile
const_cast int sizeof wchar_t
continue long static while
default mutable static_cast xor
delete namespace struct xor_eq
do new switch

1.3.4. Типы переменных

Переменные всегда имеют тип. Он указывает, какую информацию

может хранить переменная, а также определяет, сколько памяти необхо-
димо для ее хранения. Без указания типа нельзя объявлять переменную,
потому что компилятор должен знать, какой объем памяти требуется
для ее хранения. Он также проверяет, подходит ли этот тип под данную
команду программы. Эти «придирки» компилятора созданы только для
упрощения работы программиста. При компиляции обнаруживаются
1 Бьерн Страуструп. Язык программирования С++. М.: Бином, 2011.

34
 Введение в программирование

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

Язык C++ достаточно щедрый в определенных пределах. Переменные
одинаковых типов могут храниться одна в другой, пока не появляется
риск потери информации.

Хранение информации

Информация, хранящаяся в переменных, располагается в оператив-

ной памяти компьютера. А как работает оперативная память? Компью-
тер — это цифровое устройство. Он «понимает» только два состояния:
включен и выключен. И самая крошечная ячейка памяти компьютера
может принимать только одно из этих двух значений. Состояние «вклю-
чен» обозначается 1, «выключен» — 0. Единицу информации, которая
может хранить в себе 1 или 0, называют битом.

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

образом, можно записать в них число больше 1. Этот метод аналогичен
тому, который применяется в нашей системе счисления для создания
чисел больше 9. Цифры указываются друг за другом и умножаются на
основу системы. В десятичной системе счисления основа равна десяти,
в двоичной — двум. В бите может храниться 0 или 1. В двух битах можно
разместить комбинацию 00, 01, 10 и 11. Таким образом, в два бита можно
записать числа 0, 1, 2 и 3. Последующий бит удвоит количество комби-
наций. Возможные комбинации 000, 001, 010, 011, 100, 101, 110 и 111
и соответствуют числам от 0 до 7. По техническим причинам, байт —
стандартный размер наименьшего количества битов в блоке. Байт со-
стоит из 8 бит и может принимать значения 28 = 256, или соответство-
вать числам от 0 до 255 или от –128 до 127.

Целые числа

Один из часто используемых типов — целочисленный, хранящий це-

лое число без знаков после запятой. В компьютерной литературе такой
тип называют integer. Тип целочисленной переменной обозначается
int. Сначала пишется тип int, затем следует пробел, а затем указыва-
ется имя переменной. Заканчивается объявление переменной точкой
с запятой.

int counter;

Число, которое хранится в переменной counter, может быть поло-

жительным или отрицательным. Можно объявлять переменные, кото-

35
Глава 1

рые принимают только положительные значения, включая 0. Для этого

используется ключевое слово unsigned перед типом int.

unsigned int counter;

Таким образом, можно не только предотвратить то, что переменная

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

Есть два особенных случая для всех чисел: short и long. Оба атри-
бута могут быть расположены перед типом int. Имя атрибута указывает
на максимальное число, которое может хранить переменная, и соответ-
ственно на количество памяти, которое выделяется под эту переменную.
Переменные типа short или long также могут быть объявлены в каче-
стве беззнаковых. При этом перед ними указывается ключевое слово
unsigned.

unsigned short int counter;

Если употребляются атрибуты unsigned или short, ключевое сло-

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

unsigned short counter;

short few;
unsigned positive;
Листинг 1.8. Целочисленные переменные без ключевого слова int

Переменная типа short занимает не менее двух байт, тип int — не

менее того же размера памяти, сколько и short. Переменная типа long
занимает от четырех байт и имеет минимальный размер как переменная
типа int1. Количество байт, занимаемых определенными типами пере-
менных не фиксировано и зависит от компилятора.

Целочисленные значения кодируются бинарным кодом. Целочис-

ленная переменная занимает два байта, следовательно, 16 бит. Пред-
ставление числа 0 установит все биты в 0. Число 1 будет закодировано
с помощью 15 нулей и одной 1. В табл. 1.1 представлены двоичные коды
чисел.

1
Бьерн Страуструп. Язык программирования С++. М.: Бином, 2011.

36
 Введение в программирование

Таблица 1.1. Двоичные коды положительных чисел

Двоичный формат Десятичный формат

0000000000000000 0
0000000000000001 1
0000000000000010 2
0000000000000011 3
0000000000000100 4
0000000000000101 5
0111111111111111 32.767

Двоичные числа компьютер может легко складывать и вычитать.

Функция сложения работает так же, как этому учат в школе для деся-
тичной системы, но только для двух цифр. Давайте посчитаем: 0+0 по-
лучается 0. 1+0 получается 1. Также как 0+1. 1+1 не может, однако, дать
2, поскольку такого числа в двоичной системе не существует, в резуль-
тате получится 0 с переносом, а именно 10. Если следующий бит вы-
числяется, то перенос входит в вычисление, если все биты посчитаны,
а перенос остается, то он теряется.
Аналогично работает вычитание. 0-0 дает 0, как и 1-1. 1-0 дает 1. 0-1
дает 1 и перенос, который учитывается при расчете следующего бита,
если он существует.
Если кодирование положительных чисел понятно, то появляется во-
прос, как выглядят отрицательные числа в двоичной системе. Кодиро-
вание должно быть совместимо с обычной системой вычисления. Если
сложить –1 и 1 , должен получиться ноль. Для этого -1 вычисляется так,
как будто от 0 отнимается 1. Если начать с самого правого бита, полу-
чится 0-1=1. Затем перенос в следующий бит. В следующем бите опять
вычисляется 0-1, что снова приводит к переносу.

~ 0000
- 0001
Перенос: 111
----
Результат: 1111
Листинг 1.9. Бинарный расчет 0-1

Перенос проходит через все биты. Из чего следует, что число –1

в бинарном коде состоит из 1. Если это кажется нелогичным, следует
37
Глава 1

подумать, какое число даст 0, если добавить к нему 1. Здесь представле-

на проверка вычисления:

~ 1111
- 0001
Перенос: 111
----
Результат: 0000
Листинг 1.10. Бинарный расчет –1+1

Числа –2, –3 и т. д. получаются с помощью декремента, как показано

в табл. 1.2

Таблица 1.2. Бинарное кодирование отрицательных чисел

Двоичный формат Десятичный формат

0000000000000000 –0
1111111111111111 –1
1111111111111110 –2
1111111111111101 –3
1111111111111100 –4
1111111111111011 –5
1000000000000000 –32.767

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

Такая кодировка также позволяет выяснить, насколько велико са-

мое большое и самое маленькое число. В двух байтах можно разместить
числа от –32.768 до +32.767. Если используются четыре байта, то в них
можно записать числа от –2.147.483.648 до +2.147.483.647.

 ВНИМАНИЕ
Если первый бит бинарного кода числа единица, то это отрицатель-
ное число.

Для контроля пересчитаем еще раз –3+5. В результате должно по-

лучиться 2.
38
 Введение в программирование

~ 1101
- 0101
Перенос: 1 1
----
Результат: 0010
Листинг 1.11. Бинарный расчет –3+5

При использовании беззнаковых переменных 0 является самым ма-

леньким числом. Первый бит при этом используется для хранения не
знака, а числа. Таким образом переменная типа short может принимать
значения от 0 до 65.535. Если к максимальному числу прибавить 1, то
снова получится 0.

Таблица 1.3. Бинарные коды чисел без знака

Двоичный формат Десятичный формат

0000000000000000 0
0000000000000001 1
0000000000000010 2
0000000000000011 3
0000000000000100 4
0000000000000101 5
1111111111111110 65.534
1111111111111111 65.535

 ПРИМЕЧАНИЕ
Есть нечто коварное в том факте, что вы не можете преодолеть пре-
дел максимального числа целого типа. Если увеличить его на 1, то
снова получается самое маленькое значение. Таким удивительным
образом будет работать программа. Однако может оказаться, что
разработчик этого не заметит. Его задача — следить за тем, чтобы
такого перехода не произошло.

Символы

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

обработке кода. Это касается не только тех действий, которые выпол-
няются в редакторе, например, при написании письма. Речь идет также
о вводе, сортировке и выводе таких привычных данных, как адрес или
номер автомобиля.
39
Глава 1

Для хранения символов в языке C++ обычно используется тип char.

Этот тип занимает один байт, и может принимать 256 значений. То есть
существует 256 комбинаций нулей и единиц. Эти комбинации могут ко-
дировать числа от 0 до 256. Латинский алфавит состоит из 26 букв, кото-
рые могут быть маленькими или большими, так что для их хранения не-
обходимо минимум 52 комбинации. Еще нужно включить сюда 10 цифр
и некоторые знаки препинания. Таким образом, первые 128 комбина-
ций нормированы интернациональным стандартом таблицы символов
ASCII. Оставшиеся 128 используются для кодирования особых симво-
лов языков, имеющих в своей основе латинский алфавит.

Пока особые символы содержатся только в языках Западной Евро-

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

С возрастающей интернационализацией возросла потребность

в унифицированном кодировании всех национальных особых символов.
Попытка закодировать все символы мира в одной системе привела к по-
явлению стандарта UNICODE, который существует с конца 90-х годов.
Сразу стало ясно, что такое количество символов не поместится в одном
байте. Поэтому под каждый символ было выделено два байта. В 16 би-
тах можно закодировать до 65.536 знаков. Для такого набора символов
в языке C++ существует специальный тип wchar_t.Сколько байтов он
содержит, зависит от способа реализации компилятора. Первоначаль-
ное предположение, что в двух байтах можно закодировать все символы
мира, оказалось иллюзией. Сейчас для этого используются четыре бай-
та. Однако зачем резервировать, скажем, на американском компьютере
вчетверо больше памяти, только на тот случай, если в один прекрасный
день внезапно понадобится обработать китайский иероглиф, который
обладатель компьютера вероятно даже не сможет прочесть? Поэтому
был создан еще один формат — Unicode Transformation Format (UTF).
Он позволяет обслуживать UNICODE по отдельным частям. Самый из-
вестный тип такого формата UTF-8. Для каждого символа в нем выде-
лен один байт, как для типа char. Преимущество этого формата состоит
в том, что даже те программы, которые не предусматривают обработки
интернациональных символов, могут их использовать. Программы, ко-

40
 Введение в программирование

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

UTF-16. Поэтому возможны их конфликты с операционными система-
ми для мобильных устройств, такими, как Windows Phone.

Особенно запутанным кажется для начинающих отличие между

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

Чтобы запутаться окончательно, можно сказать, что буквы — это

тоже числа. Каждая буква представлена с помощью числа, которое
хранится в байте. Соответственно, это может быть число от 0 до 255.
Цифры точно так же, как и буквы, кодируются с помощью чисел, но не
совсем соответственно их значениям. В таблице символов ASCII они
располагаются, начиная с позиции номер 48. Цифра «0» кодируется как
48, цифра «1» как 49 и т. д. Это обязательно следует учитывать при вво-
де числа с помощью клавиатуры. Если число будет прочитано как буква,
нужно использовать 48 в качестве кодировки числа «0», то есть вводить
коды чисел для соответственной интерпретации. Кстати, ASCII явля-
ется не единственным стандартным набором символов. Например, для
больших вычислительных машин IBM используется набор символов
EBSDIC. К счастью, программисту не обязательно вдаваться в подроб-
ности кодирования цифр.

Особенно запутанным кажется то, что язык C++ позволяет произво-

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

Если переменная типа char фактически является переменной типа

int, то у нее также есть знак. Кроме того, как переменные типа int, так
и переменные типа char прежде всего имеют знак. Как было сказано
выше, специальные символы языка находятся за 128-й позицией. Таким
образом, в случае кодирования особого символа языка (как, например,
умлаут в немецком языке) первый бит байта определен как 1. Однако
для нормальной переменной типа char он будет интерпретирован в ка-
честве знака числа. Чтобы этого избежать, нужно во всех сомнительных
случаях добавлять переменной типа char атрибут unsigned. Иначе мо-

41
Глава 1

жет возникнуть ситуация, когда символ немецкого языка « », например,

будет иметь меньшее числовое значение, чем «а», и будет интерпретиро-
ван в качестве отрицательного числа. Тогда сортировка укажет все спе-
циальные национальные символы в начале алфавита1.

Числа с плавающей запятой

В реальном мире недостаточно использовать только целые числа.

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

823,25 = 823,25 × 1 = 823,25 × 100

823,25 = 82,325 × 10 = 82,325 × 101
823,25 = 8,2325 × 100 = 8,2325 × 102
823,25 = 0,82325 × 1000 = 0,82325 × 103

Самое нижнее число, в котором первая значимая цифра расположе-

на после запятой, отображает стандартное представление чисел с пла-
вающей запятой. Из этого представления следует, что число с плаваю-
щей запятой имеет два компонента. Один — это мантисса, здесь 82325.
Мантисса — это числовая часть константы с плавающей запятой, без
экспоненты. Другой компонент — это экспонента (значение степени)
с базисом 10, здесь 3. Экспонента отделяется при письме с помощью
большого или маленького Е. Следовательно, наше число будет пред-
ставлено в следующем виде: 0.82325Е3.

Самый простой тип чисел с плавающей запятой называется float.

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

1 При использовании атрибута unsigned все национальные особые символы будут

располагаться в конце алфавита, после «z», что более привычно.

42
 Введение в программирование

вить и такие численные величины, как 1038. Но подобная переменная

является компромиссом точности мантиссы.

В случае если необходима высокая точность в представлении чис-

ла, и его размер выходит за пределы стандартной float-переменной,
используется тип double. Имя означает «двойной» и касается точно-
сти. Точность зависит от размера памяти, занимаемой числом. Многие
компиляторы выделяют под переменную типа double в два раза больше
памяти, чем под переменную типа float. Время для расчета такой пере-
менной также увеличивается вдвое.

Если требуется особая точность, компилятор ANSI C++ располага-

ет еще одним типом данных, более точным, чем double. Это тип long
double. В зависимости от компилятора он выделяет под переменную
от 10 до 16 байт. При обращении с числами с плавающей запятой ча-
сто обнаруживаются неточности. С одной стороны, это происходит
из-за ограниченного количества знаков в мантиссе. С другой — при-
чиной неточности может послужить бинарное кодирование. Это лег-
ко установить, если присвоить переменной значение –1,0 и пошагово
увеличивать ее до 0,1. В двоичной системе счисления нельзя таким об-
разом получить точное значение 0,0. Причина в том, что 0,1 в бинарном
представлении также имеет период, как, например, треть в десятичном
представлении.

Для представления 0,1 в двоичной системе используются знаки

после запятой. Их нужно представить так, чтобы 0,1 был половиной,
0,01 — четвертью, а 0,001 — восьмой частью. Чтобы представить деся-
тую часть, восьмой части числа будет слишком много. Шестнадцатая
часть это 0,0625. Остается 0,0375 до одной десятой. Одна тридцать
вторая — это 0,03125. Остается 0,00625. Одна 256-я — это 0,00390625.
Путем дальнейших вычислений придем к бинарному представлению
из 0,000110011001111, и все еще будет не хватать определенной части.
Если продолжать так считать до конца, выяснится, что будет постоянно
недоставать некоторого значения. И как у калькулятора всегда возни-
кает проблема при вычислении трети, так у компьютера с его бинарным
кодированием чисел с плавающей запятой всегда возникают проблемы
при вычислении одной десятой.

В некоторых языках программирования, а также базах данных, су-

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

43
Глава 1

числа с плавающей запятой. Это значит, что будет выделено столько па-
мяти, сколько необходимо для представления числа.
Язык C++ не устанавливает четкие требования к количеству памяти
для большинства типов переменных. Такие детали реализации зависят
от компилятора. Четко установлены лишь качественные различия меж-
ду типами. Можно положиться на то, что short не больше long. Табл. 1.4
демонстрирует, какой размерный порядок существует на практике.

Таблица 1.4. Обычные размеры типов

Тип Стандартный размер Типичное использование

char 1 байт Буквы, символы и цифры
wchar_t 2 байта Интернациональные буквы, знаки
и цифры
short int 2 байта Числа для нумерации или позиций
int 2 или 4 байта Стандартный размер для целых чисел
long int 4 или 8 байт Обозримо большие значения без знаков
после запятой
float 4 байта Вычисленные значения со знаками по-
сле запятой
double 8 байт Расчеты и высокие стоимости
long double 12 байт Расчеты высокой точности

Какой в действительности размер имеет определенный тип, зависит

не от настроения разработчиков компилятора, а например, от аппарат-
ного обеспечения или архитектуры операционной системы. Наиболее
распространенные ранее компьютеры имели разрядность 32 бита, то
есть 4 байта. Соответственно 4 байта обрабатывались максимально бы-
стро. Современные модели имеют разрядность 64-бита. В этих системах
тип long реализуется чаще всего 8 байтами, поскольку такой размер об-
рабатывается с максимальной скоростью. В то время, когда был создан
язык C++, как правило, использовались 16-разрядные машины. Если бы
тип int реализовали тогда двумя байтами, то в будущем у компилятора
возросли бы затраты на его обработку только из-за того, что нужно было
бы ограничивать 64 бита до 16.
Если необходимо узнать конкретный размер типа, используется
псевдофункция sizeof(). Она возвращает размер типа или перемен-
ной. Результатом работы следующего примера будет количество байт,
занимаемых типом double.
cout << sizeof(double) << endl;

44
 Введение в программирование

Точно так же можно поместить в скобки sizeof() переменную или

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

В файле limits.h хранятся размеры основных типов, например кон-

станта INT_MAX. Она содержит максимальное значение, которое может
принимать переменная типа int. Аналогичная информация содержится
в CHAR_MAX относительно типа char. И совсем неудивительно, что LONG_
MAX содержит максимальное значение, которое может принимать пере-
менная типа long. Вероятно, можно удивить тем, что SHRT_MAX является
максимальным значением переменной типа short, поскольку предпо-
ложительно в имени должна быть еще и буква О2.

Таблица 1.5. Предельные константы

Константы Значение
INT_MAX Максимальное значение переменной int
INT_MIN Минимальное значение переменной int
UINT_MAX Максимальное значение переменной unsigned int
CHAR_MAX Максимальное значение переменной char
CHAR_MIN Минимальное значение переменной char
WCHAR_MAX Максимальное значение переменной wchar_t
WCHAR_MIN Минимальное значение переменной wchar_t
UCHAR_MAX Максимальное значение переменной unsigned char
SHRT_MAX Максимальное значение переменной short
SHRT_MIN Минимальное значение переменной short
USHRT_MAX Максимальное значение переменной unsigned short
LONG_MAX Максимальное значение переменной long
LONG_MIN Минимальное значение переменной long
ULONG_MAX Максимальное значение переменной unsigned long

Для всех этих типов имеются аналогичные константы с приставкой

MIN, в которых хранятся минимальные значения переменных. А если
указать большую букву U перед соответствующими именами констант,
можно узнать, какое максимальное значение могут принимать перемен-
ные с атрибутом unsigned. Если захочется провести короткий прове-
рочный тест для коллег, можно спросить у них, почему не существует
ULONG_MIN.

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

45
Глава 1

1.3.5. Синтаксис объявления переменных

Граф синтаксиса объявления переменных стандартных типов пред-

ставлен на рис. 1.4.

Рис. 1.4. Граф синтаксиса объявления переменной

Сначала указывается тип переменной, затем имя, образование кото-

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

Можно объявить несколько переменных одной командой, разделяя

их запятыми.

Все вышеописанные типы представлены на графе на рис. 1.5.

int

short

long

char

unsigned wchar_t

float

double

long

Рис. 1.5. Граф объявления типа

Известно, что существуют типы char, wchar_t, int, float или double.
Для типа int или char можно использовать атрибут unsigned. Перед

46
 Введение в программирование

типом int можно использовать атрибуты long и short. При использова-

нии одного из этих атрибутов не обязательно указывать тип int.

1.3.6. Константы

Константа — это неизменная величина. Все числа в программе яв-

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

Целые числа

Целочисленные константы самые простые для понимания. Это та-

кие числа, как 5, –3, 17 или 5498. Однако нужно следить за тем, чтобы
константа содержала только цифры, без пробелов или других особых
символов.

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

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

 ПРИМЕЧАНИЕ
Десятичная целочисленная константа — это 0 или другое число, на-
чинающееся с цифры, отличной от 0, за которой могут следовать
любые цифры, включая 0.

DecConst
0

2 0

3 ...

... 9

9
Рис. 1.6. Граф десятичной целочисленной константы DecConst

Как уже было сказано, константа может быть обозначена символом

плюс или минус перед числом. Граф на рис. 1.6 может быть использован
47
Глава 1

также для объявления констант с плавающей запятой, и будет носить

имя DecConst. В следующем графе (рис. 1.7) добавлен знак числа:

DecConst

Рис. 1.7. Граф десятичной константы со знаком

Следующая таблица демонстрирует примеры недопустимых кон-

стант (табл 1.6).

Таблица 1.6. Недопустимые целочисленные константы

Константа Причина
1 234 Указан пробел между 1 и 2
1,234 Запятая в константах не используется
1- Знак числа должен быть указан перед числом
12DM Содержимое недопустимо

Наряду с десятичными константами в языке C++ существует

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

 ПРАВИЛО
Каждая целочисленная константа, которая начинается с нуля, не бу-
дет интерпретирована в качестве десятичной. Нужно избегать ука-
зывать 0 перед константами, если разработчик не знает точно, как
выполняется их интерпретация.

Если перед константой указан 0, а за ним буква «x», значит это шест-
надцатеричная константа, то есть число с базисом 16, которое состоит из
цифр от 0 до 9 и букв от «A» до «F», используемых для чисел от 10 до 15.

48
 Введение в программирование

В этом случае также допустимо использование маленьких букв от «a»

до «f». Если за нулем следует цифра, то это восьмеричное число с бази-
сом 8. Допустимы цифры от 0 до 7.

Табл. 1.7 демонстрирует различные значения последовательности

цифр 11.

Таблица 1.7. Системы счисления

Константа Система счисления Десятичное значение

11 Десятичная (базис 10) 1×101 + 1×100 = 1×10 + 1×1 = 11
011 Восьмеричная (базис 8) 1×81 + 1×80 = 1×8 + 1×1 = 9
0х11 Шестнадцатеричная (базис 16) 1×161 + 1×160 = 1×16 + 1×1 = 17

Расчет значений для других систем счисления так же эффекти-

вен, как и для привычной нам десятичной, в которой каждая позиция
умножается на соответствующую степень десяти. Показатель степе-
ни начинается с правой позиции с 0. Самая правая цифра умножается
на 100 или 1. Вторая позиция справа умножается на 101, то есть на 10.
Далее следует 102, равное 100; 103, равное 1000 и т. д.

Шестнадцатеричные числа имеют базис 16. Для этого не хватает

цифр от 0 до 9. Поэтому для них задействованы также буквы от «A»
до «F». «А» имеет значение 10, «В» — 11 и т. д., «F» имеет максимальное
значение 15. Метод расчета значения шестнадцатеричной константы
аналогичен методу в десятичной системе. Самая правая позиция оста-
ется неизменной, поскольку 160 = 1. Следующая позиция будет умно-
жена на 16, следующая — на 162 =256 и т. д. Таким образом, 0×168 равно
1×256 + 6×16 + 8, что соответствует 360 в десятичной.

 ПРИМЕЧАНИЕ
Шестнадцатеричная целочисленная константа начинается с после-
довательности символов 0х или 0Х. Затем следуют любые цифры от
0 до 9 или буквы от «A» до «F» (равнозначно от «a» до «f»).

Восьмеричные числа состоят из цифр от 0 до 7. Здесь позиции вы-

числяются с помощью степени восьмерки. Справа налево получается 1,
8, 64 и т. д. Константа 0167 будет пересчитана следующим образом:
1×64 + 6×8 + 7. Восьмеричная константа 0167 соответствует десятично-
му значению 119.

49
Глава 1

0 x 0

X ...

...

...

Рис. 1.8. Граф шестнадцатеричной константы

 ПРИМЕЧАНИЕ
Восьмеричная целочисленная константа всегда начинается с 0. За-
тем следуют любые другие цифры от 0 до 7.

0 0

...

...

Рис. 1.9. Граф восьмеричной константы

50
 Введение в программирование

Константы с плавающей запятой

Константы с плавающей запятой — это константы, имеющие знаки

после запятой. К сожалению, запятая не является интернациональным
знаком, отделяющим целое число от дробной части. Например, в ан-
глоязычной среде для этого используется точка. Язык C++ не понимает
значение 1,2, а предпочитает 1.2.
Константа с плавающей запятой начинается с мантиссы. Мантисса —
это часть константы с плавающей запятой, которая не содержит значе-
ние степени. Иногда она имеет знак, за которым следует целая часть.
Затем появляется точка и числа дробной части. Если перед точкой
стоит 0, его можно опустить.
Экспонента используется здесь так же, как в калькуляторе. По умол-
чанию используется базис 10.
Чтобы отделить мантиссу от экспоненты, используется прописная
или строчная буква «E». Экспонента сама по себе целочисленная деся-
тичная константа, она также может быть отрицательной. Примеры при-
ведены в табл. 1.8 и на рис. 1.10.

Таблица 1.8. Представление экспоненты

Представление экспоненты Значение Представление без экспоненты

1Е3 103 1000.0
1Е0 100 1.0
1Е-1 10–1 0.1
1Е-3 100–3 0.001

Рис. 1.10. Граф константы с плавающей запятой

Данный граф три раза ссылается на DecConst. Здесь речь идет о де-
сятичной константе, как показано в графе на рис. 1.6.

51
Глава 1

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

той буквой «f». Распространено присваивание константе с плавающей
запятой значения .0, чтобы отличать их от целочисленных констант.

Символьные константы

Буква, то есть константа типа char, указывается в кавычках. Такая

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

Рис. 1.11. Граф символьной константы

Если необходимо явно указать тип константы wchar_t, перед пер-

вой кавычкой указывается большая буква «L».

Какими числами кодируются символы, зависит от набора этих сим-

волов. Для большинства систем сегодня используется стандарт ASCII
(American Standard Code for Information Interchange — американская
стандартная кодировочная таблица для обмена информацией). Ниже
представлены первые 127 символов. Для расшифровки кода в каждой
строке таблицы указан номер первого символа в десятичной и шестнад-
цатеричной системе. Над символами указано число, которое должно
быть добавлено к номеру столбца. Так, буква Z имеет десятичный но-
мер 80 + 10 = 90. Шестнадцатеричный номер 0x50 + 0x0А = 0x5А.

dec 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
hex 0 1 2 3 4 5 6 7 8 9 A B C D E F
00 0 ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O
16 10 ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z
32 20 ! " # $ % & ' ( ) * + , - . /
48 30 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
64 40 @ A B C D E F G H I J K L M N O
80 50 P Q R S T U V W X Y Z [ \ ] ^ _
96 60 ` a b c d e f g h i j k l m n o
112 70 p q r s t u v w x y z { | } ~

52
 Введение в программирование

Первые позиции ASCII используются для контрольных символов.

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

Печатные символы начинаются с номера 32. Это знаки, которые вы-

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

Цифры в таблице ASCII начинаются с номера 48. '0' кодируется

как 48, '1' — как 49. Так продолжается до '9' — 57. Программист дол-
жен четко отличать '0' и 0. Если пользователь вводит данные, то это
символьная последовательность. Чтобы вычислить из этой последо-
вательности цифры, нужно вычесть из них значение '0'. Из '3' полу-
чится 3, если из него вычесть значение '0'. Подробное описание можно
найти на стр. 128.

Буквы начинаются с прописной 'A', с номера 65. Затем следуют бук-

вы, начиная с 'a' под номером 97. Буквы следуют в алфавитном порядке
от A до Z. Интернациональные особые символы, вроде немецких умлау-
тов, начинаются с номера 128. Где расположен тот или иной особый сим-
вол языка и существует ли он вообще, зависит от используемой таблицы
символов. На западе для систем UNIX/Linux и Windows используется
таблица символов ISO 8859-1 (Latin-1). Восточноевропейские языки
используют Latin-2, например ISO 8859-9 — это таблица турецких сим-
волов.

Не полагайтесь слепо на позицию определенного символа в табли-

це. Хотя формат ASCII и используется на всех компьютерах и системах
UNIX, но, например, большие вычислительные машины IBM работают
в основном с таблицей символов EBSDIC, которая построена совсем
иначе. Лучше положиться на то, что буквы и цифры отсортированы по
возрастанию и цифры следуют одна за другой непрерывно. В следую-
щем примере, в переменной numeral_symbol хранится символ. Его чис-
ловое значение при этом должно соответствовать символу ноль.

numeric_value = numeral_symbol - '0'; // правильно

numeric_value = numeral_symbol - 48; // только для ASCII!

53
Глава 1

В первой строке вычитается символ '0', который представляется

компилятором для машины с форматом ASCII как число 48. При ком-
пиляции этой строки на машине с другой таблицей символов, вместо
него будет подставлено другое значение. В языке C++ гарантируется,
что все цифры следуют одна за одной и результат будет корректен для
всех цифр. Если вместо этого, как во второй строке, будет закодировано
конкретное число 48, то эта строка будет работать только на машинах
с таблицей символов ASCII. Отсюда следует, что первая строка значи-
тельно лучше представляет идею программиста.

Чтобы быть независимым от таблицы символов, язык C++ опреде-

ляет некоторые важные знаки с помощью специального символа \. За
ним следует символ, который кодирует последовательность. Следую-
щая таблица демонстрирует самые важные особые символы (табл. 1.9).

Таблица 1.9. Символы управления

Последовательность Значение
\n Перевод строки (line feed)
\r Возврат каретки (carriage return)
\t Табуляция
\b Возврат назад
\f Перевод формата
\0 Действительный ноль (не знак '0')
\\ Вывод символа обратного слеша
\" Вывод двойной кавычки
\' Вывод одинарной кавычки
\0nnn Восьмеричное число nnn определяет символ
\0xnn Шестнадцатеричное число nn определяет символ

Последовательности символов
Последовательности символов состоят из нескольких символов,
связанных друг с другом (рис. 1.12). Все, что должно принадлежать
константной последовательности символов, заключается в кавычки.
В одной последовательности могут использоваться все символы, кото-
рые может содержать символьная константа, а также символы управле-
ния. Например, следующая последовательность состоит из двух строк:
"Это последовательность символов \n из двух строк"
Иногда код может быть очень длинным и не помещаться в одну
строку. Поэтому несколько символьных последовательностей, следую-
щих друг за другом, можно разделить на несколько строк.

54
 Введение в программирование

Рис. 1.12. Граф константной символьной последовательности

Компилятор при обработке соединит их в одну.

"Эта последовательность символов настолько длинная,"
"что не помещается в одну строку. Но это не"
"проблема. Просто перейдите на следующую строку!"

Поскольку последовательности символов — это составные элементы,

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

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

Числовые константы, которые указаны в коде программы без по-

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

Чтобы связать число с именем, объявляется константа. В языке C++

константой называется переменная, которая не изменяется. То есть име-
ет тип и имя, как переменная, но ее значение остается постоянным. По-
скольку константа не меняет свое значение, она должна быть проинициа-
лизирована при объявлении. Объявление константы выглядит так же,
как объявление переменной с инициализацией, перед которой указано
ключевое слово const.
const int rate_of_working_time = 8;

55
Глава 1

Константы, в отличие от переменных, не нуждаются в памяти, по-

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

Есть две основные причины объявления констант. Одна — улучше-

ние читаемости кода программы. Вторая — удобство внесения измене-
ний, поскольку в этом случае требуется изменить только одну строку.
Если в вышеупомянутом примере норма рабочего времени будет не
8 часов, а 7, изменить код придется только в одной позиции. Если бы
везде в программе стояло число, пришлось бы искать его по всему коду
и при этом следить, является ли значение 8 действительно нормой ра-
бочего времени, а не максимальным количеством рабочих в смене или
минимальным тарифом уборщицы. Существует эмпирическое правило,
которое гласит, что все числа кроме 0 и 1 должны иметь имена. Возмож-
но, это преувеличение. Перед использованием числа в программе необ-
ходимо обдумать, не будет ли именованная константа бессмысленной.
Так или иначе, затраты на объявление константы вначале не соизмери-
мы с пользой в области гибкости и читаемости.

Вышеописанная форма объявления констант появилась в языке C еще

с введением стандарта ANSI. До этого константы устанавливались с по-
мощью препроцессора перед компиляцией. Препроцессор может с помо-
щью команды #define ввести кодовую замену. Так следующая команда
определяла1 бы константу rate_of_working_time из примера выше:
#define rate_of_working_time 8

Выполнение этой строки укажет препроцессору, что в исходном коде

программы до ее компиляции нужно использовать значение 8 везде, где
программист написал слово rate_of_working_time. На первый взгляд
эффект аналогичный. Но механизмы отличаются в двух важных аспек-
тах. Способ, используемый в языке C++, требует указывать тип кон-
станты. При этом константы могут инициализироваться со значением,
которое было ранее вычислено в программе.

1.4. Обработка
Итак, существуют переменные и константы. В этом разделе будет опи-
сано, как константы превращаются в переменные, как можно копировать
и вычислять переменные. В общем, как вдохнуть в компьютер жизнь.
1 Отличия понятий «объявление» и «определение» см. в глоссарии на стр. 521.

56
 Введение в программирование

1.4.1. Присваивание

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

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

Слева от знака равенства всегда указывается переменная в качестве

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

MwStSet = 16;
Netto = 200;
MwStSum = Netto * MwStSet / 100;
Brutto = Netto + MwStSum;
Листинг 1.12. Присваивание

Если слева от знака равенства вместо переменной указано нечто

иное, большинство компиляторов выдадут ошибку: «L-Value expected»
или аналогичную. Дословный перевод сообщения звучит так — «ожи-
дается значение слева», то есть значение, указываемое с левой стороны
присваивания. L-значение — это выражение, ссылающееся на объект.
Как будет описано далее, не все типы переменных допустимы в качестве
L-значения (см. стр. 125).

Язык C++ допускает возможность присвоить нескольким перемен-

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

a= b = c = d = 5 + 2;

Операция будет проведена, начиная с вычисления данных. 5+2

в итоге позволит получить 7. Это значение (7) будет присвоено пере-
менной d. Результат присвоения — значение 7, которое будет присвоено
переменной с, — далее перейдет к переменной b и в итоге к переменной
а. В результате все переменные будут иметь значение 7.

57
Глава 1

1.4.2. Мастер вычислений

В листинге 1.12 было показано, как можно выполнять счет с помо-

щью программы. Алгоритм не сильно отличается от выполнения рас-
чета на листе бумаги. Немного необычно только то, что с левой стороны
расположена цель присвоения и знак равенства. Знак умножения — *,
знак деления — /. Плюс и минус выглядят привычно — + и -. Последний
можно использовать также в качестве знака числа.

Особый вид расчета — это модуль. Данная операция возвращает

остаток от деления целых чисел. Если деление в начальных классах еще
не забылось, тогда вероятно на ум придет фраза такого рода: «25 разде-
лить на 7 будет 3 и 4 в остатке». Такой же расчет остатка есть и в языке
C++. Обозначается он в качестве модуля. Знак операции — %.
rest = 25 % 7; // Остаток равен 4

В языке C++ также соблюдаются законы математики. Старое пра-

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

Бинарные операторы, символы расчета, которые соединяют между

собой два выражения, указываются, в основном, с левой привязкой. Это
означает, что они выполняются слева направо, если приоритет одина-
ков. То есть a*b/c будет интерпретировано как (a*b)/c. Единственное
исключение — это присваивание. Здесь a=b=c выполняется как a=(b=c).
Оператор присваивания является оператором с правой привязкой. Кро-
ме того правую привязку имеют одноразрядные операторы. Сюда отно-
сится оператор ++, с которым еще предстоит познакомиться.

В некоторых случаях нельзя однозначно сказать, в какой последо-

вательности будут выполняться операции. Следующий пример можно
интерпретировать по-разному:
а = 1;
b = (а*2) + (а=2);
Присваивание а=2 в правых скобках даст результат 2, как это было по-
казано при каскадном присваивании. Но будет ли операция присваивания
произведена перед или после операции в левых скобках, остается неясным.
Переменная b в этой строке может принять значение как 4, так и 6.

58
 Введение в программирование

Разработка программы и без того достаточно сложный процесс. По-

этому нужно избегать неточностей, насколько это возможно. Если ре-
зультат выражения может быть неоднозначным, следует использовать
скобки или производить расчет в несколько шагов. Старайтесь писать
программу настолько просто и предсказуемо, насколько это возможно.
Существует так называемый принцип KISS — Keep It Small and Simple
(Делай проще и короче). Код программы, состоящий из собрания изо-
щренных трюков, практически невозможно прочесть, поэтому он необ-
служиваемый и непрофессиональный.

1.4.3. Сокращения

Человек всегда стремится сделать все максимально удобным. Так же

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

Для увеличения значения на 1, можно использовать следующий код:

counter = counter + 1;
Листинг 1.13. Содержимое переменной counter увеличивается на 1

Это означает, что значение переменной counter изменяется путем

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

Часто новое значение переменной происходит из старого, которое

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

В следующей строке значение переменной counter также увеличи-

вается на 1:

counter +=1;
Листинг 1.14. Сокращенная запись инкрементирования

59
Глава 1

Здесь комбинируются плюс и знак равенства. Чтобы плюс не был

интерпретирован в качестве знака числа 1, он должен быть указан перед
знаком равенства. Между плюсом и знаком равенства не должно быть
пробелов. Значение строки следующее: «Добавь 1 к значению перемен-
ной counter».

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

не только для сложения, но и для вычитания, умножения, деления и по-
лучения остатка от деления (табл. 1.10).

Таблица 1.10. Короткая запись

Короткая запись Длинная запись

a += b a = a + b
a –= b a = a – b
a *= b a = a * b
a /= b a = a / b
a %= b a = a % b

В особом случае, когда значение увеличивается на 1, выражение мож-

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

counter++;
Листинг 1.15. Сверхкороткая запись

Как не сложно догадаться, этот двойной плюс и дал название языку

C++. Его еще называют языком С, который увеличен на 1.

Также существует двойной минус. Он уменьшает значение перемен-

ной на 1. Почему нет двойного астериска или двойного слеша, сложно
сказать.

Можно также использовать двойной плюс или минус с правой сто-

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

counter = 5;
Sum = 2 + counter ++; // Sum содержит 7!
Листинг 1.16. Инкремент с правой стороны

60
 Введение в программирование

Очевидно, что переменная counter после этих команд содержит

значение 6. Однако немного непонятно, какое значение имеет перемен-
ная Sum.

Верно предположить, что оно будет равно 7. Как сказано выше, уве-
личение переменной counter на 1 произойдет только после вычисле-
ния арифметического выражения. Можно также указать двойной плюс
перед переменной. Тогда ее значение сначала увеличится на 1, а затем
будет использовано для вычисления выражения.

counter = 5;
Sum = 2 + ++ counter; // Sum содержит 8!
Листинг 1.17. Другой результат

В этом случае переменная Sum будет иметь другое значение. Если

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

Следующие строки содержат то же самое, но значительно проще для

восприятия:

counter = 5;
++ counter;
Sum = 2 + counter;
Листинг 1.18. Аналогичная запись, но более легкая для прочтения

Расположение инкремента перед переменной называется префик-

сом. Это значит, что переменная сначала инкрементируется, и только
после этого используется.

Расположение инкремента после переменной называется постфикс.

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

В табл. 1.11 приведен обзор математических операторов в порядке

возрастания приоритета.
61
Глава 1

Таблица 1.11. Математические операции

Оператор Значение Пример

+ Сложение а=11+5; (16)
- Вычитание а= 11-5; (6)
* Умножение а= 11*5; (55)
/ Деление а=11/5; (2)
% Остаток от деления а= 11%5(1)
++ Инкремент ++а; или а++;
-- Декремент --а; или а--;

1.4.4. Понятие «функция» на примере функции

случайных чисел

Помимо основных операторов, язык C++ содержит ряд функций,

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

f = sin(45);

Здесь sin — это имя функции, 45 — передаваемый параметр, а ре-

зультат будет помещен в переменную f.

Рассмотрим функцию случайных чисел. Для некоторых учебных

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

Выданное компьютером случайное число не является на самом деле

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

Чтобы серия испытаний могла повторяться, имеется стартовая функ-

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

параметра. Если это значение уже было использовано, то в результате

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

С вызовом функции srand() инициализируется генератор случай-

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

После инициализации генератора случайных чисел с помощью

функции srand(), можно использовать функцию rand(), которая воз-
вращает квазислучайное число типа long. Каждый повторный вызов
этой функции возвращает новую случайную величину. Обе функции
находятся в стандартной библиотеке stdlib.

Следующая маленькая программа начинает вычисление случай-

ных величин с некоторой любой величины х. Затем дважды вызыва-
ется функция rand() и значение переменной chance становится слу-
чайным.

// Программа, иллюстрирующая работу функции случайных чисел

#include <stdlib.h>
int main()
{
const int some_start_value=9;
long chance; // здесь будет храниться результат
srand(some_start_value); // Трясем кубик
chance = rand(); // Бросаем один раз
chance = rand(); // Бросаем второй раз
}
Листинг 1.19. Случайные числа

Значение, которое возвращает функция rand(), как уже было сказа-

но, является положительным целым числом, которое каждый раз иное.
Минимальный результат может быть 0. Самое большое значение огра-
ничено в компиляторе константой RAND_MAX. На практике RAND_MAX ра-
вен LONG_MAX, примерное значение которого около двух миллионов.

Однако многие программы не используют настолько большие числа.

Обычно такие программы симулируют бросок кубика, цифру лото или
игральную карту. Чтобы сократить большие числа до 6, 49 или 52 зна-

63
Глава 1

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

Если нужно симулировать бросок кубика, используется модуль 6 и по-
лучаются значения между 0 и 5. Нужно только прибавить 1, и получатся
привычные символы от 1 до 6.

cube= rand() % 6 + 1;

Если для игры необходимо действительно непредсказуемое на-

чальное значение, я рекомендую использовать временны́е функции
(см. стр. 405). Количество секунд, начиная с 1.1.1970 до текущего мо-
мента, отлично подходит в качестве начального значения. Если кажется,
что эту величину можно легко рассчитать, используйте миллисекунды
по модулю 1000, которые прошли в промежутке времени, в течение ко-
торого пользователь вводил данные.

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

Преобразование значений одного типа в другой и обратно необходи-

мо, если нужно присвоить переменную одного типа переменной другого
типа. Так, при делении двух целых чисел получается целое число. Если
3 разделить на 4, получится 0 (и 3 в остатке). Но если нужно вместо
этого получить 0,75, следует один из операндов обозначить в качестве
числа с плавающей запятой, чтобы язык C++ использовал при обработ-
ке деление для чисел с плавающей запятой. Такое преобразование на-
зывают «кастинг»1. Чтобы выражение одного типа преобразовать в дру-
гой, имеются два определения. Первое унаследовано от языка C. Перед
выражением в скобках указывается желаемый тип результата. В языке
C++ ввели определение, при котором за именем типа следует в скобках
выражение, которое будет преобразовано в желаемый тип:

int value;
value = (int)something; // Классический C-кастинг
value = int(something); // C++

Некоторые преобразования в языке C++ проводятся без появления

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

64
 Введение в программирование

присвоено переменной типа long. В обратном случае все усложняется.

Число 200 000 не поместится в переменной типа short, поскольку она
занимает только 2 байта. Здесь компилятор, скорее всего, выдаст преду-
преждение о том, что информация может быть потеряна.

Может произойти так, что компилятор вместо чисел с плавающей

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

float price = (4/3)*5;

Содержимое переменной price может удивить — оно равно 5. При-

чина в том, что компилятор производит вычисление 3/4 как для целых
чисел и обрезает значения после запятой. Так что результат деления бу-
дет равен 1. Умножение его на 5 даст вышеуказанное значение. Одна-
ко скорее следует ожидать, что на кассе придется заплатить 6,67 рубля,
и продавец отклонит все доводы в пользу программы. В таких случаях
можно применить преобразование типов. Нужно как минимум один из
операндов выражения конвертировать в тип float, чтобы произвести
расчет для чисел с плавающей запятой. После согласования расчет даст
ожидаемые 6,66667.

float price = (float(4)/3)*5;

Наконец стоит сказать, что скобки вокруг 4/3 с точки зрения языка
C++ совсем не лишние, ведь выражение содержит операции одинакового
приоритета, и следовательно, будет вычисляться слева направо. Поэто-
му скобки имеют далеко не формальное значение. Тот, кто впоследствии
станет искать ошибку в программе, сразу увидит, как автор хотел рас-
ставить приоритеты. Если в каком-то выражении возникают сомнения
в приоритете вычислений, лучше указать больше скобок. Программа от
этого не станет выполняться медленнее. Компилятор все равно уберет
такие скобки при оптимизации.

1.5. Ввод и вывод

Вы с радостью убедитесь в том, как удивительно компьютер умеет
считать. Но даже если любопытство не относится к вашим порокам, так
или иначе однажды вам захочется узнать, что же рассчитал компьютер.
Рассмотрим функции вывода.
65
Глава 1

1.5.1. Потоковый вывод командой cout

Язык C++ использует для ввода и вывода потоковую модель. Пере-

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

Поток вывода и поток ввода находятся в одной библиотеке. Перед

первым использованием этих функций в программе нужно написать
следующие строки:
#include <iostream>
using namespace std;

В первой строке командой #include к программе подключается

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

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

std. Пространства имен позволяют разграничить одинаковые имена
переменных. Чтобы имя из стандартной библиотеки можно было ис-
пользовать в собственной программе или в других библиотеках, оно
расположено в пространстве имен std. Для каждого имени можно уста-
новить, будет ли оно использовано в пространстве имен std или в дру-
гом. Чтобы не возникало конфликтов, следует использовать команду
using namespace, которая установит, что пространство имен std рас-
пространяется на все элементы программы. Пространства имен будут
подробно рассмотрены на стр. 327.

Если используется старый компилятор C++, то он может еще не учи-

тывать пространства имен. Тогда он не сможет найти и файл iostream.
В таком случае придется использовать старые варианты подключения
файла iostream.h. Новый компилятор GNU Compiler при этом будет
выдавать предупредительные сообщения, что использование файла
iostream.h совсем устарело.
#include <iostream.h>

Для вывода данных используется команда cout1. Затем следует ком-

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

1 «Out» в команде cout переводится с английского языка как «наружу». Это направ-
ленный объект вывода. Буква «с» стоит впереди потому, что это любимая буква Бьерна
Страуструпа. Поэтому он и назвал свой язык C++.

66
 Введение в программирование

cout << result;

cout << endl;
Листинг 1.20. Вывод переменной

В примере выводится содержимое переменной result. В строке

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

Чтобы улучшить читаемость кода и сократить работу при его на-

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

cout << result << endl;

Листинг 1.21. Последовательность вывода

Так можно выводить не только переменные, но и константы. Это

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

cout << "Результат: " << result << endl;

Листинг 1.22. Выходная последовательность

Этот пример демонстрирует, что значение, которое сейчас появилось

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

Для вывода ошибок предусмотрен объект cerr. Обычно вывод про-

исходит так же, как при использовании команды cout.

Если же пользователь прерывает стандартный ход программы,

ошибки выдаются не в потоке вывода, а возникают на экране. Поэто-
му следует выводить данные с помощью команды cout, а сообщения об
ошибках с помощью команды cerr.

67
Глава 1

1.5.2. Форматированный вывод

Если выводить командой cout последовательно несколько строк,

они будут отображены друг за другом без каких-либо разделяющих зна-
ков. Вывод значения 8 и сразу же за ним следующий вывод числа 16 бу-
дут отображены на экране в виде 816. Соответственно, следует указать
между ними как минимум пару пробелов или поясняющих слов.
cout << "Было введено число: " << input
<< "После увеличения его вдвое получилось " << output << endl;

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

Чтобы узнать, сколько пробелов нужно выводить после каждого значе-
ния, нужно сначала выяснить, сколько позиций занимает каждое число.
Чтобы это упростить, существует, так называемый, манипулятор setw()1.
Он указывается перед командой cout и форматирует последующую вы-
водимую информацию. В скобках setw() указывается количество по-
зиций, которые резервируются для последующего вывода. Все позиции,
которые не занимает выводимая информация, заполняются пробелами,
данные выравниваются по правому краю. Прежде чем работать с ма-
нипуляторами, нужно подключить файл iomanip с помощью команды
include. Эти строки располагаются в самом начале программы:
#include <iostream>
#include <iomanip>
using namespace std;

В следующем примере символы обеих выводимых строк расположе-

ны рядом друг с другом и выровнены по правому краю.
cout << setw(7) << 3233 << setw(6) << 128 << endl;
cout << setw(7) << 3 << setw(6) << 1 << endl;

Дополнительную информацию о манипуляторах можно найти

на стр. 387.

1.5.3. Потоковый ввод командой cin

Чтобы считать данные, вводимые с клавиатуры, используется ко-

манда cin 2.
1
Слово «setw» состоит из «set width», что переводится как «установить ширину».
2
«in» в «cin» означает «внутрь». Это объект ввода. Происхождение буквы «с» я уже
объяснял.

68
 Введение в программирование

Оператор ввода состоит из двух символов >>. Они указывают на пе-

ременную, в которую будут записаны вводимые данные.

// Демонстрация ввода и вывода

#include <iostream>
using namespace std;
int main()
{
int input_number;
int increase;
cout << "Пожалуйста, введите число!" << endl;
cin >> input_number;
increase = input_number * 2;
cout << "Число, увеличенное вдвое "
<< increase << "." << endl;
}
Листинг 1.23. Простой диалог между пользователем и программой (inout.cpp)

1.6. Практические задания

• Перепишите листинг 1.23. Скомпилируйте и запустите. Введите
разные значения. В главе 6 вы найдете описание первых шагов при
работе с компилятором.
• Измените программу, удаляя некоторые части. Подумайте, к чему
приведут эти изменения. Если вы получите от компилятора сообще-
ние об ошибке, прочтите его. Попробуйте установить связь между
изменениями, внесенными в программу, и сообщением от компиля-
тора.
• Напишите программу, которая выводит на экран два слова «Привет,
пользователь».
• Напишите программу netto.cpp, которая в соответствии с вводимой
ценой за массу нетто товара вычисляет и выдает налог на добавоч-
ную стоимость. Будьте министром финансов и сами установите за-
кон о добавочной стоимости для вашей программы.
• Дополните программу netto.cpp так, чтобы она выводила цену за мас-
су брутто товара. Решение вы найдете на стр. 496.
69
 Глава 2
ЦИКЛИЧЕСКОЕ ПРОГРАММНОЕ
УПРАВЛЕНИЕ
Игра пришла в движенье.

До сих пор программы состояли только из следующих друг за дру-

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

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

Насыпать 6 ложек молотого кофе в фильтр
Налить в кофеварку 1 литр воды
Включить кофеварку
Подождать
Выключить кофеварку
Взять кофейник с напитком

На самом деле это далеко не полное описание процесса. На практике

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

Если в кофеварке находиться уже использованный одноразовый

бумажный фильтр
{
Вынуть его из кофеварки
Выкинуть в мусорный бак
}
Вынуть новый фильтр из пачки фильтров
Вставить фильтр в кофеварку
Повторить 6 раз:
{
Насыпать ложку молотого кофе в фильтр
70
 Циклическое программное управление

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

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

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

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

В таких случаях программа должна менять ход своего выполнения

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

2.1.1. По условию: if

С помощью команды if1 можно исключить выполнение отдельных

частей кода. Синтаксис команды if описан на рис. 2.1.

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

71
Глава 2

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

После ключевого слова if следуют скобки, в которых формулирует-

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

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

Надежнее всего команды и блоки команд, следующие после условия

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

В первом примере показано деление двух переменных. Если бы де-

литель был равен 0, это привело бы к сбою программы. Поэтому осто-
рожный программист перед расчетом организует проверку, равен ли де-
литель 0. Знак неравенства состоит из символов !=.

if (denominator != 0)
result = numerator / denominator;
Листинг 2.1. Проверка

Деление будет произведено только в том случае, если условие вы-

полняется, то есть делитель не равен нулю.

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

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

тельности называются вложением. В следующем примере представлены

вложения операторов 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.
73
Глава 2

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

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

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

Структурные диаграммы

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

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

В диаграмме Насси-Шнейдермана программа представлена в виде

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

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

При выполнении проверки блок вертикально делится пополам. Ле-

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

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

условие выполняется, правая — команды, которые следуют, если оно не

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

На рис. 2.5 представлено вложенное условие, которое описывает по-

следовательность действий для случая, когда человеку нужно сходить
в туалет.

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

Рассмотрим структурную диаграмму на примере программы для

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

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

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

75
Глава 2

if (year<3)
{
percent=3;
}
else
{
if (year<6)
{
percent=4;
}
else
{
percent=5;
}
}
Листинг 2.5. Вложенное условие if

«Висящий» else

Особая проблема с вложенными условиями может возникнуть в том

случае, когда при нескольких операторах if существует только один
оператор else. Эта проблема получила название «проблема висящего
else».

if (a == 0)
if (b == 0)
c=5;
else
cout << "К чему я отношусь?";
Листинг 2.6. «Висящий» else

При беглом рассмотрении можно подумать, что команда else отно-

сится к проверке переменной а. Но это только на первый взгляд. Из-за
того, что else располагается сразу же после проверки переменной а, ка-
жется, что else к ней и принадлежит. Но это не так. Язык C++ в таком

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

случае относит ключевое слово else к последней команде if, таким об-
разом, оно принадлежит к проверке переменной b.

Такая ситуация будет однозначной, если команды после if написа-

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

if (a == 0) if (a == 0)
{ {
if (b == 0) if (b == 0)
{ {
c=5; c=5;
} }
} else
else cout << "Куда?";
cout << "Куда?"; }
Листинг 2.7. Фигурные скобки однозначно указывают принадлежность

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

Пока не нарушаются правила формирования блоков, всегда будет по-
нятна структура кода и куда относится команда else.

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

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

2.1.3. Вариант за вариантом: switch case

Команда if позволяет реализовать проверку только двух вариантов:

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

77
Глава 2

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

ставлен отдельный вид товаров.

Сначала задача будет решена посредством каскадного использова-

ния команды if.

if (level == 1)
{
cout << "Сладости, книги" << endl;
}
else if (level == 2)
{
cout << "Одежда" << endl;
}
else if (level == 3)
{
cout << "Одежда" << endl;
}
else if (level == 4)
{
cout << "Игрушки" << endl;
}
else if (level == 5)
{
cout << "Электроника " << endl;
}
else
{
cout << "Гараж" << endl;
}
Листинг 2.8. Каскадная проверка оператором if

Если посмотреть внимательно, то я здесь немного смошенничал. Во-

обще, после каждой команды if и else нужно делать отступы. Но в дан-

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

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

Эта конструкция будет значительно проще, если использовать опе-

ратор выбора.

switch (level)
{
case 1:
cout << "Сладости, книги" << endl;
break;
case 2:
case 3:
cout << "Одежда" << endl;
break;
case 4:
cout << "Игрушки" << endl;
break;
case 5:
cout << "Электроника" << endl;
break;
default:
cout << "Гараж" << endl;
break;
}
Листинг 2.9. Оператор case

Оператор выбора начинается с ключевого слова switch. В следующих

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

79
Глава 2

В следующем за ключевым словом switch блоке находится строка

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

Если проверяемая величина не равна ни одному из определенных

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

На рис. 2.7 представлен граф синтаксиса оператора выбора

Рис. 2.7. Граф синтаксиса команды switch

Блок case представлен на отдельном графе на рис. 2.8.

Рис. 2.8. Граф синтаксиса блока case

В некотором отношении этот граф не совсем корректный. Если сле-

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

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

Пример с этажами может создать впечатление, что все возможные

значения проверяемой величины должны быть представлены непре-
рывной последовательностью. Это бессмысленно. Не нужно сортиро-
вать значения в порядке возрастания. Также не обязательно в конце ис-
пользовать оператор default.
На практике оператор выбора используется в случаях, когда необхо-
димо проверить реакцию на команду или результат работы. В програм-
мировании графических сред часто можно встретить такой оператор
выбора. Программы ожидают результата ввода данных с клавиатуры,
мыши или другого источника, распознают его, основываясь на сообще-
нии от системы, и реагируют заранее предписанным образом. Систем-
ные сообщения обычно являются целыми числами.
В следующем примере показано, что будет, если в переменной symbol
хранится символ. Оператор выбора интересуется символами от '3' до '6'
и символом '9'. Самый простой случай — если значение переменной
symbol будет равно '6'. Тогда переменной е будет присвоено значение 1.
Также и с цифрой '5' все достаточно просто. В этом случае, переменная d
получит значение 2.

switch (symbol)
{
case '3':
case '4':
case '9':
a = 4;
case '5':
d = 2;
break;
case '6':
e = 1;
break;
}
Листинг 2.10. Оператор выбора

Если значение переменной symbol равно '3', '4' или '9', тогда сначала
переменной a будет присвоено значение 4. Поскольку затем нет коман-

81
Глава 2

ды break, переменной d будет присвоено 2. Затем команда break пре-

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

В этом примере также показано, что оператор default необязателен.

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

2.1.4. Короткая проверка с помощью символа

вопросительного знака

С помощью вопросительного знака можно сократить проверки та-

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

Типично использование вопросительного знака в функциях вычис-

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

if (value >= 0)
{
Abs = value;
}
else
{
Abs = - value;
}
Листинг 2.11. Расчет абсолютной величины с помощью команды if

С помощью вопросительного знака можно определить это значитель-

но короче. Сначала нужно сформулировать условие (здесь: value >= 0).
Затем следует знак вопроса. После этого следует указать выражение,

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

которое должно использоваться, если условие выполняется (здесь:

Abs = value ). Через двоеточие должно располагаться выражение, кото-
рое будет использоваться в случае, если условие не выполняется (здесь:
Abs = - value).

Abs = value >=0 ? value : - value;

Листинг 2.12. Расчет абсолютной величины с помощью оператора
вопросительного знака

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

жение, то есть проверка (рис. 2.9). Выражение с вопросительным знаком
строится следующим образом:

Рис. 2.9. Граф синтаксиса выражения с вопросительным знаком

Многих программистов этот оператор сбивает с толку, особенно тех,

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

Следующий пример рассчитывает минимум между переменными a

и b и демонстрирует, как вопросительный знак может сократить про-
граммный код.

Minimum = a < b ? a : b;

Перед знаком вопроса проверяется, меньше ли переменная a пере-

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

2.2. Булевы выражения

«Что есть истина?», — спрашивает Понтий Пилат в Ин. 18, 38. В язы-
ке C++ поиск истины осуществляется с помощью булевых выражений.
Они могут использоваться в операторах if и ?, а также в циклах. Так что
пришло время рассмотреть их поближе.

83
Глава 2

Результат условия может принимать два состояния: истина или

ложь. Для истинного состояния в языке C++ используется ключевое
слово true, для ложного — false.

Язык C не знал этих двух ключевых слов, однако интерпретировал

число 0 в качестве лжи и любое другое число в качестве истины. Язык C++
унаследовал эти свойства, так что false можно задавать с помощью 0.

2.2.1. Переменные и константы

В языке C++ можно задавать логические константы. Они имеют тип

bool и могут принимать значения true или false. Хотя для таких пере-
менных теоретически используется только 1 бит, на практике они зани-
мают минимум 1 байт.

bool little = true;

little = a < b;
if (little)
{
...
Листинг 2.13. Булевы переменные

В языке C также можно найти булевы типы и константы. В среде

Windows распространены, в основном, BOOL, TRUE и FALSE. Они не явля-
ются элементами языка, а определяются с помощью макросов (стр. 325),
и подразумевают под FALSE — 0, под TRUE — 1, а под BOOL — тип char
или int.

2.2.2. Операторы

Самый простой способ сформулировать выражение — это сравнить

два численных значения. Чтобы узнать, больше или меньше первое чис-
ло второго, между операндами указывается знак <. Для быстрого запо-
минания можно представить, что знак < сделан из знака =, в котором
слева (со стороны прочтения) расстояние между двумя линиями умень-
шилось.

if (a < b)

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

Последующие за этой строкой команды будут выполнены только

в том случае, если содержимое переменной a будет меньше содержимо-
го переменной b.

Если добавить к знаку < знак =, можно получить условие «меньше

или равно», которое проверит, меньше или равно левое значение пра-
вому.

if (a <= b)

Для проверки условия «больше или равно» используется аналогич-

ная комбинация из символов >=. Между этими символами нельзя ука-
зывать пробел.

Чтобы проверить равенство двух значений, в языке C++ использу-

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

if (a == b)

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

если значения переменных a и b равны друг другу.

К сожалению, здесь может подстерегать ловушка. Посмотрите на

следующий код:

if (a=1) // Осторожно! Присваивание, а не проверка!

{
a=5;
}
Листинг 2.14. Коварная западня!

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

значение 5, если значение переменной a равно 1. Но на самом деле речь
идет о присваивании а=1. После выполнения команды if переменной a
будет присвоено значение 1. Вероятно, не это планировал программист.
Отсюда следует, что результатом выражения в скобках всегда будет 1,
потому что выполнение происходит справа налево. Однако любое чис-
ло, отличное от 0, всегда интерпретируется как истина, и присваивание
а=5 будет выполнено в любом случае. Правильная запись этого условия
выглядит так:

85
Глава 2

if (a==1)
{
a=5;
}
Листинг 2.15. Исправлено!

Вследствие особой коварности такого кода, если в условии будет

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

Некоторые программисты приобретают привычку в проверочном

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

С другой стороны, можно исходить из того, что программист, ис-

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

Знак неравенства состоит из последовательности символов !=. Вос-

клицательный знак представляет собой отрицание.

Таблица 2.1. Сравнение числовых значений

Оператор Значение
a == b a равно b ?
a != b a неравно b?
a > b a больше b?
a >= b a больше или равно b?
a < b a меньше b?
a <= b a меньше или равно b?

В одном условии можно сравнить только два операнда друг с дру-

гом. Если нужно проверить, например, лежит ли значение переменной a
в диапазоне между 5 и 10, нужно использовать две операции сравнения.
Следующая проверка вряд ли будет одобрена компилятором.

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

if (5<=a<=10) // не работает!
{
// сделай что-нибудь;
}
Листинг 2.16. Еще один коварный случай!

Сначала компилятор вычислит выражение 5<=a1. Оно может быть

истинным или ложным, и в результате получится 1 или 0. Далее полу-
ченное значение будет проверено на соответствие условию <=10. По-
скольку 0 или 1 меньше 10, выражение в примере будет всегда иметь
значение true. В действительности автор хотел здесь проверить, будет
ли значение переменной a больше или равно 5, и меньше ли 10 значение
переменной a.

if (5<=a)
{
if (a<=10)
{
// сделай что-нибудь;
}
}
Листинг 2.17. Решение с помощью вложения

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

оба условия, чтобы выполнился внутренний блок.

2.2.3. Объединение булевых выражений

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

которых будет true, можно использовать объединение с помощью опе-
рации «И». Пример: если некоторое значение должно лежать в опре-
деленном интервале, нужно составить два условия: значение должно
быть равно хотя бы минимуму интервала и не должно превышать мак-
симум. Оба условия должны быть определены, чтобы общее условие

1
Для экспертов: операция сравнения является операцией с левой привязкой.

87
Глава 2

выполнялось. Такое объединение называется «И» и обозначается сим-

волами &&.

if (5<=a && a<=10)

{
// сделай что-нибудь;
}
Листинг 2.18. Решение с помощью «И» объединения

Другой пример: фирма выплачивает дополнительный денежный

бонус только в том случае, если сотрудник состоит в штате и рабо-
тает в фирме минимум полгода. Здесь также должны выполняться
оба условия и речь идет о необходимости использования «И» объеди-
нения.

Следующая таблица истинности (табл. 2.2) демонстрирует все воз-

можные комбинации обоих операндов и какой результат даст их «И»
объединение:

Таблица 2.2. Таблица истинности для операции «И»

a b a && b
true true true
true false false
false true false
false false false

Другое дело, когда необходимо проверить утверждение, что величи-

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

Если значение меньше, чем минимум, значит, оно уже лежит вне ин-
тервала. Объединение, которое приводит к результату true, если одно
из объединенных условий истинно, называется «ИЛИ»-объединением
и обозначается с помощью символов ||1.

1 В некоторых таблицах символов этот символ изображается не непрерывной чер-

той, а с зазором посередине.

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

if (5>a || a>10)
{
// сделай что-нибудь;
}
Листинг 2.19. Объединение «ИЛИ»

Вернемся к одному из примеров: одна довольно щедрая фирма мог-

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

Таблица 2.3. Таблица истинности для операции «ИЛИ»

a b a||b
true true true
true false true
false true true
false false false

Третий логический оператор отрицает булево значение. Оператор

«НЕ» влияет на один операнд и обозначается в языке C++ с помощью
знака !. Если выражение, перед которым указан восклицательный знак,
равно true, то результат операции будет false.

Таблица 2.4. Таблица истинности для операции «НЕ»

a !a
true false
false true

 Результатом операции «И» будет значение «истина» только в том

случае, если все операнды имеют значение «истина».
Результатом операции «ИЛИ» будет значение «истина» в том случае,
если как минимум один из операторов имеет значение «истина».

Обратите внимание на оба определения операций «И» и «ИЛИ».

Языковое использование очень часто бывает неряшливым. Если, напри-

89
Глава 2

мер, в музее висит предупреждение, что запрещено кататься на роликах

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

В языке C++ нет специального выражения для выполнения опера-

ции «или-или». Однако такая операция часто называется «сложение
по модулю два» (в английском языке обозначается как XOR). Конечно,
можно реализовать ее на основе «И» и «ИЛИ». Для этого рассмотрим
таблицу истинности, где обозначено, когда выражение имеет значение
true, а когда false.

Таблица 2.5. Таблица истинности для операции «сложение по модулю два»

a b a XOR b
true true false
true false true
false true true
false false false

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

бы все строки, которые истинны, скопировать и объединить с помощью
«ИЛИ». Пример такой копии — две средние строки таблицы. Первая
строка звучит в качестве «a И НЕ b», где a истинно или true, а b —
ложно или false. Вторая строка — «НЕ a И b». В конце концов, оба вы-
ражения связаны с помощью «ИЛИ». Для контроля можно построить
следующую таблицу (табл. 2.6).

Таблица 2.6. Таблица истинности (а И НЕ b) ИЛИ (НЕ a И b)

a b a && !b !a && b (a && !b)|| (!a && b)
true true false false false
true false true false true
false true false true true
false false false false false

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

Второй вариант представляет собой попытку связать воедино все

строки, значение которые истинно. Если при этом появляется пара
строк со значением «ложь», их надо исключить. Например, выражение
«а ИЛИ b» включало бы три верхние строки. Только первая строка не
подходит к выражению «a XOR b», так что она исключается с «И НЕ».
Выражение имеет вид: «(a ИЛИ b) И НЕ (a И b)». Рассмотрим таблицу
истинности (табл. 2.7) также и для этого выражения, чтобы проверить,
правильно оно или нет.

Таблица 2.7. Таблица истинности для выражения «(a ИЛИ b) И НЕ (a И b)»

a b a || b a && b (a || b) && !(a && b)
true true true true false
true false true false true
false true true false true
false false false false false

Закон Де Моргана

При инверсии (отрицании) логических выражений можно стол-

кнуться с некоторыми сюрпризами. Здесь действует закон Де Моргана:

!(a && b) эквивалентно !а || !b

!(а || b) эквивалентно !а && !b

Для примера инвертируем условие, которое проверяет, лежит ли

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

if (a>=2 && a<=5)

Самая простая форма построения инверсии — заключить выраже-

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

if (!(a>=2 %% a<=5))

Это выражение работает без нареканий, поэтому лучше использо-

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

if (a<2 && a>5) // быстро, но неверно!

91
Глава 2

Здесь проверялось бы, является ли переменная a меньше, чем 2,

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

if (!(a>=2) || (a<=5))

Теперь части целого выражения можно упростить: (!a>=2) легче

преобразовать в a<2. Точно так же выражение !(a<=5) эквивалент-
но a>5. Таким образом, правильно преобразованное условие име-
ет вид:

if (a<2 || a>5)) // правильная инверсия!

Переменная a лежит вне интервала, если она меньше 2 или больше 5.

Если одно из выражений истинно, то результатом проверки всего усло-
вия будет «истина».

Если переменная a лежит в интервале, то оба выражения будут лож-

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

Отсюда следует, что логическая операция «И» будет инвертирова-

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

Короткое замыкание

Программа при обработке логического условия не обязана проверять

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

Этот факт используется в языке C++ для увеличения коэффициента

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

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

ведение едва ли можно почувствовать, так как выигрыш в скорости не-

значителен. Однако сложнее, если второе выражение помимо поиска
истины выполняет что-либо еще.

if ((salary<20000) && (personal_nr++>10))

{
...
Листинг 2.20. Короткое замыкание

При нормальном выполнении программой такой операции, значе-

ние переменной personal_nr будет увеличено на 1. Однако фактиче-
ски это произойдет только в том случае, если зарплата не меньше 20000.
Если же переменная personal_nr должна инкрементироваться даже
для сотрудников с маленькой зарплатой, следует поменять последова-
тельность условий:

if ((personal_nr++>10) && (salary<20000))

{
...
Листинг 2.21. Последовательность написания условий также важна!

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

должны быть только проверки или логические операции. Арифметиче-
ские операции надежнее располагать до или после условия.

personal_nr++;
if ((personal_nr>10) && (salary<20000))
{
...
Листинг 2.22. Конец головоломкам

Но если вы хотите сами представить логику, которой пользуется

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

93
Глава 2

if (salary<20000)
{
if (personal_nr++>10))
{
...
Листинг 2.23. Идентично, но более наглядно

Здесь более четко представлено то, что вы намереваетесь сделать.

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

2.3. Постоянные повторения: циклы

Существует много задач, в которых нужно повторять команды, пока
не будет получен рассчитываемый результат. Такое повторение в програм-
мировании называется циклом. Любая форма перечисления будет реали-
зована в программе с помощью цикла. При расчете нулевых условий по
правилу ложного положения (или метод regula falsi) в каждом цикле вы-
числяется новое приближение, пока не будет найдено значение функции
при нулевых условиях с указанной точностью. В компьютерной игре мож-
но стрелять до тех пор, пока не будет уничтожен последний космический
корабль. Цикл повторяет определенные команды, но всегда имеет усло-
вие, по которому он будет прерван. Или, если сформулировать позитивно:
цикл будет повторяться до тех пор, пока действительно его условие.

Необходимо внимательно следить за правильностью условия цик-

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

2.3.1. Цикл с предусловием: while

Самый простой цикл начинается с ключевого слова while. В перево-

де на русский язык оно означает «пока». И это уже дословно описывает

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

то, как работает данный цикл. Он повторяет команды, пока некоторое

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

Синтаксис цикла очень напоминает команду if. Фактически разли-

чие состоит только в том, что в цикле эта команда повторяется. Если
условие не выполняется, цикл ведет себя так же, как оператор if: коман-
ды попросту не будут выполняться.

Цикл начинается с ключевого слова while. В скобках указывается

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

Рис. 2.10. Граф синтаксиса while

Подумайте, что вы делаете, когда считаете. Вы начинаете с опреде-

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

В программе используется переменная, которая устанавливается

в качестве начальной. Ее значение должно быть определено до начала
цикла, иначе при каждом повторении переменной будет присваивать-
ся ее начальное значение, и цикл станет бесконечным. Предположим,
в процессе выполнения цикла программа каждый раз увеличивает пере-
менную на 1. Цикл начинается с ключевого слова while. Сразу же за
ним в скобках формулируется условие. До тех пор, пока условие дей-
ствительно, программа остается в цикле. Если нужно посчитать до 10,
следует проверять, меньше или равна переменная 10. Сразу за условием
можно определить команду, которая будет повторяться в цикле. Если
требуется увеличивать переменную и выводить ее значение на экран, то
нужно использовать две команды. Это можно организовать, используя
блок, то есть структуру с фигурными скобками. В блоке будет располо-
жен вывод переменной и последующее ее увеличение.
95
Глава 2

#include <iostream>
using namespace std;
int main()
{
i = 1; // Установлено начальное значение переменной
while (i <= 10) // Условие цикла
{
cout << i << endl; // Вывод
i++; // Без этой строки цикл будет выполняться //бесконечно
}
}
Листинг 2.24. Счет

При определении границ цикла легко допустить ошибки. Если вме-

сто <= будет использован только символ <, программа будет считать
только до 9. Причина в следующем: как только значение переменной i
достигнет 10, условие больше не будет выполняться и цикл прервется.
Также можно построить цикл, выполняющийся 10 раз, в котором счет
начнется с 0 и в условии станет проверяться, меньше ли значение пере-
менной, чем число 10. Тогда переменная i будет принимать значение от
0 до 9. Если увеличивать значение i перед выводом его на экран, можно
получить значения от 1 до 10.

#include <iostream>
using namespace std;
int main()
{
i = 0;
while (i < 10)
{
i++;
cout << i << endl;
}
}
Листинг 2.25. Счет, вариант №2

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

while проверяет условие перед началом цикла. Это означает, что

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

Структурная диаграмма цикла while представлена на рис. 2.11.

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

Рис. 2.11. Структурная диаграмма цикла while

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

i = 10;
while (i > 0)
{
i--;
}
Листинг 2.26. Обратный счет

Здесь переменная i имеет начальное значение 10. В условии цик-

ла проверяется, больше ли нуля значение переменной i. Это верно, так
что программа входит в цикл и начинает выполнять его тело. Тут про-
исходит только уменьшение значения переменной i на 1, поэтому пере-
менной i после первого прохода цикла будет присвоено значение 9. Это
без сомнений больше, чем 0. Цикл будет повторяться до тех пор, пока
значение переменной i вследствие декрементирования не уменьшится
до 0. Тогда при следующей проверке условие цикла не будет выполнять-
ся, и программа сразу же его покинет.

97
Глава 2

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

ния можно поразмыслить, что будет выводиться на экран, если располо-
жить команду вывода перед или после декрементирования переменной
i в цикле. Если вы уверены в том, что произойдет — проверьте!

2.3.2. Цикл с постусловием: do-while

В некоторых ситуациях проверка в начале цикла неудобна. Иногда

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

Типичное использование цикла с постусловием в программирова-

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

Еще один пример — игра «Сапер». Пользователь должен нажать

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

На рис. 2.12 представлен граф синтаксиса цикла do-while.

Рис. 2.12. Граф синтаксиса цикла do-while

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

бы в цикле выполнялось несколько команд.

Структурная диаграмма отличается от диаграммы while тем, что

условие указано в конце цикла (рис. 2.13).
1 Наученные опытом родители твердо уверены, что конечное условие системы «де-
душка» не выполняется.

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

Рис. 2.13. Структурная диаграмма цикла do-while

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

и подумайте, будут ли выведены цифры 10, 1 и 0! Затем проверьте, соот-
ветствуют ли действительности ваши предположения.

#include <iostream>
using namespace std;
int main()
{
int i = 10;
do
{
cout << i << endl;
i--;
}
while(i>0);
}
Листинг 2.27. Цикл do-while

2.3.3. Шаг за шагом: for

Оба рассмотренных ранее цикла требуют три элемента:

• Инициализации перед началом цикла.
• Условия, которое должно выполняться, чтобы цикл работал.
• Некоторого действия, вследствие которого результат условия может
измениться.
99
Глава 2

Если не хватает одного из этих элементов или он некорректно опре-

делен, есть риск получить бесконечный цикл. Цикл for «помнит» все
эти три элемента. Так как они собраны в одном месте, их легко контро-
лировать. Цикл, как правило, используется при счете; и в этом случае
особенно проявляется предусмотрительность цикла for. В следующем
примере показан счет от 0 до 9.

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

{
cout << i << endl;
}
Листинг 2.28. Счет с помощью цикла for

В скобках, которые следуют за ключевым словом for, вначале ука-

зывается инициализация стартового значения, где значение переменной
i устанавливается равным 0. При использовании цикла while инициа-
лизация проводится перед началом цикла. На втором месте в скобках
располагается условие цикла. Третья команда — инкрементирование
переменной счетчика, которая обычно указывается в конце цикла. Эти
три элемента разделяются с помощью точек с запятой. Цикл for струк-
турирован следующим образом:

Рис. 2.14. Граф синтаксиса цикла for

Цикл for очень похож на цикл while. Только первый элегантнее

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

 Стартовая команда;
while(условие)
{
Тело цикла;
Завершающая команда;
}

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

Как и было обещано, данная структурная диаграмма не отличает-

ся от диаграммы цикла while. Только часть, расположенная для while
в начале цикла, определяется в цикле for в области условия (рис. 2.15).

Рис. 2.15. Структурная диаграмма цикла for

Некоторые программисты в структурной диаграмме помещают за-

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

Если требуется несколько команд в стартовом или заключительном

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

#include <iostream>
using namespace std;
int main()
{
int i, a;
for (i=0, a=10; i<5; i++, a--)
{
cout << i << "-" << a << endl;
}
}
Листинг 2.29. Несколько команд в управляющей части цикла for

101
Глава 2

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

выражения. И при этом объединяет их в одну команду. Соответственно
с точки зрения компилятора i=0, a=10 — одна команда, которая состоит
из двух выражений, разделенных оператором запятой.

Три элемента в скобках цикла for могут отсутствовать. Если началь-

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

Особый вариант цикла for то и дело встречается в примерах про-

грамм. Если программист специально хочет написать бесконечный
цикл, то для этого часто используется цикл for, в скобках которого нет
ничего, кроме двух знаков точки с запятой. Две пустые позиции язык
C++ расценивает, как истину. Очевидно, он всегда настроен оптими-
стично. Там, где условия цикла каждый раз являются истиной, програм-
ма никогда не выходит из цикла. Такой тип бесконечного цикла имеет,
однако, другой выход, кроме как по главному условию, определенному
вначале. Сюда относится, например, команда break, которая будет опи-
сана в следующей главе.
for (;;) // будет работать до следующего отключения
электричества
{
...
}

2.3.4. Выходы из цикла: break и continue

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

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

error=0;
while (a>0)
{
...
c=4;

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

if (error==9)
{
break;
}
a++;
...
}
Листинг 2.30. Цикл прерывается командой break

Такой механизм, конечно, неслыханно практичен. Можно сразу же

среагировать на определенное событие, которое требует покинуть цикл.
Но такая конструкция имеет две ошибки, если рассматривать ее с точки
зрения красоты стиля. Во-первых, уже не однозначно ясно, на основа-
нии какого условия был покинут цикл, во-вторых, команды до и после
оператора if выглядят расположенными на одном уровне. Но все же ко-
манда a++ выполняется не по тому же условию, что с=4.

Слишком частое использование оператора break свидетельству-

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

error=0;
while (error!=9 && a>0)
{
...
c=4;
if (error!=9)
{
a++;
...
}
}
Листинг 2.31. Альтернатива оператору break

103
Глава 2

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

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

while (a>0)
{
...
c=4;
if (error==9)
{
continue;
}
a++;
...
}
Листинг 2.32. Команда continue пропускает оставшуюся часть тела цикла

Использование команды continue еще более простое, чем команды

break. Ее единственное достоинство при использовании в проверочном
блоке if состоит в том, что команда а++ не будет выполнена. Но, в то же
время, именно это и является недостатком: можно не заметить, что эта
команда будет выполняться только тогда, когда значение переменной
error не будет равно 9.

while (a>0)
{
...
c=4;

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

if (error!=9)
{
a++;
...
}
}
Листинг 2.33. Альтернатива команде continue

2.3.5. Грубый скачок: goto

С помощью команды goto можно перейти в любую желаемую по-

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

if (a==0)
{
a++;
goto middle;
}
b+=2;
if (b>6)
{
goto end;
middle:
// здесь b>6 или a==1
b=4;
}
else
{
c=2;
}
end:
a++;
Листинг 2.34. Дикие скачки

105
Глава 2

Прыжок в позицию с меткой middle: демонстрирует, какое безобра-

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

Если вы будете постоянно использовать в своих программах опера-

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

В старых (действительно старых) языках программирования был

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

Современные языки имеют все инструменты для организации усло-

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

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

2.4.1. Простые числа

Простое число — это число, которое можно разделить без остатка

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

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

Программа должна выводить все простые числа между 3 и 100. Та-

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

#include <iostream>
using namespace std;
int main()
{
const int max_prime_number =100; // Конец расчета
int prime_number; // Тестовый кандидат
for (prime_number =3; prime_number <= max_prime_number;
prime_number ++)
// Проработать все числа
{
// Проверить, является ли число действительно //простым чис-
лом
// Тестовый вывод:
cout << prime_number << " ";
}
cout << endl;
}
Листинг 2.35. Простые числа с первым циклом

В цикле организован тестовый вывод. Таким образом можно видеть,

что простые числа действительно следуют от 3 до 100. Если вы не уве-
рены, выполняют ли определенные части кода программы то, что вы
ожидаете, спокойно используйте такой вывод. Потом его можно уда-
лить. Если складывается впечатление, что выводимое количество чи-
сел слишком большое, следует просто уменьшить значение переменной
max_prime_number до 10.

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

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

107
Глава 2

В этом цикле будет происходить деление. Он начинается с 2 и заканчи-

вается на значении prime_number - 1.

#include <iostream>
using namespace std;
int main()
{
const int max_prime_number =100;
int prime_number, divisor;
for (prime_number=3; prime_number<=max_prime_number;
prime_number++)
{
// Проверка, является ли простое число действительно //про-
стым
for (divisor=2; divisor<=prime_number-1; divisor++)
{
// Тестовый вывод
cout << divisor << " ";
}
cout << endl;
}
cout << endl;
}
Листинг 2.36. Простые числа с внутренним циклом

Теперь надо проверить, делится ли prime_number на divisor. Для

этого уже можно использовать команду %, которая вычисляет остаток от
числа. Она возвратит 0, если при делении нет остатка. Таким образом,
нужно составить условие, которое будет проверять, есть ли остаток от
деления переменной prime_number на переменную divisor.

#include <iostream>
using namespace std;
int main()
{
const int max_prime_number=100;

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

int prime_number, divisor;

for (prime_number=3; prime_number<=max_prime_number;
prime_number++)
{
// Проверка, является ли простое число действительно //про-
стым
for (divisor=2; divisor<prime_number; divisor++)
{
// деление без остатка?
if (0==prime_number % divisor)
{
// Число можно разделить, значит оно не //простое!
// Тестовый вывод:
cout << prime_number << "-" << divisor << endl;
}
}
cout << endl;
}
cout << endl;
}
Листинг 2.37. Простые числа с проверкой на делимость

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

кандидаты в простые числа и их делители. Эти числа не являются про-
стыми, поскольку у последних не может быть делителя. Если программа
заметит это при выполнении данного фрагмента кода, она будет знать,
что кандидат не является простым числом. Чтобы запомнить состояние,
лучше всего использовать переменную типа bool.

#include <iostream>
using namespace std;
int main()
{
const int max_prime_number=100;
int prime_number, divisor;
bool the_prime_number;
cout << "2";
109
Глава 2

for (prime_number=3; prime_number<=max_prime_number;

prime_number++)
{
the_prime_number = true;
// Проверка, является ли простое число действительно //про-
стым
for (divisor=2; divisor<prime_number; divisor++)
{
// Есть ли остаток от деления?
if (0== prime_number % divisor)
{
// Число можно разделить, значит оно не //простое!
the_prime_number = false;
}
}
// Проверка окончена.
// Если это простое число, выводим его!
if (the_prime_number)
{
cout << ", " << prime_number;
}
}
cout << endl;
}
Листинг 2.38. Расчет простых чисел завершен (prime_number.cpp)

Эта программа выполняет требования, которые были установле-

ны вначале. Прежде объявляется переменная the_prime_number. Для
каждого нового кандидата значение этой переменной устанавливается
равным true. Если появляется остаток от деления, значение перемен-
ной устанавливается равным false. После того как все делители будут
проверены, если при этом значение переменной the_prime_number все
еще останется true, то кандидат будет выведен на экран. Число 2 будет
просто выведено в начале, без всяких расчетов. Вообще-то такое реше-
ние не является оптимальным, так как внутренний цикл продолжит вы-
полняться даже в том случае, если при делении кандидата на 2 не будет
остатка. Это можно легко остановить, если добавить в цикл еще одно

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

условие. Оно станет проверять, было ли проведено деление числа для

всех делителей, а также был ли при делении получен остаток.

#include <iostream>
using namespace std;
int main()
{
const int max_prime_number=100;
int prime_number, divisor;
bool the_prime_number;
cout << "2";
for (prime_number=3; prime_number<=max_prime_number;
prime_number++)
{
the_prime_number = true;
// Проверка, является ли простое число действительно //про-
стым
for (divisor=2; the_prime_number &&
divisor < prime_number; divisor++)
{
// Есть ли остаток от деления?
if (0==prime_number % divisor)
{
// Число можно разделить, значит оно не //простое!
the_prime_number = false;
}
}
// Проверка окончена.
// Если это простое число, выводим его!
if (the_prime_number)
{
cout << ", " << prime_number;
}
}
cout << endl;
}
Листинг 2.39. Оптимизированный расчет простых чисел

111
Глава 2

Эта программа возвращает точно такой же результат, как и предыду-

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

Рис. 2.16. Структурная диаграмма программы расчета простых чисел

2.4.2. Наибольший общий делитель

Наибольший общий делитель (НОД) двух чисел — это самое большое

число, на которое без остатка делятся два числа. Расчет НОД использует-
ся в математике для дробей. Если числитель и знаменатель разделить на
наибольший общий делитель, то дробь будет максимально сокращена. Ал-
горитм вычисления НОД может базироваться на алгоритме вычисления
простых чисел. Для этого оба числа раскладываются на простые множите-
ли и все общие простые множители для этих чисел между собой перемно-
жаются. Но можно сделать еще проще. Эвклид уже около 2000 лет назад
описал очень легкий способ преобразования для вычисления НОД.

Оба числа, для которых нужно найти НОД, назовем a и b. Идея осно-
вывается на том утверждении, что НОД — делитель не только для a и b, но

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

также для b и (a-b), пока b больше, чем a1. Значит, можно рассматривать
вместо a и b равнозначно b и (a-b) и уже не нужно искать, какое из этих
чисел больше. Так же можно поступить с двумя другими числами, не толь-
ко с a и b. Снова вместо большего числа будет использована разница между
ними. При дальнейшем повторении этого способа, когда самое маленькое
число станет равно 0, второе число при этом будет НОД (рис. 2.17).

Рис. 2.17. Структурная диаграмма для поиска НОД

В данном примере разработчик программы должен начинать со струк-

турной диаграммы. Следом записываются оба кандидата. Затем цикл по-
вторяется, пока меньшее число остается больше 0. Внутри цикла должно
проверяться, какое из двух чисел больше. В данном случае значения могут
меняться местами, перед тем как одно из них будет вычтено из другого. Так
формализуется общее описание алгоритма и вставляется в структурную
диаграмму. Почти все можно сразу описать кодом на языке C++. Только об-
мен содержимого в переменных нужно раскрыть подробнее, перед тем как
вставить этот код в программу. Может возникнуть идея написать сначала
a=b и потом b=a. Но это, однако, не станет работать, потому что содержимое
переменной a при первом присваивании будет изменено и, следовательно,
потеряно. Поэтому следует использовать вспомогательную переменную,
которая сохранит содержимое переменной а перед тем, как оно изменится.

help = a;
a = b;
b = help;
Листинг 2.40. Обмен значений переменных

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

113
Глава 2

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

мы. Одновременно здесь использован синтаксис языка C++ (рис. 2.18).

Рис. 2.18. Более подробная структурная диаграмма для НОД

Теперь это легкая задача — перенести структурную диаграмму в со-

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

#include <iostream>
using namespace std;
int main()
{
int a, b, help;
cin >> a;
cin >> b;
while (b>0)
{
if (b>a)
{
// обмен a и b
help = a;
a = b;
b = help;
}

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

a = a - b;
}
cout << a << endl;
}
Листинг 2.41. Программа на языке C++ для нахождения НОД

2.5. Упражнения
• Дополните программу netto.cpp (см. стр. 497) из последней главы,
чтобы она проверяла, больше ли 0 цена за массу нетто товара, и толь-
ко тогда проводила расчет.
• Добавьте в программу netto.cpp сообщение об ошибке, которое будет
выводиться, если пользователь ввел некорректные данные. Пример
решения приведен на стр. 497.
• Сложные проценты: вы ежегодно вносите на счет под 5% годовых по
5000 Евро. Создайте таблицу с годовым взносом слева и состоянием
счета справа. Пример решения на стр. 498.
• Угадывание чисел: пусть компьютер выберет случайное число в диа-
пазоне от 1 до 1000. Пользователь вводит число и компьютер сооб-
щает, больше, меньше или равно это число тому, которое он выбрал.
Это будет повторяться до тех пор, пока пользователь не угадает чис-
ло. Пример решения приведен на стр. 498.
 Глава 3
ТИПЫ ДАННЫХ И СТРУКТУР
Час управления типами данных:
в этой главе будут собраны воедино
все базовые типы, а из них созданы новые.

Для отображения реальных данных недостаточно только базовых

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

3.1. Массив
Массив1 — это комбинация нескольких переменных одного типа.
К элементам массива обращаются по их позиционному номеру.

Массивом можно описать ряд элементов одного типа. Примером мо-

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

1 5 13 27 43 44

[0] [1] [2] [3] [4] [5]

Рис. 3.1. Числа лото в массиве

На рис. 3.1 показано, как расположены числа лото в массиве. Под

каждой ячейкой находятся квадратные скобки, в которых указана по-
зиция числа. Вопреки человеческой привычке, нумерация элементов
в массиве начинается с 0. Если в массиве хранится шесть чисел, послед-
няя позиция будет иметь номер 5.
1 Понятие «массив» часто переводится как «поле». Однако этот термин не очень
точен, и многие программисты предпочитают использовать слово «массив». Я также при-
надлежу к их числу, поэтому использую его в данной книге.

116
 Типы данных и структур

Чтобы объявить в программе массив для чисел лото, сначала нужно

указать тип одного-единственного элемента. Затем следует имя масси-
ва. В квадратных скобках следует количество элементов в массиве, ко-
торые он должен содержать.
int lotto[6];
То, что максимальный индекс массива 5, а элементов в нем 6, выгля-
дит немного странно. Однако нужно привыкнуть, на этом еще неодно-
кратно будет акцентироваться внимание.

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

шесть переменных целого типа. Когда программа покидает блок, в кото-
ром находится объявление массива, память автоматически отчищается.

Если требуется получить доступ к одному из элементов массива,

сначала нужно указать имя всего массива. Затем в квадратных скобках
следует номер элемента, доступ к которому требуется получить. При
этом всегда важно помнить, что нумерация элементов в массиве начи-
нается с нуля.
lotto[2] = rand() % 49 + 1;
cout << lotto[0];

Первая строка демонстрирует, как третьему элементу массива — не

второму — можно присвоить случайное число от 1 до 49. Вторая строка
выводит значение первого элемента на экран.

Синтаксический опознавательный знак массива — это квадратные

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

int lotto[6];
srand(0);
for(i=0; i<6; i++)
{
lotto[i] = rand() % 49 + 1;
}
Листинг 3.1. Числа лото в виде массива

117
Глава 3

Переменная lotto — массив чисел целого типа. Квадратные скоб-

ки с числом 6 внутри говорят о том, что здесь будет храниться 6 пере-
менных. Как получить доступ к этим значениям, показано в цикле for.
Каждой из шести переменных по порядку присваиваются случайные
значения в диапазоне от 1 до 49. Которая из переменных использует-
ся — показано в квадратных скобках. Номер позиции называется индек-
сом. В языке C++ он всегда начинается с 0. Поскольку в данном массиве
6 элементов, индекс приобретает значения от 0 до 5.

Там, где элементы приобретают значение случайным образом, не

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

int lotto[6];
int i, j;
bool new_number;
srand(0);
for(i=0; i<6; i++) // вытащим одно за другим шесть чисел
{
do // повторим вытаскивание числа до нового значения
{ // число отличается от всех предыдущих
lotto[i] = rand() % 49 + 1;
new_number = true; // удовлетворительный набор
for (j=0; j<i; j++)
{ // просмотреть все, ранее вытащенные шарики
if (lotto[j]==lotto[i])
{ // здесь обнаружено дублирование значения
new_number = false;
}
}
} while (!new_number);
}
Листинг 3.2. Числа лото в виде массива (lotto.cpp)

118
 Типы данных и структур

Внешний цикл с переменной i в качестве индекса перебирает все

выбранные числа лото по порядку. Сама процедура выбора числа про-
исходит в цикле do-while, который должен повторяться, пока не будет
выбрано такое число, которого еще не было ранее. Решение может быть
принято только по окончании выполнения тела цикла. Поэтому в дан-
ном случае удобнее всего использовать цикл с постусловием. После вы-
бора производится проверка. Во внутреннем цикле for просматривают-
ся все ранее полученные числа. Это означает, что индекс j начинается
с 0 и остается меньше i, поэтому он всегда меньше, чем индекс только
что выбранного числа. В случае появления идентичного значения, пере-
менная new_number типа bool будет установлена в false. Это приведет
к повторению операции выбора числа. После каждой такой операции
эта переменная должна устанавливаться в true, иначе цикл никогда не
будет покинут, если однажды встретится повторяющееся значение.

Как уже упоминалось, каждый массив начинается с индекса 0. Это

часто сбивает с толку. Массив из шести элементов имеет максимальный
индекс 5. Чтобы запутать вас окончательно, следует сказать, что при
объявления массива из шести элементов, в квадратных скобках следует
указывать 6. Для доступа к элементу максимальным числом в квадрат-
ных скобках будет 5. Однако чтобы достигнуть полного понимания этой
конструкции, сначала нужно ее прочувствовать.

int lotto[6];
lotto[0] = 1; // первый элемент!
...
lotto[5] = 3; // шестой элемент, ok!
lotto[6] = 4; // седьмой элемент: ошибка!!!
Листинг 3.3. Переход границы

Такой переход за границу существующего массива не будет ни от-

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

119
Глава 3

Язык C++ передает им ответственность за это и предлагает в качестве

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

Уже в начале главы цикл for был использован для работы с масси-
вом. Цикл for и массивы «принадлежат» друг другу. Чтобы в таком цикле
перебрать все элементы массива, нужно контролировать только некото-
рые моменты. Прежде всего, переменная индекса должна начинаться с 0.
Условие следует формулировать как «значение индексной переменной
меньше размера массива». В заключительной команде значение индекс-
ной переменной просто увеличивается. Особенно четко это видно, если
размер массива задан некоторой константой, в данном случае MAXLOTTO.

const int MAXLOTTO=6;

int lotto[MAXLOTTO];
for (int i=0; i<MAXLOTTO; i++)
{
lotto[i] = ...
}
Листинг 3.4. Цикл for и массив

Массив также можно инициализировать. При этом для каждого его

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

const int MAXLOTTO=6;

int lotto[MAXLOTTO] = { 12, 7, 45, 2, 21, 9 };
Листинг 3.5. Инициализация массива

Здесь нужно указать, что такая запись функционирует только для

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

Особый случай инициализации массива со значением null. В языке

C++ любую структуру данных можно инициализировать со значением
null, если при инициализации указать {0}. При этом выделяемое коли-
чество памяти под такую переменную будет установлено в 0.

120
 Типы данных и структур

const int MAXLOTTO=6;

int lotto[MAXLOTTO] = {0};
Листинг 3.6. Инициализация со значением null

Чтобы установить размер памяти, занимаемой массивом, можно так-

же использовать псевдофункцию sizeof(). В следующем примере по-
казано, как получить размер массива, отдельного его элемента и общее
количество элементов.

#include <iostream>
using namespace std;
int main()
{
double c[13];
cout << "Количество памяти, занимаемое массивом double
c[13]: ";
cout << sizeof(c) << endl;
cout << " Количество памяти, занимаемое элементом: ";
cout << sizeof(c[0]) << endl;
cout << "Количество элементов: ";
cout << sizeof(c) / sizeof(c[0]) << endl;
}
Листинг 3.7. Функция sizeof() в массиве (sizeof.cpp)

3.1.1. Сортировка методом «пузырька»

Однотипные данные больших объемов хотелось бы выводить на

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

Чтобы представить, как компьютер выполняет сортировку, разложи-

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

121
Глава 3

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

Один из практикуемых методов — просмотреть все карты и сравнить

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

4 9 3 2

4 9

3 9

4 3 2 9

3 4

3 2 4 9

2 3 4 9
Рис. 3.2. Сортировка методом «пузырька»

Видно, что числа поменяли свое расположение уже после первого

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

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

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

122
 Типы данных и структур

цикл всегда проходит с левого края до границы внешнего цикла, то есть

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

for (i=MAX-1; i>0; i--)

{
for (j=0; j<i; j++)
{
...
}
}
Листинг 3.8. Цикл для сортировки методом «пузырька»

Вместо того чтобы изобретать решение в виде листинга, наверное, раз-

умнее использовать диаграмму Насси — Шнейдермана. Во внутреннем ци-
кле каждый элемент будет сравниваться с его соседом справа. Если элемент
слева больше элемента справа, они должны поменяться местами (рис. 3.3).

Рис. 3.3. Структурная диаграмма сортировки методом «пузырька»

Теперь можно структурную диаграмму описать на языке C++. Следу-

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

#include <iostream>
using namespace std;
#include <stdlib.h>
const int MAX=5;

123
Глава 3

int main()
{
int field[MAX], dop, help;
int i, j, k;
srand(56); // Генератор случайных чисел готов
for (i=0; i<MAX; i++)
{ // Заполнение и вывод массива
field[i] = rand() % 100 + 1;
cout << field[i] << " ";
}
cout << endl;
for(i=MAX-1; i>0; i--)
{
for (j=0; j<i; j++)
{
cout << "(" << j << "-" << j+1 << "): " ;
if (field[j]>field[j+1])
{ // Требуется перестановка
help = field[j];
field[j] = field[j+1];
field[j+1] = help;
}
cout << field[j] << " - " << field[j+1] << " ";
}
// Здесь выводится массив
cout << endl << MAX-i << "-й проход цикла завершен: ";
for (k=0; k<MAX; k++)
{
cout << field[k] << " ";
}
cout << endl;
}
}
Листинг 3.9. Сортировка методом «пузырька» (bubble.cpp)

124
 Типы данных и структур

Следующие строки демонстрируют пробный запуск программы.

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

80 91 14 78 17
(0-1): 80 - 91 (1-2): 14 - 91 (2-3): 78 - 91 (3-4): 17 - 91
1-й проход цикла завершен: 80 14 78 17 91
(0-1): 14 - 80 (1-2): 78 - 80 (2-3): 17 - 80
2-й проход цикла завершен: 14 78 17 80 91
(0-1): 14 - 78 (1-2): 17 - 78
3-й проход цикла завершен: 14 17 78 80 91
(0-1): 14 - 17
4-й проход цикла завершен: 14 17 78 80 91

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

3.1.2. Присваивание в массивах

Массив принадлежит к немногочисленным структурам данных, ко-

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

В некоторых компиляторах, таких как GNU Compiler, все же воз-

можно копировать массивы посредством присваивания. Вообще-то, это

1
Массив так же не может быть возвращаемым значением для функции (см. стр. 128).

125
Глава 3

работает только для массивов одинакового размера и типа. При таком

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

int source[MAX];
int target[MAX];
target = source; // нестандартно!

Другие компиляторы, такие как Visual C++ корпорации Microsoft,

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

int source[MAX];
int target[MAX];
int i;
for (i=0; i<MAX; i++)
{
target[i] = source[i];
}

Если нужно быстро скопировать один массив в другой, который

имеет такой же тип и размер, можно использовать функцию memcpy().
Функция копирует побайтно выбранную область памяти.

Первый параметр функции — цель, второй — источник, третий —

размер. Преимущество функции memcpy() заключается в высокой ско-
рости. Недостаток — в том, что компилятор не контролирует, соответ-
ствуют ли тип и размер источника цели.

Для примера показан вызов функции:

#include <string.h>
int source[MAX];
int target[MAX];
memcpy(target, source, sizeof(source));

Поскольку такой вариант чреват ошибками, лучше использовать его

только в случае, когда высокую скорость требуется обеспечить любой
ценой. Чтобы использовать функцию memcpy(), нужно подключить
файл string.h.

126
 Типы данных и структур

3.1.3. Символьные последовательности языка C

Важная область применения массивов — последовательности сим-

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

Но у нее есть свои недостатки. Так, строке не может быть присвоено

другое кодовое значение, поскольку массив не является L- значением.
Поэтому в стандартную библиотеку языка C++ был добавлен новый тип
string. Мы рассмотрим его подробнее на стр. 354.

Последовательности символов, базирующиеся на массиве типа

char, сокращенно называются С-строками. Они иногда используются
и в языке C++. Так константные последовательности символов опреде-
ляются как С-строки. Множество интерфейсов реализованы в виде мас-
сива типа char. Новый тип string предлагает возможность объединить
обе формы представления символьных последовательностей, которые
также могут существовать по отдельности. Тип string не заменяет
классическую С-строку, а дополняет ее. Но все же в новых программах
рациональнее использовать тип string.

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

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

Чтобы в одном массиве отделять друг от друга символьные строки,

как самые короткие, так и самые длинные, конец строки должен быть
маркирован. Разделение осуществляется с помощью 0. Здесь речь идет
не о символе '0', а о нулевом бите, который представлен в виде '\0' или
как числовая константа 0. Каждая строковая константа всегда включа-
ет в себя этот заключающий символ. Поэтому пустая строка (вида "")
на самом деле не пустая. Она содержит в себе один элемент, то есть 0.
В примере показаны объявление и инициализация С-строки:

char last_name[6] = "Kai";

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

трех элементах хранятся символы 'K', 'a' и 'i'. В четвертом элементе с ин-
дексом 3 хранится 0. Состояние остальных двух элементов неопределен-

127
Глава 3

но. Там могут находиться еще старые данные, обозначенные на рис. 3.4
символами 'z' и 'M'.

’K’ ’a’ ’i’ 0 ’z’ ’M’

[0] [1] [2] [3] [4] [5]

Рис. 3.4. Заполненный массив типа char

Размер массива можно также указать при инициализации. В данном

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

char last_name[] = "Kai";

Для работы с С-строками существует большое количество различ-

ных вспомогательных функций (см. стр. 369), которые так или иначе
довольно часто используются. В новых программах, тем не менее, преи-
мущественно используется тип string (см. стр. 355).

3.1.4. Пример: определение числового значения

введенного символа

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

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

Следующий пример позволяет считывать символьную последова-

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

128
 Типы данных и структур

#include <iostream>
using namespace std;
const int MAX=256;
int main()
{
char input[MAX];
int i = 0;
long value = 0;
cin.getline(input, MAX);
while (input[i]>='0' && input[i]<='9')
{
value *= 10;
value += input[i] — '0';
i++;
}
cout << value << endl;
}
Листинг 3.10. Считывание целых значений

Рассмотрим по отдельности самые важные строки программы:

cin.getline(input, MAX);

Вызов функции cin.getline(input, MAX) позволяет пользова-

телю начать ввод данных и записывает введенную им строку в массив
input типа char. Ввод ограничен символом MAX.

while (input[i]>='0' && input[i]<='9')

Цикл while просматривает всю введенную строку, пока текущий

символ находится в указанных пределах. Это устанавливается услови-
ем. Программа покинет цикл, как только встретит первый символ, не
являющийся цифрой. То же условие предохраняет от выхода за преде-
лы символьной последовательности, потому как нулевой завершающий
символ также лежит в указанной условием области.
value *= 10;
value += input[i] — '0';

129
Глава 3

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

этим важно инициализировать эту переменную со значением 0. В цикле
при каждом его повторении предыдущее значение переменной умножает-
ся на 10 и таким образом происходит сдвиг позиции влево. Новая цифра
должна лежать в диапазоне между 0 и 9. Посредством вычитания символа
'0' достигается, к примеру, то, что из символа '2' можно получить число 2.
Это значение затем будет добавлено к уже имеющемуся значению перемен-
ной. Рассмотрим работу программы на примере числа «735» (табл. 3.1).

Таблица 3.1. Пошаговая таблица

i value input[i] После выполнения команды
0 0 '7' value *= 10;
0 7 '7' value += input[i] — '0';
1 7 '3' i++;
1 70 '3' value *= 10;
1 73 '3' value += input[i] — '0';
2 73 '5' i++;
2 730 '5' value *= 10;
2 735 '5' value += input[i] — '0';
3 735 '\0' i++;

Базируясь на описанном выше алгоритме, очень просто считывать

также числа с плавающей запятой, в которых дробная часть отделена
символом запятой. Обычно язык C++ использует англо-американскую
систему представления таких чисел и отделяет дробную часть с по-
мощью точки. При проходе цикла while для позиций перед запятой
проверяется, является ли следующий символ запятой или нет. Затем
выполняется почти такой же цикл. В переменной NK устанавливается
десятичная экспонента, на которую будет разделена следующая цифра
до того, как она будет добавлена к значению переменной value.

#include <iostream>
using namespace std;
const int MAX=256;
int main()
{
char input[MAX];
int i=0;
double value = 0;

130
 Типы данных и структур

cin.getline(input, MAX);
while (input[i]>='0' && input[i]<='9')
{
value *= 10;
value += input[i] — '0';
i++;
}
if (input[i]==',')
{
double NK = 1;
i++;
while (input[i]>= '0' && input[i]<= '9')
{
NK *= 10;
value += (input[i]- '0')/NK;
i++;
}
}
cout << input << value << endl;
}
Листинг 3.11. Считывание чисел с запятой (number_input.cpp)

Упражнение
• Напишите программу, которая позволяла бы вводить дроби и кон-
вертировала их в переменные типа long. Числитель и знаменатель
должны разделяться слешем. При вводе 3/4 переменная должна со-
держать 0.75. Пример приведен на стр. 502.

3.1.5. Многомерный массив

Язык C++ позволяет организовывать массивы различных размерно-

стей. При объявлении многомерного массива для каждой размерности
используются отдельные квадратные скобки. Подобная конструкция
представляет собой массив массивов.
double matrix[MAXCOLUMN][MAXROW];

131
Глава 3

Здесь объявляется массив, количество строк в котором равно MAXROW,

а столбцов — MAXCOLUMN. Занимаемая таким массивом память определя-
ется следующим образом:
sizeof(double)* MAXROW * MAXCOLUMN
Доступ к элементам двумерного массива осуществляется также с по-
мощью двух пар квадратных скобок. Если необходимо использовать
элемент из четвертого столбца и третьей строки, доступ к нему будет
получен через определение matrix[3][2];

3.1.6. Пример: игра «Бермуда»

В качестве примеров двумерных массивов можно рассматривать

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

В игровом поле размерностью девять на семь клеток спрятаны четы-

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

Первый шаг состоит в том, чтобы определить игровое поле. В дву-

мерном массиве будут храниться результаты попыток пользователя
отгадать, где спрятан корабль. Для хранения этой информации луч-
ше всего подходит тип char. Следующий листинг демонстрирует, как
поле сначала инициализируется с точками. Затем программа переходит
в цикл, где создается игровое поле и пользователь может вводить коор-
динаты. Для этого вводится номер строки, потом следует буква столбца,
например 2C. На данном этапе разработки поля, указанные во введен-
ных координатах, будут сначала маркированы знаком х в игровом поле.
132
 Типы данных и структур

На этом основании программа выдаст сообщение, были ли введены дей-

ствительно существующие координаты.

#include <iostream>
using namespace std;
const int X=9;
const int Y=7;
int main()
{
char game_space[X][Y];
int x, y;
char cx, cy;
for (x=0; x<X; x++)
{
for (y=0; y<Y; y++)
{
game_space[x][y] = '.';
}
}
// Создание игрового поля и ввод координат
bool loop_end=false;
int xin, yin;
do
{
cout << " 1 2 3 4 5 6 7 8 9" << endl;
for (y=0; y<Y; y++)
{
cout << (char)('A'+y) << " ";
for (x=0; x<X; x++)
{
cout << " " << game_space[x][y];
}
cout << endl;
}

133
Глава 3

cin >> cx >> cy;

xin = cx — '1';
yin = cy — 'A';
if (xin>=0 && xin<9 && yin>=0 && yin<7)
{
game_space[xin][yin] = 'x';
}
else
{
loop_end = true;
}
}
while (!loop_end);
}
Листинг 3.12. Игровое поле «Бермуда» (bermuda1.cpp)

После запуска программы на экран будет выведено игровое поле с ко-

ординатами. Программа останавливается, ожидая ввода данных. После
ввода 2С — возврата в программу — на экране появляется символ х в со-
ответствии с введенными координатами. После ввода значения 6F сим-
вол x будет расположен в двух местах — с координатами 2С и 6F. Если
ввести координаты, которых нет в поле, программа завершит работу.

1 2 3 4 5 6 7 8 9
A . . . . . . . . .
B . . . . . . . . .
C . . . . . . . . .
D . . . . . . . . .
E . . . . . . . . .
F . . . . . . . . .
G . . . . . . . . .
2C
1 2 3 4 5 6 7 8 9
A . . . . . . . . .
B . . . . . . . . .

134
 Типы данных и структур

C . x . . . . . . .
D . . . . . . . . .
E . . . . . . . . .
F . . . . . . . . .
G . . . . . . . . .
6F
1 2 3 4 5 6 7 8 9
A . . . . . . . . .
B . . . . . . . . .
C . x . . . . . . .
D . . . . . . . . .
E . . . . . . . . .
F . . . . . x . . .
G . . . . . . . . .
Xx

3.2. Указатель и адрес

Указатель — это особенная переменная. Ее содержимое в целом не-
существенно. Гораздо интереснее то, что она может указывать на дру-
гую переменную. Таким образом, посредством переменной-указателя
рассматривается не сама переменная, а содержимое другой. Эту косвен-
ность поначалу сложно понять, и позднее она еще неоднократно станет
поводом для путаницы.

Представьте, что каждый день вы ездите на работу на машине и пар-

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

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

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

135
Глава 3

магнитной карте, вам неизвестно. И в целом вас это не интересует, пока вы

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

 Указатель — это переменная, которая хранит адрес в памяти, по

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

136
 Типы данных и структур

char *char_pointer;

Переменная char_pointer — это указатель на некоторую перемен-

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

Особая позиция в памяти называется адресом. Позиции памяти

в компьютере пронумерованы, за адресом скрыто некоторое число. Что-
бы выяснить адрес переменной, используется символ &. Этот оператор
в английском языке носит имя «амперсанд» и в программировании ча-
сто так и называется. В следующем примере показано, как указателю
char_pointer присвоить адрес переменной letter.

char letter = 'A';

char_pointer = &letter;

Как уже было сказано, нас интересует содержимое не указателя,

а переменной, на которую он указывает. После того, как указателю был
присвоен адрес переменной, можно получить к ней доступ, если устано-
вить перед именем указателя символ *.
cout << *char_pointer;

Эта команда выведет на экран символ A, который хранится в пере-

менной letter. Также можно присвоить переменной letter новое зна-
чение, используя указатель.
*char_pointer = 'B';
cout << letter;

С помощью символа * перед именем указателя четко обозначается,

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

На рис. 3.5 показана ситуация после присваивания символа В через

указатель char_pointer. Вверху справа находится переменная letter.
Здесь мы исходим из того, что она располагается в памяти по адресу
17543. Именно этот номер содержит переменная char_pointer, которая
в свою очередь хранится по адресу 23164. Соотношения размеров так-
же подходят. Пока переменная типа char занимает один бит, указатель,
обычно, занимает на компьютере от четырех до восьми байт.

137
Глава 3

Рис. 3.5. Указатель

Можно с уверенностью представить, что с помощью указателя край-

не удобно получать доступ к переменным. И, конечно же, указатель при-
меняется очень часто. Здесь перечислены примеры типичного исполь-
зования указателей, которые мы рассмотрим в книге немного позже.
1. Можно написать часть программы, которая будет получать доступ
к переменной через указатель. Если присвоить указателю другой
адрес, та же часть программы станет работать уже с другой перемен-
ной. Далее в книге это продемонстрировано вместе с параметрами
функции.
2. В процессе работы программы может потребоваться выделить но-
вую часть памяти. Как будет показано позже, для этого использует-
ся команда new. Чтобы программа могла получить доступ к новому
участку памяти, new предоставляет указатель.
3. С помощью указателей можно построить сложные конструкции дан-
ных. Для этого из данных и указателей строятся объединения пере-
менных (см. стр. 146). Если указатель такого объединения ссылается
на следующее объединение, можно построить цепь в виде линейного
списка. Если в объединении данных интегрировать несколько указа-
телей, можно создать конструкцию, подобную дереву.

Для надежности указатель, у которого еще нет конкретного целевого

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

char *char_pointer; // char_pointer объявлен

char_pointer=0; // защищен посредством обнуления адреса

138
 Типы данных и структур

Если нужно переменную-указатель инициализировать со значением

0, можно просто написать =0 как для переменной целого типа. В про-
граммировании на языке C в связи с этим часто встречается константа
NULL. Здесь речь идет о 0, который явным образом указывает на исполь-
зование его для указателя. В языке C++ константа NULL и не требуется,
и не имеет смысла.
char *char_pointer=0;

3.2.1. Косвенный доступ

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

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

char *char_pointer; // Объявление указателя

char_pointer = 0; // Инициализация со значением 0
char letter = 'A'; // Переменная с содержимым
char_pointer = &letter; // Получение адреса переменной
*char_pointer = 'B'; // Переменная поменяла значение 'B'

Символ * идентичен символу умножения. Компилятор, тем не ме-

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

int main()
{
int *int_pointer = 0;
int intVar = 5;
int_pointer = &intVar;
// указатель получает адрес переменной intVar
// теперь int_pointer указывает на intVar

139
Глава 3

*int_pointer = 1;
// переменной, на которую указывает int_pointer, будет
// присвоено значение 1. При этом только содержимое
// intVar равно 1.
intVar = *int_pointer + 1;
// значение intVar будет изменено на сумму 1 и значение, на
// которое указывает int_pointer. Но только сама переменная.
// Поэтому значение intVar в итоге будет равно 2.
}

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

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

3.2.2. Массивы и указатели

В языках C и C++ указатели и массивы удивительным образом

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

int values [4];

int *values_pointer = 0;
values_pointer = values;

Особенно интересно то, что в процессе присваивания указателю

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

140
 Типы данных и структур

values_pointer = values;
values_pointer[3] = 4;

Эта ситуация представлена на рис. 3.6. Не без причины переменная-

массив values представлена в качестве указателя.

Рис. 3.6. Указатель совместим с массивом

Следующие конструкции, вероятно, вызовут у вас холодный пот; од-

нако для компилятора они совсем не покажутся странными. Тут ситуа-
ция сначала выглядит аналогично:

int values[4];
int *values_pointer = 0;
values_pointer = values;
values_pointer[3] = 5;
values_pointer = & values[2];
values_pointer[1] = 3; // записывается в values[3]!
Листинг 3.13. Массив и указатель

Строка, в которой указателю присваивается адрес третьего элемента

массива, особенно оригинальна:
values_pointer = &values[2];

Здесь values[2] не что иное, как переменная целого типа, и, разуме-

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

141
Глава 3

Рис. 3.7. Массив со сдвинутым указателем

Из-за сдвига значение элемента values_pointer[0] будет идентич-

но значению элемента values[2]. В результате, values_pointer[1]
будет последним элементом массива values. Если бы при этом обраба-
тывался элемент values_pointer[2], был бы получен доступ к памяти,
которая находится вне резервируемой массивом области. Результат при
этом сложно предсказать.

 Основное отличие: при объявлении массива память резервирует-

ся в зависимости от количества элементов, а при объявлении ука-
зателя — только для хранения переменной-указателя.

3.2.3. Арифметика для указателей

Указатель можно инкрементировать и декрементировать. При этом

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

Если необходимо присвоить элементам массива 0, можно сделать

это с помощью оператора индекса.

int values[MAX];
for(i=0; i<MAX; i++)
{
values[i] = 0;
}

Альтернативой может служить использование указателя и просмотр

массива с его помощью:

142
 Типы данных и структур

int values[MAX];
int *pointer = values;
for(i=0; i<MAX; i++)
{
*pointer = 0;
pointer++;
}

Из этих двух циклов быстрее работает второй. Это совершенно ясно,

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

Рис. 3.8. Блуждающий указатель

Символьные последовательности очень элегантно обрабатываются

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

char source[MAX];
for (char *p = source; *p; p++)
{
cout << *p ;
}
Листинг 3.14. Цикл for для строк

143
Глава 3

В начальной команде объявляется указатель р и инициализируется

вместе с массивом source. Следующая команда — условие, по которо-
му выполняется цикл. То, что оно такое короткое, несколько смущает.
Условие *р содержит символ, на который указатель р ссылается в на-
стоящий момент. В данном случае это не булево значение, но не трудно
вспомнить, что язык C++ интерпретирует нулевое значение в качестве
ложного, а все остальные — как истинные. Здесь это означает, что цикл
будет продолжаться, пока не наткнется на завершающий строку символ
0. Только тогда выражение *р примет значение ложь. Заключительная
команда в итоге заботится о том, чтобы после каждого прохода цикла
переменная р указывала на следующий символ строки.

Сложение и вычитание

Указатель можно не только инкрементировать и декрементировать,

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

*(pointer+2) = 4;
pointer[2] = 4;
Листинг 3.15. Однозначные команды

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

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

3.2.4. Константный указатель

Ключевое слово const вам уже знакомо по объявлению констант.

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

const int *const_target = &var_target;

Этот указатель объявлен так, что ключевое слово const находится

прямо перед типом цели. Через него целевую переменную нельзя изме-

144
 Типы данных и структур

нить. Указатель способен при этом инкрементироваться. Можно таким

образом просматривать и выводить содержимое массива.

int * const const_pointer = &var_target;

Указатель const_pointer не может быть изменен относительно его

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

const int * const Constant = &var_target;

Для указателя Constant нельзя менять ни значение переменной, ни

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

3.2.5. Анонимный указатель

Указатель всегда имеет одинаковый размер, не важно, на данные ка-

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

На какой тип ссылается указатель, с точки зрения компьютера со-

вершенно безразлично. Компилятор, правда, следит за тем, чтобы ука-
затель на переменную типа char не стал внезапно использоваться так,
словно он указывает на переменную типа float.

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

зателя, цель которого еще неизвестна. При этом указатель объявляется
с типом void.

void *ptr;

Переменных типа void не существует, так что объявление перемен-

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

145
Глава 3

Как уже было сказано, каждому void-указателю можно присвоить

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

void *voidPtr;
int *intPtr;
voidPtr = intPtr; // работает без проблем
intPtr = (int *)voidPtr; // необходимы скобки

3.3. Объединение переменных: struct

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

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

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

Еще в языке C для подобных целей использовались структуры, ко-

торые объединяли в себе несколько переменных. Ключевое слово для
определения такой составной переменной звучит как struct. За ключе-
вым словом следует имя нового типа. В следующих фигурных скобках

146
 Типы данных и структур

перечисляются составные части новой структуры. Такое определение не

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

Для моделирования автомобиля создается новый тип, назовем его

TAutoTyp, который состоит из нескольких элементов.

struct TAutoTyp // Объявляем новый тип

{
char brand[MaxMarka];
char model[MaxModel];
long km;
int kW;
float price;
}; // Здесь легко забыть про точку с запятой!
Листинг 3.16. Структура для автомобиля

Ключевое слово struct начинает объявление типа. Затем следует

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

Новый тип TAutoTyp создан. Он может так же широко использовать-

ся, как и тип int. Можно, например, создать новую переменную такого
типа, или новый массив, или объявить указатель с таким типом.
TAutoTyp collection; // Объявлена новая переменная
TAutoTyp auto_parking[100]; // Массив автомобилей
TAutoTyp *parking_map; // Указатель на автомобиль

Переменная collection содержит только ту информацию, которая

определена в структуре TAutoTyp при ее создании. Чтобы добраться до
отдельных частей структуры, после ее имени указывается точка и затем
располагается имя требуемой составляющей части.
// Для доступа к отдельным элементам структуры
collection.km = 128000;
collection.kW = 25;
collection.price = 25000.00;

147
Глава 3

Если необходимо получить доступ к элементам структуры через

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

TAutoTyp *parking_map = 0; // Никакого адреса в памяти

parking_map = &collection; // Указывает на структуру collection
(*parking_map).price = 12500; // Элемент price в collection
Листинг 3.17. Указатель на структуру

Хоть это решение и может казаться логичным, но оно ни элегантно,

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

parking_map->price = 12500;

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

с левой стороны присваивания. Одной структуре можно присвоить дру-
гую, если она такого же типа. При этом из переменной-источника в но-
вую переменную будет бит за битом скопирована вся информация.
TAutoTyp my_next_auto, my_dream_auto;
my_next_auto = my_dream_auto;

Несмотря на то, что совершенно очевидно, что обе эти переменные

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

struct // Здесь не указывается тип

{
char brand[MaxMark];
char model[MaxModel];
long km;
int kW;

148
 Типы данных и структур

float price;
} my_first_auto, my_dream_auto;
Листинг 3.18. Структура для автомобиля

Здесь переменные my_first_auto и my_dream_auto объявляются

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

Структуры также можно инициализировать. Для этого, как и при

работе с массивами, используются фигурные скобки. Здесь значения
также отделяются запятой.
TAutoTyp JB = {"Aston Martin", "DB5", 12000, 90, 12.95};
TAutoTyp GWB = {0};

Структуры использовались еще в языке C и были там единственной

возможностью объединения данных.

В языке C++ для этой цели обычно используются классы (см. стр. 213
и далее), которые могут значительно больше, чем С-структуры. Однако
по причине совместимости ключевое слово struct используется в языке
C++ и, вероятно, будет и далее перениматься. Тем не менее, структура
в языке C++ позволяет значительно больше, чем в языке C. В целом она
соответствует классу, в котором все элементы доступны извне (рис. 3.9).

Рис. 3.9. Граф синтаксиса структуры

Граф VarDef можно найти на стр. 46. В этой позиции объявляются

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

149
Глава 3

3.3.1. Пример: игра «Бермуда»

После моделирования игрового поля (см. стр. 131) следует разме-

стить на нем корабли. Каждый корабль имеет свои координаты x и y.
В дальнейшем каждый корабль должен быть маркирован, если он был
найден. Поэтому потребуется еще одна переменная типа bool, назовем
ее detected. Чтобы объединить корабли в этой форме, будет использо-
вана структура. По правилам игры всего должно существовать четыре
корабля, поэтому нужно использовать массив структур.

const int max_ship=4;

struct tShip
{
int x;
int y;
bool detected;
};
tShip Ship[max_ship];
Листинг 3.19. Объявление кораблей

Следующим шагом следует спрятать корабли. Естественно, как

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

// Бермуда: добавление структуры

#include <iostream>
using namespace std;
#include <stdlib.h>
const int X=9; // Ширина игрового поля по горизонтали
const int Y=7; // Высота игрового поля по вертикали
const int max_ship=4; // Количество кораблей
struct tShip
{ // Копия корабля
int x; // Позиция по горизонтали
150
 Типы данных и структур

int y; // Позиция по вертикали

bool detected;
};
tShip Ship[max_ship]; // Наш флот
int main()
{
int i, j; // Переменные счета
bool new_number; // Позиция обнаружена?
srand(0);
for(i=0; i<max_ship; i++) // Все корабли
{
Ship[i].detected = false;
// Определение позиции
do
{
// Выбрать случайную позицию
Ship[i].x = rand() % X;
Ship[i].y = rand() % Y;
new_number = true;
// Проверить, не занимает ли данную позицию
// один из предыдущих кораблей
for (j=0; j<i; j++)
{
if (Ship[j].x== Ship[i].x
&& Ship[j].y== Ship[i].y)
{
// Уже один расположен!
new_number = false;
}
}
// теперь найдена новая позиция
} while (!new_number);
}
// для контроля выведем все корабли
for (i=0; i<max_ship; i++)

151
Глава 3

{
cout << Ship[i].x << "," << Ship[i].y << " ";
}
cout << endl;
}
Листинг 3.20. Прячем корабли (bermuda2.cpp)

Теперь созданы структуры данных для программы игры «Бермуда».

Следующим шагом все части обретут функциональность.

3.4. Динамические структуры

Обычно переменные, которые будут использоваться в программе,
определяются при ее создании. Для этого уже перед началом написания
кода необходимо определить, какие данные требуются. Предположим,
что в программе необходимо заполнить лист покупок. Можно использо-
вать для этого массив, в котором будут храниться записи о необходимых
покупках. Но сколько записей может быть максимально? Неважно, ка-
кое значение вы выберете: оно будет слишком маленьким, если вы наме-
рены закупить продукты на полгода вперед, и слишком большим, если
вам нужно просто купить яйца и бекон для импровизированного обеда.
Для таких случаев язык C++ предлагает возможность выделять память
по мере выполнения программы, организуя доступ к ней указателем.

3.4.1. Выделение и освобождение памяти

Команда new запрашивает новый участок памяти. Чтобы можно

было к ней обратиться, она возвращает указатель. Чтобы команда new
«знала», сколько необходимо запросить памяти, за ней следует желае-
мый тип данных.

float *float_pointer = new float;

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

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

152
 Типы данных и структур

Только что выделенная память может быть сразу же инициализирова-

на. Для этого в скобках после типа указывается значение инициализации.
int *int_pointer = new int(2); // Инициализация
Переменной, на которую указывает int_pointer, сразу после созда-
ния будет присвоено значение 2.
Выделенная память в определенный момент должна быть освобож-
дена. Особенно это важно, когда через указатель выделяется следующий
участок памяти, прежде чем предыдущий был освобожден, тогда остат-
ки блуждают по основной памяти, и к ним уже нельзя получить никако-
го доступа. Это можно сравнить с автомобилем, который теряет масло.
В подобных случаях говорят о так называемой «утечке памяти». Как
и при утечке масла, утечка памяти в небольших количествах не трагична
и проявляется, вероятно, минимальным снижением производительно-
сти. Опасна она только в том случае, когда оставшиеся участки памяти
превышают определенный уровень. Тогда возможна критическая потеря
производительности или сбой программы. По этой причине необходимо
следить за тем, чтобы каждый занятый участок памяти был освобожден
после его использования. Для этого служит команда delete. За ней сле-
дует указатель, который ссылается на данный участок памяти:
delete float_pointer;
Указатель не должен быть тем, с помощью которого запрашивалась
память. Он должен только лишь указывать на верный участок памяти
и принадлежать такому же типу. После освобождения памяти коман-
дой delete рекомендуется присвоить переменной-указателю значение
0. Это предотвратит ситуацию, когда в другом месте по ошибке будет
освобожден тот же участок памяти. Команда delete распознает, когда
значение указателя равно 0 и не пытается освободить память по этому
адресу. Почти так же важен факт, что дальнейшее использование этого
указателя для считывания или записи участка памяти сразу приведет
к ошибке, которую легко будет обнаружить. После освобождения памя-
ти указатель ссылается в конце концов только на тот участок, который
больше недействителен. Возможно, что в дальнейшем эту память снова
потребуется выделить. Если значение указателя на нее не будет уста-
новлено равным 0, и программа станет и дальше работать с этим недей-
ствительным указателем, тогда начнет использоваться участок памяти,
который, вероятно, относиться к другой части программы. При этом
программа продолжит работать словно в нормальном режиме, и данная
ошибка никогда не будет обнаружена.

153
Глава 3

3.4.2. Создание массивов во время выполнения

программы

С помощью команды new можно также создать динамический мас-

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

Для создания массива во время выполнения программы, для опера-

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

Если с помощью команды new был создан массив, этот участок памя-
ти освобождается специальной для массива записью команды delete[].
Хотя при нормальном вызове команды delete большинство компиля-
торов не найдут изъянов, результат будет непредсказуем.

int *Lotto = 0; // Указатель объявлен и инициализирован

Lotto = new int [6]; // Запрошен участок памяти под массив
// из 6 элементов
for (i=0; i<6; i++) // Просмотр массива
{
Lotto[i] = rand() % 49 + 1; // Запись чисел лото
}
delete[] Lotto; // Освобождение памяти
Lotto = 0; // Предохранение указателя
Листинг 3.21. Запрос создания массива во время работы программы

3.4.3. Связанные списки

Если требуется объединить несколько элементов одного типа, то

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

154
 Типы данных и структур

Сколько элементов может находиться в списке, ограничено только сво-

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

База связанного списка — структура, которая содержит, с одной сторо-

ны, данные, с другой стороны — указатель на следующий элемент списка.

struct TList
{
int data;
TList *next;
};

Есть нечто озадачивающее в использовании типа TList при его объ-

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

Рис. 3.10. Связанный список

Переменная anchor — это указатель на тип TList, который образует

базис для доступа программы к связанному списку. Через якорь можно
добраться до первого элемента списка. Там уже содержится указатель
next, ссылающийся на следующий элемент списка. Так программа мо-
жет обрабатывать все элементы, пока указатель next не примет значение
0. Этим обозначается конец списка. Если тот пуст, переменная anchor
должна содержать 0.

Новый элемент списка создается с помощью команды new. При этом

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

155
Глава 3

#include <iostream>
using namespace std;
struct TList
{
int data; // симулирует данные
TList *next; // Связь со следующим элементом
};
TList *anchor = 0; // Начало списка
int main()
{
int content;
TList *knot, *old;
// Заполнение списка числами до тех пор, пока не встретится
//число 0
do
{
cout << "Введите число(0 для завершения ввода)"
<< endl;
cin >> content;
if (content)
{
// Новые элементы списка:
TList *knot = new TList;
knot->data = content; // Запись данных
knot->next = anchor; // Прикрепляем предыдущий //элемент
списка
anchor = knot; // Передаем дальше начальное //значение
}
} while (content);
// Выводим список в обратном порядке
// при этом удаляем выведенные элементы
while (anchor) // Не равен 0! Список не пустой!
{
cout << anchor ->data << endl;

156
 Типы данных и структур

old = anchor; // Перестраховываемся при дальнейшем //удале-

нии
anchor = anchor->next; // Следующий элемент вперед
delete old; // Удаляем выведенный элемент
}
}
Листинг 3.22. Программа демонстрации связанного списка

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

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

3.5. Объединение
Объединение — union — представляет собой особый тип структу-
ры. Его можно описать в качестве связи или-или. В одном объедине-
нии хранится несколько переменных, из которых можно использовать
только одну. То есть обрабатывать можно только один из представлен-
ных в объединении элементов. Объединение занимает столько памяти,
сколько требуется для хранения самого большого из его элементов.

В объединении хранится взаимозаменяемая информация. Так банк

может использовать данные кредитной карты с номером и месяцем,
а когда ее действие прекращается — счет с личным номером и банков-
ским индексом.
union tBank
{
tCredit_card card;
tNumber number;
};

Структура union содержит только непосредственные данные. Она

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

157
Глава 3

прочитаны из переменной number. То, что результат бессмысленный,

может определить только пользователь.

В некоторых программах посредством объединения происходит об-

мен последовательности байтов между разными устройствами. Слово из
16 бит занимает 2 байта. Но последовательность этих байт в различных
машинах отличается. В компьютерах, например, младший байт считыва-
ется первым; в большинстве процессоров структуры RISC — наоборот.

union tTransform
{
struct
{
unsigned char high;
unsigned char low;
} byte;
unsigned short word;
} Transform;
int main()
{
Transform.word = 7656;
cout << (int) Transform.byte.high << endl;
cout << (int) Transform.byte.low << endl;
}
Листинг 3.23. Программа union.cpp

В результате программа выдаст на компьютере с процессором Intel

значения 232 и 29.

Использование объединения может легко привести к непредвиден-

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

3.6. Перечисляющий тип enum

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

158
 Типы данных и структур

После ключевого слова enum следует имя перечисления. В следую-

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

Рис. 3.11. Граф синтаксиса enum

В следующем примере представлено перечисление цветов.

enum color {red, yellow, green, blue};

При дальнейшем выполнении программы переменные можно объя-

вить с типом color и присвоить им элементы перечисления.

color traffic_lights;
…
traffic_lights = red;

Внутри перечисления элементы нумеруются по порядку. Таким об-

разом red будет иметь индекс 0, yellow — индекс 1 и т. д. По этой причи-
не константы перечисления можно присваивать целочисленным пере-
менным.

Если попытаться сделать наоборот — это приведет к выводу компи-

лятором предупреждения.

color traffic_lights;
int i;
…
i = red; // никаких проблем
traffic_lights = 3; // появится предупреждение

Значения по умолчанию можно также задать при объявлении, как

показано в следующем примере:

enum color{red=2, yellow, green=7, blue};

Это приведет к тому, что red будет равен 2, yellow — 3, green — 7,

а blue — 8.
159
Глава 3

3.7. Определение типов

Командой typedef можно присваивать типам имена. Часто такое
употребление используется для сокращения написания длинных назва-
ний типов. Можно типу unsigned char присвоить имя uchar. Это вы-
глядит следующим образом:

typedef unsigned char uchar;

Команда typedef способна также пояснять, как используется тип.

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

typedef uchar byte;

Можно объявить тип с именем order_number, который является не

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

На этапе тестирования допустимо также обозначить какой-нибудь

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

typedef int tData;

Этот тип tData можно использовать, например, в линейном списке

при тестировании. Если модуль функционирует, можно удалить строку
с командой typedef и позже использовать правильный тип tData.
 Глава 4
ФУНКЦИИ
Функции позволяют объединять команды.
Так начинается творческий процесс создания
программного обеспечения, который выходит
за переделы просто технически верного
нанизывания команд одна на другую.

Вы наверняка помните функции из математики. Вызов функции

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

a = sin(alpha);

Здесь sin — имя функции, alpha — параметр, передаваемый в функ-

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

Чтобы написать функцию самостоятельно, следует в одном бло-

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

Одна функция уже встречалась нам ранее — это функция main().

Она вызывается операционной системой для запуска программы. Мож-
но написать множество дополнительных функций и вызывать их из
main(), поскольку внутри одной функции разрешено вызывать другие.

Обычно функция возвращает некоторое значение. Оно с помощью

ключевого слова return после окончания функции передается в про-
161
Глава 4

грамму, вызвавшую эту функцию. Тип возвращаемого значения опреде-

ляется при описании функции. Возвращаемое значение можно присво-
ить переменной.

В качестве первого примера напишем функцию next(). Она после

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

#include <iostream>
using namespace std;
int next_number=0; // В этой переменной хранится состояние
счета
int next()
// изменение глобальной переменной next_number
{
next_number++; // увеличение глобальной переменной
return next_number;
}
int main()
{
int n;
n = next();
cout << n << endl;
next(); // здесь n не изменяется!
cout << n << endl;
n = next();
cout << n << endl;
}
Листинг 4.1. Функция next (next.cpp)

Объявление функции next() начинается с определения типа воз-

вращаемого значения, в данном случае — int. Тип возвращаемого зна-
чения может быть любым. Единственное, чем не может быть возвращае-

162
 Функции

мое значение, — это массивом, поскольку он не является L-значением.

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

Компилятор GNU Compiler выдаст при этом ошибку — тип возвра-

щаемого значения неверный, тогда как компилятор Visual C++ просто
выдаст предупреждение. Если функция не должна возвращать значе-
ние, ее тип определяется ключевым словом void.

За типом возвращаемого значения следует имя функции. Оно под-

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

Регистр букв учитывается. Есть смысл потратить время на поиск

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

За именем функции следуют скобки, в которых могут содержаться

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

В фигурных скобках следует тело функции — блок команд, который

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

На рис. 4.1 представлен граф синтаксиса для объявления функции.

Рис. 4.1. Граф синтаксиса для объявления функции

• Тип возвращаемого значения

Здесь можно использовать любой тип, кроме массива. Функции
без возвращаемого значения определяются ключевым словом void.
В отличие от языка С, в языке C++ тип должен быть указан явно.

163
Глава 4

• Имя функции
Имя начинается с латинской буквы или знака подчеркивания. За-
тем следуют латинские буквы, цифры и знаки подчеркивания в лю-
бом порядке. Имя соответствует графу синтаксиса, показанному на
рис. 1.2 на стр. 33.
• Параметры
Функция может как вообще не иметь параметров, так и иметь лю-
бое их количество, при этом они разделяются запятой1. Определе-
ние параметра соответствует определению переменной. Подробнее
параметры рассмотрены в следующей главе.
• Тело
Это последовательность команд, которые составляют содержимое
функции и выполняются после ее вызова.

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

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

void separator()
{
cout << "-------------------------" << endl;
return;
}
int main()
{

1 Некоторые компиляторы могут ограничивать число возможных параметров. Кро-

ме того, большое количество параметров указывает на плохое построение программы.
2 Void —пустой, лишенный чего-либо (англ.). Прим. ред.

164
 Функции

separator();
cout << "Программа для определения..." << endl;
separator();
}
Листинг 4.2. Простая функция separator()

В функции, которая не возвращает значение, ключевое слово return

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

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

1
От англ. stack — стопка. Прим. ред.

165
Глава 4

в другое. При корректировке функции остаются в выигрыше все части

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

Имеет смысл использовать функции даже в том случае, если они

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

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

Объявление параметров функции аналогично объявлению перемен-

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

Для наглядности функция separator() будет расширена так, чтобы

можно было задать количество символов "-" в разделяющей линии.

void separator(int number)

{
int i;
for (i=0; i<number; i++)
{
cout << "-";
}
cout << endl;
}
...
int main()

166
 Функции

{
int width = 45;
separator(width);
cout << "Программа для определения..." << endl;
separator(45);
}
Листинг 4.3. Функция separator() с параметром

Параметр number с точки зрения функции — самая обычная локаль-

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

Программист не замечает того, что происходит с переменными вну-

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

Передача данных между программой и функцией всегда должна

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

Параметр передается в функцию в качестве значения. То есть содер-

жимое переменных, которые передаются программой в функцию, нельзя
изменить в ее теле. В примере значение переменой number изменялось
бы в функции separator(),и это было бы заметно. Значение 45, с кото-
рым вызывалась функция, не изменится. Также не изменится перемен-
ная width, которая передавалась в функцию при первом вызове.

 Переменные параметров являются локальными переменными

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

167
Глава 4

Параметры копируются в стек перед адресом возврата. Так можно

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

На рис. 4.2 повторно представлен граф с рис. 4.1. На рис. 4.3 он будет
дополнен параметрами функции.

Рис. 4.2. Граф синтаксиса функции

Рис. 4.3. Граф синтаксиса параметров

Удивительно, что при объявлении параметров можно написать тип

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

Функция вызывается с помощью ее имени. Программа, вызывающая

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

168
 Функции

Рис. 4.4. Интерфейс функции

4.1.1. Прототипы

Если вызов функции располагается в коде программы до ее непосред-

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

void separator(int sights_number);

int main()
{
int width = 45;
separator(45);
cout << " Программа для определения..." << endl;
separator(width);
}
void separator(int number)
{
...
}
Листинг 4.4. Прототип

169
Глава 4

В прототипах можно опустить имена переменных или, как показано

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

4.1.2. Указатель в качестве параметра

При вызове функции передаваемые параметры копируются в их

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

void increment(int *target)

{
*target += 1;
}
int main()
{
int my_value = 5;
increment(&my_value); // после этого my_value равно 6
}
Листинг 4.5. Изменяющийся параметр

После вызова функции increment() содержимое переменной

my_value будет равно 6. При вызове с помощью символа амперсанда

170
 Функции

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

Параметром является указатель.

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

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

Рис. 4.5. Указатель в качестве параметра

График демонстрирует, как программа обслуживает параметр target

с помощью адреса переменной my_value, и как функция использует
переданный указатель *target, чтобы получить доступ к переменной
my_value.

Константный указатель

Вместе с возможностью изменять внешние переменные использо-

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

171
Глава 4

было показано, как можно двумя способами объявить переменные ука-

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

const int *const_target;

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

int * const const_pointer;

Если ключевое слово const стоит перед именем указателя, это озна-
чает, что указатель const_pointer не изменяется. Например, он не мо-
жет быть инкрементирован. При этом разрешено изменение перемен-
ной, на которую он ссылается.

const int * const Constant;

Последний пример сочетает в себе оба варианта и запрещает как ин-

крементирование указателя, так и доступ к переменной.

Использование const имеет обоснованную пользу. Оно говорит про-

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

4.1.3. Массив в качестве параметра

Массив также можно передать в функцию в качестве параметра. Для

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

void fa(int a[5]);

void fb(int a[]);
void fc(int *a);

Параметр функции fa() указывает, что она ожидает массив из пяти

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

172
 Функции

с его копией. Компилятор не проверяет, содержит ли массив действи-

тельно пять элементов.

Параметр fb() ожидает массив. Поскольку в квадратных скобках

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

Параметром fс() является указатель на целочисленную перемен-

ную. Как и ожидается, здесь также передается массив. Все три параме-
тра совместимы между собой.

Несмотря на то, что все три параметра технически работают одинако-

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

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

следует указать ключевое слово const перед определением параметра.
Тогда при каждой попытке изменения данных в массиве компилятор бу-
дет выдавать ошибку.
void fa(const int a[5])
{
a[2] = 3; // компилятор выдаст ошибку!
}

Многомерный массив

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

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

void fa(int a[5][4]);

void fb(int a[][4]);
void fc(int (*a)[4]);

Сходство в передаче массивов для первой размерности очевидно.

Вторая размерность указана непосредственно.

Величина второй размерности должна быть указана, поскольку вну-

три функции невозможно будет корректно выделить память. Например,
173
Глава 4

элемент a[1][1] находится в нашем примере (выше) на седьмой пози-

ции. Если бы вторая размерность равнялась 10, тогда элемент a[1][1]
был бы на двенадцатой позиции. В случае двумерного массива вторая
размерность проверяется компилятором. Вызов функции с массивом,
объявленным в качестве b[5][3], будет обнаружен и запрещен компи-
лятором.

Скобки вокруг *а в функции fc()необходимы, иначе параметр бу-

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

4.1.4. Ссылочный параметр

В языке C++ существует еще один способ, как из функции получить

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

Содержимое указателя и ссылки различается тем, что в ссылку не ко-

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

#include <iostream>
using namespace std;
int func(int &parameter)
{
parameter = parameter + 4;
}
int main()
{
int number = 5;

174
 Функции

func(number);
cout << number << endl; // результат: 9!
}
Листинг 4.6. Передача параметров по ссылке (linkpar.cpp)

Разница между указателем и ссылкой, используемыми в качестве па-

раметров, совсем незначительная. На первый взгляд, она состоит только
в синтаксисе определения. И на самом деле, на практике можно одно за-
менять другим. Разница заключается только в том, что указателю в лю-
бой момент можно присвоить другое значение, и указать тем самым на
иную переменную. Ссылка, напротив, является представителем переда-
ваемой переменной и не может использоваться для какой-либо иной.
В больших структурах данных ссылка имеет значительное преиму-
щество при передаче данных в функцию, поскольку при этом не требу-
ется копировать всю структуру. По этой причине ссылочная передача
данных широко используется, даже когда переменные в функции не
должны изменятся. Если необходимо защитить данные от изменения
в вызываемой функции, используется ключевое слово const.
int func(const bigtype &link_par)
{
...

По причине того, что ссылка является представителем переменной,

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

Упражнение
• Напишите функцию с именем swap(), которая получает два ссылоч-
ных параметра и обменивает их содержимое между собой. Решение
приведено на стр. 503.

175
Глава 4

4.1.5. Пример: стек

Следующий пример реализует стек. Данная структура помещает

данные в память и выдает их в порядке, обратном записи. Две ключевые
операции стека — это push()1 для записи данных, и pop()2 для их по-
лучения.

В качестве данных используются целые числа. Есть только один стек,

доступ к которому можно получить с помощью переменной Stack.

#include <iostream>
using namespace std;
struct TListStack
{
int data; // симуляция данных
TListStack *next; // связь со следующим элементом
};
TListStack *Anchor = 0; // глобальный начальный пункт стека
void push(int data) // добавление нового элемента
{
// создание нового элемента:
TListStack *node = new TListStack;
node->data = data; // заполнение данными
node->next = Anchor; // прикрепление к предыдущему элементу
Anchor = node; // установка нового начального пункта
}
int pop() // получение последнего записанного в стек элемен-
та
{
int content=0; // промежуточное сохранение элемента
if (Anchor) // не равен 0! Стек не пустой!
{
// сохранение указателя чтобы в будущем удалить //элемент:
TListStack *old = Anchor;

1
В пер. с англ. «толкать». Прим. ред.
2
В пер. с англ. «вытягивать». Прим. ред.

176
 Функции

Anchor = Anchor ->next; // следующий элемент вперед

content = old->data; // сохранение данных
delete old; // удаление элемента
}
return content; // возвращение содержимого
}
int main() // тест функции стека
{
push(2); // записать данные в стек
push(5); // записать данные в стек
push(18); // записать данные в стек
cout << pop() << endl; // вывод должен быть 18
cout << pop() << endl; // вывод должен быть 5
cout << pop() << endl; // вывод должен быть 2
}
Листинг 4.7. Стек в качестве связанного списка (stackstruct.cpp)

Можно, конечно, вместо целочисленной переменной использовать

любые другие структуры данных. В случае если в программе стек ис-
пользуется для различных типов данных, допустимо вместо данных ис-
пользовать указатель на них. Используя указатель на тип void, можно
создать гибкие структуры со всеми возможными типами. В конце кон-
цов, смысл функций push() и pop() при изменении типа данных не ме-
няется. Но прежде чем потратить силы на эксперименты в этой области,
рекомендуется рассмотреть примеры. Возможно, проблема уже имеет
значительно более элегантное решение (см. стр. 317).

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

Упражнение
• Расширьте программу стека так, чтобы в ней можно было использо-
вать не один , а сколько угодно различных стеков, в том числе и ло-
кальных. Подсказка: вместо функций push() и pop() в глобальном
списке используйте переменную Anchor, список следует передавать
в качестве параметра. Решение приведено на стр. 504.

177
Глава 4

4.1.6. Предопределенные параметры

Язык C++ позволяет указывать некоторые параметры функции

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

void PreVar(int a, int b, int c=4, char d='A', float e=0.0)

{
...
}
int main()
{
PreVar(5, 2, 5);
}
Листинг 4.8. Предопределенные параметры

После вызова функции PreVar() ее параметры предопределены

следующим образом:
• а==5
Значение установлено при вызове функции
• b==2
Значение установлено при вызове функции
• с==5
Значение установлено до вызова функции. Хотя параметр предо-
пределен со значением с=4, это, однако, будет действительно только
в том случае, если при вызове функции будет задано не более двух
параметров.
• d=='A'
При вызове функции были заданы только три параметра, поэтому
используется предопределенное значение.
• е==0.0
При вызове функции были заданы только три параметра, поэтому
используется предопределенное значение.
178
 Функции

4.1.7. Параметры функции main

Пришло время рассмотреть поближе функцию main(). Она так же

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

Тип возвращаемого значения функции main() является целочис-

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

Функция main() имеет два параметра вызова. По ним программа

может определить, какой командой и с какими аргументами вызвана
функция. Первый параметр традиционно называется argc1. Это пара-
метр целочисленного типа, который определяет количество параметров
запущенной программы. Имя программы также считается параметром,
поэтому минимальное значение argc равно 1. Второй параметр называ-
ется argv2 и представляет собой массив указателей на тип char. Здесь
располагается имя программы и ее параметры, задаваемые операцион-
ной системой. Полное определение main() имеет следующий вид3:

int main (int argc, char* argv[])

{
...
}

Имена argc и argv являются чистой условностью. Эти параметры

можно назвать иначе. Однако, поскольку они известны именно под та-

1 argc состоит из английского словосочетания «argument count», что означает «коли-

чество аргументов».
2
argv от английского словосочетания «argument vector», что в переводе означает
«вектор аргументов».
3
В некоторых случаях можно встретить третий параметр, которым является ука-
затель на переменную режима работы. Однако этот параметр не поддерживается стан-
дартом POSIX. Причина в том, что доступ к этой переменной посредством функций
getenv() и setenv() гораздо проще.

179
Глава 4

кими именами, их изменение вряд ли приведет к лучшему пониманию

кода программы. Рассмотрим сначала второй параметр argv. Это массив
указателей на С-строки. Графически его можно представить следующим
образом (рис. 4.6).

Рис. 4.6. Параметр argv

Параметр argv является массивом, содержащим указатели. Каж-

дый из указателей ссылается на определенную С-строку, то есть на мас-
сив элементов типа char, конец которого обозначен нулевым байтом.
Первый указатель, то есть элемент argv[0], всегда указывает на имя
программы, с которым она была запущена. Соответственно, значение
параметра argc всегда равно минимум 1. Эта особенность прежде все-
го используется в UNIX, чтобы с помощью имени программы управ-
лять также ее функциональностью. Яркий пример — программа архи-
вации gzip, которая распаковывает архив, если ее вызвать под именем
gunzip.

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

ся в argv[1]. В таком случае переменная argc будет иметь значение 2.

Следующая программа демонстрирует имя, под которым она была

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

#include <iostream>
using namespace std;
int main(int argc, char **argv)
{

180
 Функции

for (int i=0; i<argc; i++)

{
cout << argv[i] << endl;
}
return 0;
}
Листинг 4.9. Отображает параметры вызова (main.cpp)

4.1.8. Переменное количество параметров

Существуют функции, к примеру printf() (см. стр. 373), кото-

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

К этим дополнительным параметрам нельзя добраться внутри

функции так же просто, как к обычным, поскольку они не имеют имен,
которые можно использовать для доступа к ним. С помощью макроко-
манды va_start() можно получить доступ к дополнительным пара-
метрам. Первый — это указатель на тип va_list. По его содержимому
функция va_arg() определяет, какой размер имеют переменные. Этот
указатель определяется макрофункцией va_start(). Второй параметр
va_start() — последний стандартный параметр функции. Доступ к па-
раметрам прекращается после вызова макроса va_end(), единственный
параметр которого — указатель.

Между тем доступ к отдельному параметру осуществляется с помо-

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

#include <iostream>
using namespace std;
#include <stdarg.h>
void func(int num, ... )

181
Глава 4

{
va_list param; // указатель на параметр
int intpar; // содержимое параметра
va_start(param, num); // подготовка доступа
// просмотр всех параметров
//(зависит от переменной num)
for (int i=0; i<num; i++)
{
intpar = va_arg(param, int); // достать параметр
cout << intpar << endl; // вывести его
}
cout << "---" << endl;
va_end(param); // закрыть доступ
}
int main()
{
// проверка функции с различными параметрами
func(2, 5, 2);
func(0);
func(4, 5, 2, 0, 3);
}
Листинг 4.10. Доступ к дополнительным параметрам (vararg.cpp)

Количество параметров передается в функцию из программы, кото-

рая ее вызывает. Макрос не несет эту информацию. В примере выше ко-
личество параметров ожидается в качестве первого параметра функции.
В функцию func() можно передавать только целочисленные параме-
тры. Для функции printf() в качестве типа и количества параметров
используется формат строк.

Как мы видим, применение этой техники легко приводит к ошиб-

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

182
 Функции

4.2. Перегрузка функций

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

#include <iostream>
using namespace std;
void show(int i)
{
cout << "int: " << i << endl;
}
void show(double f)
{
cout << "double: " << f << endl;
}
int main()
{
show(12); // вызывает первую функцию (12 тип int)
show(2.5); // вызывает вторую функцию (2.5 тип float)
}
Листинг 4.11. Перегруженные функции (overload.cpp)

Функции отличаются параметрами, а не типом возвращаемого зна-

чения.

4.3. Коротко и быстро: встроенные функции

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

183
Глава 4

щается обратно к пункту, из которого она ушла в функцию. Несмотря

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

Если компилятор определит, что такая подстановка не приносит

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

#include <iostream>
using namespace std;
inline int min(int a, int b)
{
return a<b ? a : b;
}
int main()
{
cout << min(4, 3) << endl;
cout << min(3, 4) << endl;
}
Листинг 4.12. Встроенная функция (inline.cpp)

В примере код функции используется не обычным способом — под-

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

#include <iostream>
using namespace std;
int main()

184
 Функции

{
cout << 4<3 ? 4 : 3 << endl;
cout << 3<4 ? 3 : 4 << endl;
}
Листинг 4.13. Преобразование

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

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

4.4. Нисходящий метод

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

Нисходящий метод — это техника разработки, при которой ком-

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

Таким образом, программа разделена уже на первом этапе. Затем

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

Такая манера разработки реализуется с помощью процедурных язы-

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

185
Глава 4

4.4.1. Пример: игра «Бермуда»

Лучше всего рассмотреть разделение задачи на части и упрощение

ее с помощью нисходящего проектирования на примере. Для этого рас-
смотрим игру «Бермуда», правила которой описаны на стр. 131.

Сначала игра будет описана несколькими общими шагами. В фазе

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

Рис. 4.7. Структурная диаграмма игры «Бермуда»

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

int main()
{
init_game_field():
do
{
output_game_field();
input_data();
search_ships();
write();
}
while (!end_game());
}

186
 Функции

Отельные части задачи выделены в функции. Они могут расклады-

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

int main()
{
char game_field[X][Y];
tShip ship[max_ship];
int x, y;
int number;
init_game_field(game_field, ship);
do
{
output_game_field(game_field);
input_data();
number=search_ships(ship,x,y);
write(game_field, x, y, number);
}
while (!end_game(ship));
}
Листинг 4.14. Главная программа

Рассмотрим функцию init_game_field(). Она выполняет две опе-

рации. Сначала должен быть подготовлен двумерный массив. Затем
корабли следует расставить на свои позиции. Оба задания уже были
выполнены на стр. 131 и 150. Единственное, что осталось сделать, — упа-

187
Глава 4

ковать эти фрагменты программы в функции и определить их входные

параметры.

void init_output(char game_field[X][Y])

{
...
}
void init_ship(tShip ship[])
{
...
}
void init_ game_field(char game_field[X][Y], tShip ship[])
{
init_output(game_field);
init_ship(ship);
}
Листинг 4.15. Инициализация

Вывод игрового поля уже был запрограммирован, а ввод данных

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

188
 Функции

int search_ships(tShip ship[], int x, int y)

{
int number=0;
if (ship_exist(ship, x, y, true))
{
return max_ship;
}
else
{
number += search_left(ship, x, y);
number += search_left_up(ship, x, y);
number += search_up(ship, x, y);
number += search_right_up(ship, x, y);
number += search_right(ship, x, y);
number += search_right_down(ship, x, y);
number += search_down(ship, x, y);
number += search_left_down(ship, x, y);
}
return number;
}
Листинг 4.16. Поиск кораблей

Восемь функций поиска похожи между собой. Например, рассмо-

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

int search_right_up(tShip ship[], int x, int y)

{
x++; y--;
while(x<X && y>=0)
{
if (ship_exist(ship, x, y))
{

189
Глава 4

return 1;
}
x++; y--;
}
return 0;
}
Листинг 4.17. Диагональный поиск

Под конец еще следует реализовать функцию ship_exist(). Это от-

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

bool ship_exist(tShip ship[], int x, int y

bool mark=false)
{
for (int i=0; i<max_ship; i++)
{
if (ship[i].x==x && ship[i].y==y)
{
if (mark)
{
ship[i].finded = true;
}
return true;
}
}
return false;
}
Листинг 4.18. Вопрос попадания

190
 Функции

Видно, что изначально казавшаяся сложной задача, легко решает-

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

Упражнение
• Это конечно не очень хорошо, что поиск в различных направлени-
ях осуществлен разными, но, тем не менее, похожими друг на дру-
га функциями. Вместо этого значительно более элегантно было бы,
если бы использовалась только одна функция, которая выполняла
бы поиск в различных направлениях, в зависимости от того, какие
параметры в нее передаются. Для реализации этой задачи требует-
ся поразмыслить. Однако не сдавайтесь слишком быстро. Решение
приведено на стр. 506.

4.5. Область действия переменных

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

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

4.5.1. Глобальные переменные

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

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

Для глобальных переменных можно также использовать прототи-

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

191
Глава 4

Переменная объявляется без ее определения, если перед ней указано

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

enum tMarker = ... ;

extern tMarker actual_marker;
tError read_number(char *source)
{
...
actual_marker = NUMBER;
...
}
...
tMarker actual_marker = 0;
Листинг 4.19. Объявление переменной

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

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

4.5.2. Локальные переменные

Если внутри блока объявлена переменная, она называется локаль-

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

Локальные переменные хранятся в стеке (см. стр. 523). Там же рас-

полагаются адрес возврата вызванной функции и ее параметры. Эта

192
 Функции

память легко освобождается после того, как программа покидает функ-

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

Везде, где это возможно, следует использовать локальные перемен-

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

Память станет оптимально использоваться, поскольку она задей-

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

Переменные параметров также являются локальными. Они помеща-

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

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

Локальные переменные могут быть объявлены в качестве стати-

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

Такие переменные видимы только в блоке, в котором они опреде-

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

1 Можно описывать глобальные переменные как статические. Однако это будет

иметь совершенно иное значение.

193
Глава 4

В следующем примере сравниваются три переменные, и демонстри-

руется различное их поведение.

#include <iostream>
using namespace std;
int globvar = 1;
void func()
{
static int statvar = 1;
int locvar = 1;
cout << "статическая:" << statvar;
cout << "глобальная:" << globvar;
cout << "локальная:" << locvar << endl;
statvar++;
globvar++;
locvar++;
}
int main()
{
func();
func();
func();
locvar = 8; // компилятор выдаст ошибку
statvar = 8; // компилятор выдаст ошибку
globvar = 8; // это работает
func();
func();
}
Листинг 4.20. Статическая переменная

Функция func() работает с тремя переменными. Все три выводят-

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

194
 Функции

поскольку они доступны только внутри функции func(). Она вызыва-

ется еще два раза. Когда обе ошибки будут устранены, программу можно
запустить.
статическая: 1 глобальная: 1 локальная: 1
статическая: 2 глобальная: 2 локальная: 1
статическая: 3 глобальная: 3 локальная: 1
статическая: 4 глобальная: 8 локальная: 1
статическая: 5 глобальная: 9 локальная: 1

В примере показано поведение различных переменных. Поведение

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

Каждый раз переменная инициализируется заново и принимает зна-

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

Глобальная переменная globvar создается и инициализируется при

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

Статическая переменная statvar ведет себя частично как локаль-

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

4.6. Рекурсивные функции

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

195
Глава 4

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

ципу рекурсии. Второй — тоже самое, но без рекурсии. Обе функции
подсчитывают сумму чисел от 1 до max.

long sum_recursion(long max)

{
if (0 < max)
{
return sum_recursion(max - 1) + max;
}
return 0;
}
long sum_iterat(long max)
{
long Sum = 0;
while (0 < max)
{
Sum+=max;
max--;
}
return Sum;
}
int main(int argc, char** argv)
{
long max = atol(argv[1]);
cout << sum_recursion(max) << endl;
cout << sum_recursion(max) << endl;
}
Листинг 4.21. Сумма от 1 до max (recsum.cpp)

Экономия двух строк, вероятно, не впечатляет. Но в примере речь

идет не об элегантности или эффективности, а о предоставлении альтер-
нативного решения. Этот простой пример упрощает понимание работы
рекурсии.

196
 Функции

Тело такой функции соответствует телу цикла. Он не содержит ре-

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

За кадром

Рекурсия использует стек, в который при каждом повторном вызове

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

sum_recursion(4) [=6]+4
sum_recursion(3) [=3]+3
sum_recursion(2) [=1]+2
sum_recursion(1) [=0]+1
sum_recursion(0)

Сначала функция sum_recursion() вызывается с параметром 4.

Пока его значение не станет равно 0, она вызывает саму себя с параме-
тром, уменьшенным на 1. Здесь получилось бы 3. Вызов повторяется
за вызовом, пока значение параметра не станет равным 0. После это-
го функция не вызывает себя, а просто выполняет все следующие да-
лее в ее теле команды. Она возвращает 0. Затем функция переходит
в предыдущий свой вызов, где значение параметра max было равно 1.
Оно добавляется к результату, который вернула функция, и передается
далее в качестве результата. Затем возврат происходит на тот уровень,
где значение параметра max было равно 2. Так продолжается до тех пор,
пока функция sum_recursion(4) не вернет 10.

4.6.1. Область действия

Определенные задания, которые с помощью рекурсии можно решить

в несколько строк, иначе можно реализовать только с основательными

197
Глава 4

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

ветвится на манер дерева.

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

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

print_recursion(char * FileName)
{
open_file(FileName)
while (!end_file())
{
read_line();
if (command_include(IncludeFileName))
{
print_recursion(IncludeFileName);
}
print_line();
}
}
Листинг 4.22. Рекурсия печати

Эта функция справляется с любым количеством вложенных одна

в другую команд #include и в целом достаточно легко читается. Можно
исходить из того, что препроцессор C++ (см. стр. 521) считывает файлы
также рекурсивно.

4.6.2. Пример: бинарное дерево

Бинарное дерево проще всего реализовать с помощью рекурсии

(рис. 4.8). Оно состоит из узлов, которые имеют две ветви, указывающие
на следующие узлы. Каждый узел содержит некоторую информацию.

198
 Функции

27

16 36

7 19 43

Рис. 4.8. Бинарное дерево

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

Если информация отсортирована подобным образом, ее можно най-

ти очень быстро.

Чтобы построить такое дерево в программе, нужно определить ка-

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

struct tTree
{
int content;
tTree *left;
tTree *right;
};
Листинг 4.23. Узел бинарного дерева

Дерево создается, когда несколько узлов связываются друг с другом

с помощью указателей left и right, не создавая при этом замкнутый
круг. Напомню: узел создается с помощью команды new (см. стр. 152).
Возвращаемое значение — это указатель на новый узел. Для доступа
к его элементам следует после указателя ввести комбинацию симво-
лов -> и затем сообщить имя элемента, к которому требуется доступ
(см. стр. 146).

199
Глава 4

tTree *NewKnot;
NewKnot = new tTree;
NewKnot -> content = 5;
Листинг 4.24. Создание и заполнение узлов бинарного дерева

Следующий листинг демонстрирует функцию, которая перебирает

элементы бинарного дерева и выводит их на экран. До этого вы можете,
вооружившись карандашом, попробовать перебрать по порядку элементы
дерева, расположенного на рисунке. При этом следует постоянно придер-
живаться левой стороны. Если дальше влево двигаться нельзя, следует
отобразить содержимое узлов и попробовать сделать шаг вправо, а после,
если это возможно, снова двигаться влево. Рассматривая рекурсивную
функцию output_tree(), можно установить, что она работает именно
таким образом. Сначала проверяет, существует ли вообще текущий лист.
Затем вызывает саму себя для левой ветви. Функция будет вызывать себя
до тех пор, пока ветви слева существуют. Когда она больше не находит ле-
вой ветви, содержимое текущего узла выводится на экран. Затем функция
вызывается для правой ветви. Отсюда она снова просматривает все левые
части, пока они не закончатся. Очевидно, что рекурсивное решение соот-
ветствует интуитивному решению задачи. Его преимущества сразу станут
понятны, если попробовать вывести данные дерева с помощью цикла.

struct tTree
{
int content;
tTree *left;
tTree *right;
};
void output_tree(tTree *leaf)
{
if (leaf==0) return;
output_tree(leaf->left);
cout << leaf->content << endl;
output_tree(leaf->right);
}
Листинг 4.25. Вывод отсортированного бинарного дерева (bintree.cpp)

200
 Функции

Соответственно, добавление элемента в дерево проще всего реали-

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

tTree * insert(tTree *leaf, int content)

{
if (leaf==0) // найдена свободная позиция
{
// добавление нового листа
leaf = new tTree;
leaf->left = leaf->right = 0;
leaf->content = content;
return leaf; // возвращение указателя на новый лист
}
if (content < leaf->content)
{
// присваивание сохраняет старый лист или новый
leaf->left = insert(leaf->left, content);
}
else if (content > leaf->content)
{
// присваивание сохраняет старый лист или новый
leaf->right = insert(leaf->right, content);
}
return leaf; // возвращает текущий лист
}
Листинг 4.26. Добавление элемента в отсортированное дерево (bintree.cpp)

Добавление нового листа в дерево не будет работать в переборе, в ко-

тором вызывается команда new, но будет работать в вызванной до этого
функции в следующей позиции:
leaf->left = insert(leaf->left, content);

201
Глава 4

В большинстве случаев это присваивание не изменит лист, посколь-

ку в качестве первого параметра передается именно тот лист, который
располагался в этой позиции. Только в случае, если leaf->left равно
0, будет создан новый лист. Указатель на него возвращается, и на это
место помещается новый элемент.

Упражнение
• Напишите функцию рекурсии, которая ищет числа в бинарном дере-
ве. Решение приведено на стр. 507.

4.6.3. Игра «Ханойская башня»

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

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

Рис. 4.9. «Ханойская башня»

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

количестве колец. Для этого используется полная индукция, которая
подводит базис под рекурсивный метод для решения задачи с помощью
программы. Метод доказательства полной индукции состоит из двух
фаз: первая — это утверждение, в котором доказывается, что решение
верно для одного элемента. Вторая — индуктивный шаг. Здесь принима-
ется, что решение верно также для n элементов. Исходя из этого должно
быть доказано, что утверждение верно и для n+1 элементов. Если это
удастся, то доказательство будет верным для дюбого числа элементов.

Доказательство
1. Утверждение
Если башня состоит из одного кольца, можно просто переложить его
с левого колышка на правый.

202
 Функции

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

Верхние n колец следует переместить на средний колышек — мы

предположили, что это возможно.

На левом колышке осталось одно кольцо, которое перекладывается

на правый.

Тогда n колец с центрального колышка перекладываются на него же.

В итоге на правом колышке располагаются все n+1 колец.

Доказано.

Рекурсивная функция carry() в точности реализует индуктивный

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

Свободное место устанавливается с помощью небольшого трюка.

Параметры передают, какие колышки заняты. Третий колышек должен
быть свободен. На него перемещаются оставшиеся кольца. Сумма номе-
ров колышков всегда равна 1+2+3=6. Если два из них известны, нужно
просто сложить их номера, и номер третьего будет разницей между 6
и полученной при сложении суммой.

#include <iostream>
using namespace std;
void carry(int from, int to, int rings_number)
{
int free;
if (rings_number==0) return;
free = 6 — from - to; // определение свободного
//места

203
Глава 4

carry(from, to, rings_number-1);

cout << from << " - " << to << endl;
carry(free, to, rings_number-1);
}
int main()
{
carry(1, 3, 3); // с колышка 1 на колышек 3 перемещается 3
// кольца
}
Листинг 4.27. «Ханойская башня» на основе рекурсии (hanoi.cpp)

Первый вызов отображает, что кольца сначала находятся на колыш-

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

4.6.4. Пример: калькулятор

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

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

204
 Функции

Тип перечисления tToken демонстрирует, какой символ был рас-

познан. Помимо четырех основных арифметических операций (PLUS,
MINUS, MUL, DIV) здесь находятся скобки (LPAR и RPAR) и числа (NUMBER).
Символ END указывает на конец ввода, а символ ERROR требуется для
обозначения ошибки ввода.

Функция searchToken() распознает символы и может определить

целочисленное значение.

enum tToken
{
PLUS, MINUS, MUL, DIV, LPAR, RPAR, NUMBER, END, ERROR
};
// глобальные переменные:
tToken aktToken; // последняя распознанная лексема
double TokenNumber; // значение числовой константы
char *srcPos; // программная позиция
tToken searchToken()
// поиск с актуальной позиции следующей лексемы.
// здесь также устанавливаются числовые константы
// и записываются в глобальные переменные TokenNumber.
{
aktToken = ERROR;
if (*srcPos==0)
{
aktToken = END;
}
else
{
switch (*srcPos)
{
case '(': aktToken=LPAR; break;
case ')': aktToken=RPAR; break;
case '*': aktToken=MUL; break;
case '/': aktToken=DIV; break;

205
Глава 4

case '+': aktToken=PLUS; break;

case '-': aktToken=MINUS; break;
}
if (*srcPos>='0'&& *srcPos<'9')
{
aktToken=NUMBER;
TokenNumber = 0.0;
}
while (*srcPos>='0' && *srcPos<'9')
{
TokenNumber *= 10;
TokenNumber += *srcPos-'0';
srcPos++;
}
if (aktToken != NUMBER)
{
srcPos++;
}
}
return aktToken;
}
tToken Error(char *s)
// вывод сообщения и возврат ошибки
{
cerr << s << endl;
return ERROR;
}
Листинг 4.28. Лексический анализ (calc.cpp)

Рекурсия используется в начале программы для интерпретации лек-

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

206
 Функции

ется к функции Brackets(), поскольку скобки определяют приоритет

операций.

Функция Brackets() проверяет, какой приоритет имеет лексема.

Сюда относятся открытые скобки, число или знак числа. Если лексема
не является ни одним из этих элементов, функция завершается и воз-
вращается к вызванной функции MulDiv(). Эта функция ищет символ
умножения (*) или деления (/). Если лексема не является ни одним из
этих символов, функция возвращается в PlusMinus() и ищет сложение
или вычитание.

Если же функция Brackets() нашла левую скобку, то она вызывает

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

double PlusMinus(); // Прототип

double Brackets()
// определение скобок, чисел и знака числа
// рекурсивный вызов Brackets() и PlusMinus()!
{
double Number;
switch(aktToken)
{
case NUMBER:
searchToken();
return TokenNumber;
case MINUS:
searchToken();
return -Brackets();
case LPAR:
searchToken();
Number = PlusMinus();
if (aktToken != RPAR)
{
return Error(") expected");
}

207
Глава 4

searchToken();
return Number;
case END:
return 1;
}
return Error("primary expected");
}
double MulDiv()
// определение деления и умножения
// рекурсивный вызов Brackets()!
{
double Number;
// вызов операции с наивысшим приоритетом
Number = Brackets();
while (aktToken==MUL || aktToken==DIV)
{
if (aktToken==MUL)
{
searchToken();
Number *= Brackets();
}
else if (aktToken==DIV)
{
searchToken();
Number /= Brackets();
}
}
return Number;
}
double PlusMinus()
// определяет сложение и вычитание
// рекурсивный вызов MulDiv()
{
double Number;
// вызов операции с наивысшим приоритетом

208
 Функции

Number = MulDiv();
while (aktToken==PLUS || aktToken==MINUS)
{
if (aktToken==PLUS)
{
searchToken();
Number += MulDiv();
}
else if (aktToken==MINUS)
{
searchToken();
Number -= MulDiv();
}
}
return Number;
}
double analysis(char *s)
{
srcPos = s;
searchToken(); // предварительное определение первой
//лексемы
return PlusMinus();
}
int main(int argc, char* argv[])
{
double Number = analysis(argv[1]);
cout << Number << endl;
return 0;
}
Листинг 4.29. Синтаксический анализатор (calc.cpp)

При вызове функции analysis()в качестве параметра необходимо

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

жет проанализировать числа с плавающей запятой. На стр. 372 и далее

приведены примеры программ, в которых представлено решение и для
дробных чисел.
Программа получает проанализированную строку в качестве пара-
метра. В UNIX нужно обращать внимание на то, чтобы строка для ана-
лиза помещалась в кавычки, если необходимо провести умножение1.
Здесь представлено несколько тестовых запусков:
> calc "12*(5+2)"
84
> calc "4*(5+2)"
28
> calc "4*5+2"
22
> calc "(5-4)*5*6+(7-3)*((4+2))"
54
> calc "(5-4)*5*6+(7-3)*((4+5)/3)"
42
>
Калькулятор справляется с правилом приоритетов арифметических
операций, не имеет проблем со скобками и может посчитать также слож-
ные выражения.

Упражнения
• На стр. 372 приведен пример, как можно прочесть числа с плаваю-
щей запятой из символьной последовательности. Интегрируйте это
решение в код программы калькулятора, чтобы оно могла работать
также с числами типа double. Решение приведено на стр. 508.
• Дополните программу калькулятора так, чтобы между лексемами
мог располагаться пробел. При тестировании строку с пробелом
следует вводить в кавычках, поскольку она будет интерпретирована
в качестве нескольких параметров.
• Почему программа не путается со знаком минус, хотя иногда он мо-
жет быть знаком числа, а иногда обозначать арифметическую опера-
цию? Ответ на стр. 510.
1 Причина в том, что оболочка UNIX расценивает астериск как выделение места под
файл и можно получить забавные результаты.

210
 Функции

4.7. Указатель функции

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

Такой указатель может потребоваться, к примеру, чтобы сообщить

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

При этом пользовательская программа сообщает операционной си-

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

Чтобы вызвать функцию через указатель, должен быть точно указан

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

Рис. 4.10. Граф синтаксиса указателя функции

Скобки вокруг имени указателя и астериск очень важны. Они не

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

Чтобы установить указатель на функцию для добавления целого

числа в структуру дерева, лучше всего ориентироваться на прототип
функции.
tTree * fit_in(tTree * leaf, int content); // прототип

После этого необходимо указать астериск перед именем функции

и заключить то и другое в скобки. Затем нужно убрать имена параме-
тров, и указатель на функцию готов.
tTree * (* fit_in)(tTree * , int); // указатель на функцию

Указатель может получать адрес функции с помощью прямого при-

сваивания имени. Допустимо перед именем функции указать знак адре-
211
Глава 4

са. Это не навредит, а для читателя будет понятно, что здесь речь идет об
адресе функции.

fit_inPointer = fit_in; // первый вариант

fit_inPointer = &fit_in; // второй вариант

Вызов функции с помощью указателя не отличается от

Anchor = fit_inPointer(Anchor, 22); // вызов через указатель

 Глава 5
КЛАССЫ
Язык C++ поддерживает объектно ориентированное
программирование посредством классов.
Эта парадигма позволяет создавать
надежные и хорошо обозримые программы.
Но язык C++ не навязывает написание
объектно ориентированных программ.
Он позволяет прийти к этому самостоятельно.

Бьерн Страуструп не изобрел объектно ориентированное програм-

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

Разработка программного обеспечения занимает много времени

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

213
Глава 5

отслеживаются. Процедуры и функции позволили реализовать нисхо-

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

Модульность с принципом секретности позволила разделить рабо-

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

Объектное ориентирование ставит объекты и структуры данных на

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

5.1. Классы и структуры данных

В одном классе можно объединить несколько различных типов дан-
ных для моделирования своего собственного типа. Этот принцип уже из-
вестен из структур (стр. 146). Согласно ему можно объединять массивы
и другие, самостоятельно созданные типы — фантазия не ограничивает-
ся. Речь идет о том, чтобы данные о некотором реальном объекте объеди-
нить в класс и создать пригодную модель реальности в программе.

Рассмотрим простой пример даты. Она состоит из трех целых чисел,

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

class tDate
{
public:
int Day;
int Month;
int Year;
};
Листинг 5.1. Класс даты — первый шаг

214
 Классы

Слово public с двумя точками означает, что все следующие элемен-

ты общедоступные. Не следует забывать это слово, поскольку иначе вся
информация в классе будет скрытой, и к ней нельзя будет получить до-
ступ извне. Почему закрытый доступ хорош, мы увидим потом. Команда
public: просто сообщает о том, что можно получить доступ к элементам
Day, Month и Year так же, как это делается в структурах (см. стр. 146).

tDate today;

today.Day = 13;

Здесь создан объект today типа tDay. Объект содержит три цело-
численные переменные — Day, Month, Year, как это видно из объявления
класса. Чтобы получить доступ к переменной, следует сначала указать
имя объекта, затем точку, а после нее — имя элемента, к которому требу-
ется получить доступ. В примере дню присваивается значение 13.

Чтобы добраться до элемента класса через указатель, его следует

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

tDate *once;

(*once).Day = 13;

once->Day = 13;

Переменная once является указателем на объект класса tDate. Здесь

представлены две альтернативы доступа к элементу Day через указатель.

 Класс — это абстрактное определение типа данных. Объект — это

переменная, тип которой — класс. Можно сказать, что объект —
это экземпляр класса.

5.1.1. Союз функции и структуры данных

Теперь можно поместить дату в созданный тип данных, создав такую

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

215
Глава 5

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

Так же как к элементам данных можно получить доступ только через

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

Предположим, нам нужно в класс даты добавить функцию расчета

дня нового года. Она будет так же встроена в структуру класса, как и три
целочисленные составляющие.

class tDate
{
public:
int Day;
int Month;
int Year;
void NewYear(int Year);
};
today.NewYear(2000);

Функция NewYear() имеет в качестве параметра число года. Она

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

216
 Классы

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

а Year — 2000.

Для вызова элементной функции ее имя прикрепляется к имени объ-

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

class tDate
{
public:
int Day;
int Month;
int Year;
void NewYear(int Year);
};
void tDate:: NewYear(int pYear)
{
Day = 1;
Month = 1;
Year = pYear;
}
Листинг 5.2. Класс с элементной функцией

Чтобы отличать элементную функцию NewYear() от глобальной,

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

Также можно определить функцию прямо в классе. Но тогда код

очень быстро станет нечитаемым. Поэтому так можно делать только
с очень короткими функциями.

class tDate
{
public:

217
Глава 5

int Day;
int Month;
int Year;
void NewYear(int Year);
{
Day = 1;
Month = 1;
Year = pYear;
}
};
Листинг 5.3. Класс с элементной функцией

Функция, которая в определении класса не только объявлена, но

и определена, автоматически компилируется в качестве встроенной
(см. стр. 183).

В обоих случаях при вызове элементная функция получает прямой

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

Номенклатура

Объектно ориентированное программирование вводит новые понятия.

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

218
 Классы

Я отказался от этих терминов по нескольким причинам. Прежде все-

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

5.1.2. Доступ к элементам класса

Внутри элементной функции можно получить прямой доступ к эле-

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

void tDate:: NewYear(int pYear)

{
this->Day = 1;
this->Month = 1;
this->Year = Year;
}
Листинг 5.4. Доступ через указатель this

Локальные переменные, к которым также относятся параметры, пе-

рекрывают элементы класса с такими же именами. Через указатель this
можно явно получить доступ к элементу класса. Это особенно заметно
при присвоении числа года. Цель — элемент класса, источник — пара-
метр.

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

void tDate:: NewYear(int pYear)

{
tDate::Day = 1;
tDate::Month = 1;
tDate::Year = Year;
}
Листинг 5.5. Доступ по имени класса

219
Глава 5

5.2. Создание и удаление объекта

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

5.2.1. Конструктор и деструктор

Элементные функции, которые вызываются при создании объекта,

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

Конструктор всегда носит имя класса и не имеет возвращаемого

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

Как противоположность конструктора существует деструктор. Он

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

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

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

class tDate
{
public:

220
 Классы

tDate();
~tDate();
...
};
tDate::tDate()
{
Day=0; Month=0; Year=0;
}
tDate::~tDate()
{
}
Листинг 5.6. Конструктор и деструктор

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

создается и разрушается объект. Глобальные объекты создаются при
запуске программы и разрушаются при ее завершении. Локальные —
вызывают конструктор на том шаге программы, где находится их опре-
деление, и удаляются, когда программа покидает область действия объ-
екта. Создание и удаление объекта может быть явно указано с помощью
операторов new и delete. Если массив создается командой new, то для
создания каждого из его элементов вызывается конструктор. Соответ-
ственно, при удалении для каждого элемента вызывается деструктор
delete[].

{
tDate today;
tDate *tomorrow; // конструктор не вызывается!
tDate *holiday; // конструктор не вызывается
tomorrow = new tDate; // конструктор вызывается
holiday = new tDate[14]; // конструктор не вызывается 14 раз
delete tomorrow; // вызывается деструктор
...
delete[] holiday; // деструктор вызывается 14 раз
} // вызывается деструктор объекта today
Листинг 5.7. Вызов конструктора и деструктора

221
Глава 5

Особая форма инициализации

В большинстве случаев конструктор состоит из нескольких присва-

иваний, которые инициализируют переменные объекта.

Вместо того чтобы задавать переменным объекта начальные значе-

ния посредством присваивания в теле конструктора, их можно инициа-
лизировать следующим способом:

tDate::tDate() : Day(0),Month(0),Year(0)
{
}
Листинг 5.8. Альтернативная реализация

Для этого между заголовком и телом конструктора перечисляются

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

В этом случае значение переменных Day, Month, Year устанавливают-

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

5.2.2. Конструктор и параметры

Конструкторы также могут принимать параметры. Передаваемое

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

Конструкторы можно перегружать, как и обычные функции. Поми-

мо стандартного конструктора может существовать множество других,

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

важна. Но к этому мы еще вернемся.

222
 Классы

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

структор в зависимости от передаваемых ему параметров. Следующий
пример демонстрирует класс tDate с конструктором с тремя параметра-
ми.

class tDate
{
public:
tDate(int Day, int Month, int Year=-1);
...
};
tDate::tDate(int Day, int Month, int Year)
{
this->Day=Day;
this->Month=Month;
this->Year=Year;
if (Year<0)
{
// установить текущий год
...
}
}
tDate Start(1,1,1970);
tDate NewYear(31,12);
tDate *Christmas = new tDate(24,12);
Листинг 5.9. Конструктор с параметрами

Объект Start с помощью конструктора устанавливается в 1.1.1970.

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

223
Глава 5

Конвертирующий конструктор

Если присваивать переменной типа float переменную типа int, она

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

Конструктор с одним параметром приведет к тому, что компилятор

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

class tFraction
{
public:
tFraction(char *);
Add(tFraction&);
};
...
char input[MAXSTR];
getline(cin, input, MAXSTR);
tFraction b1(input);
getline(cin, input, MAXSTR);
b1.Add(input);

В классе tFraction находится конструктор, который принимает

в качестве параметра указатель на тип char, то есть С-строку. Функция
Add() принимает только тип tFraction. Компилятор позволяет сделать
вызов функции Add() с параметром С-строка, поскольку с помощью
этого конструктора он может скомпилировать данный параметр в тип
tFraction.

Конструктор конвертирования будет автоматически вызываться

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

class tFraction
{
public:

224
 Классы

explicit tFraction(long);
...
};
tFraction Fraction=12; // не будет работать через компилятор
tFraction Fraction(12); // так работает

Стандартный конструктор

Стандартным конструктором считается тот, вызов которого возмо-

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

В вышеописанном примере создание объекта типа tFraction или

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

5.3. Доступная и скрытая области

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

5.3.1. private и public

По умолчанию все элементы класса являются закрытыми. Если

в его определении указать метку public:, все элементы, следующие по-
сле нее, будут общедоступными. Если за этим блоком следуют закрытые
элементы, нужно указывать их после метки private:. Можно чередо-

225
Глава 5

вать такие метки сколько угодно. Однако рекомендуется скомпоновать

открытые и закрытые элементы в два блока. Более практично первыми
определять открытые элементы.

Хорошая идея обозначать элементы данных закрытыми. За счет это-

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

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

numerator и denominator — скрыты от внешнего доступа параметром
private. К общедоступным функциям относятся те, которые позволя-
ют записать и прочесть эти значения.

class tFraction
{
public:
tFraction() {numerator=0; denominator=1;}
long get_denominator() {return denominator;}
long get_numerator() {return numerator;}
void set_denominator(long p)
{if (p!=0) denominator =p;}
void set_numerator(long p) {numerator=p;}
void Show();
private:
long numerator;
long denominator;
};
void tFraction::Show()
{
cout << numerator << "/" << denominator << endl;

226
 Классы

}
int main()
{
tFraction fraction;
long in_denominator, in_numerator;
cout << "Введите через пробел числитель и знаменатель!"
<< endl;
cin >> in_numerator >> in_denominator;
fraction.set_denominator(in_denominator);
fraction.set_numerator(in_numerator);
fraction.Show();
}
Листинг 5.10. Расчет дроби с приватными данными

В примере класса tFraction элементы данных numerator

и denominator являются закрытыми. Доступ осуществляется с помо-
щью функций, которые начинаются со слова get или set. Это предот-
вращает ситуацию, когда кто-нибудь присвоит знаменателю значение 0.
Также можно при изменении или выводе на экран автоматически сокра-
тить дробь.

Имеет смысл ограничить доступ к данным класса. Это предотвратит

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

class tDate
{
private:
int day;
int month;

227
Глава 5

int year;
int weekday;
public:
tDate();
~tDate();
void set_day(int value);
void set_month(int value);
void set_year(int value);
int get_day() return day;
int get_month() return month;
int get_year() return year;
int get_weekday();
};
tDate::tDate()
{
weekday = -1;
}
void tDate::set_month(int value)
{
if (value>0 && value<13 && month!=value)
{
month = value;
weekday = -1;
}
}
Листинг 5.11. Класс с приватными элементами

При этом каждый, кто использует этот класс, учитывает, что при из-
менениях следует устанавливать значение переменной weekday равным
–1, а переменные day, month и year определять в качестве закрытых,
тем самым, защищая их от доступа извне. Их можно изменить только
с помощью элементных функций. Для этого используется функция
set_month(), которая, с одной стороны, не может присвоить месяцу
в объекте неверное значение. С другой стороны она заботится о том,
чтобы день недели обозначался как недействительный, как только из-

228
 Классы

менилось значение месяца. Этим достигается то, что элементная функ-

ция get_weekday() может возвращать день недели без пересчета, пока
он не установлен другой функцией в –1. Только тогда он должен быть
рассчитан заново.

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

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

5.3.2. Пример: стек

На стр. 154 уже был представлен связанный список. Там мы рас-

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

Функции push() и pop() принадлежат только классу и уже не явля-

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

// программа демонстрации стека на основе класса

#include <iostream>
using namespace std;
class tNode // узел связанного списка
{
public:
int d; // данные, здесь целые числа
tNode *next; // скрепление
};
// стек как объединение из якоря и операций
class tStack
{
public:
tStack();
229
Глава 5

~tStack();
void push(int); // добавление информации
int pop(); // получение информации
private:
tNode * Anchor; // каждый стек имеет свой собственный
// якорь
};
tStack::tStack()
{
Anchor = 0; // подготовка пустого списка
}
// деструктор удаляет все лишние элементы
tStack::~tStack()
{
tNode *last = Anchor; // вспомогательный указатель для
//защиты якоря
while (Anchor) // пока в списке есть элементы
{
last = Anchor; // первый элемент защищен
Anchor = Anchor->next; // установлен якорь на
//следующий элемент
delete last; // первый элемент освобожден
}
}
// добавление нового элемента в начало списка
void tStack::push(int d)
{
tNode *node = new tNode; // создание элемента списка
node->d = d; // заполнения поля данных
node->next = Anchor; // прикрепление к списку
Anchor = node; // присвоение этого элемента якорю
}
// прочесть верхний элемент и удалить его из списка
int tStack::pop()
{

230
 Классы

int content=0; // вспомогательная переменная типа данных

//элемента
if (Anchor) // пока список не пуст
{
tNode *old = Anchor; // защитить первый элемент
Anchor = Anchor->next; // установить якорь на второй
//элемент
content = old->d; // скопировать содержимое узла
delete old; // освободить прочитанный узел
}
return content; // вывести содержимое узла
}
int main() // главная программа для тестирования стека
{
tStack stack; // объявить стек
stack.push(2); // записать тестовые данные
stack.push(5);
stack.push(18);
cout << stack.pop() << endl; // прочесть стек
cout << stack.pop() << endl;
cout << stack.pop() << endl;
}
Листинг 5.12. Реализация стека (stack.cpp)

Упражнения
• Создайте класс tFIFO, который также создает динамическую струк-
туру данных. В отличие от стека, принцип FIFO1 аналогичен обслу-
живанию по очереди. Пакет, помещенный первым, также первым
и считывается. Подсказка для решения: не рекомендуется использо-
вать якорь, лучше заменить его на два указателя. Первый будет ссы-
латься на начало очереди, а второй — на конец. Решение приведено
на стр. 511.

1
Акроним от фразы First In, First Out — «первым пришел — первым ушел». Прим. ред.

231
Глава 5

• Дополните класс tFraction приватной функцией ggT-function(),

которая вызывается при выводе функцией Show() для сокращения
дроби.

5.3.3. Друзья

Друзья — это люди, которым мы доверяем и с которыми делимся

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

Друг класса определяется внутри него. При этом следует ключевое

слово friend и определение функции или класса, который принимается
другом.

class pal;
class police
{
public:
void help(pal&);
};
// Чтобы класс pal мог использовать класс в интерфейсе,
класс
// colleague должен быть определен здесь
class colleague;
class pal
{
private:
int secret;
void spion();
friend void help(pal);
friend class colleague;
friend void police::help(pal&);
};
class colleague
{

232
 Классы

public:
colleague()
{
JB.secret=007;
}
pal JB;
};
void help(pal Egon)
{
Egon.spion();
}
Листинг 5.13. Дружественные классы (friend.cpp)

Класс pal имеет три «дружественных» определения: первое разреша-

ет функции help() доступ ко всем элементам. Во втором определении
класс colleague обозначается дружественным. Тем самым каждой эле-
ментной функции класса colleague разрешен доступ к любому элемен-
ту класса pal. Третье определение позволяет функции help() из класса
police получать доступ ко всем элементам класса pal. Все остальные
функции класса police не имеют разрешения на доступ.

5.4. Конструктор копирования

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

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

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

233
Глава 5

класса освободит память внешней переменной, на которую ссылается

указатель.

Рис. 5.1. Копирование объекта

Поскольку он ссылается на область памяти оригинала, она также бу-

дет освобождена. Это значит, что каждый объект, который передается
функции в качестве параметра, потеряет свой внешний участок памяти
при завершении функции.

КОГДА ДОЛЖЕН СОЗДАВАТЬСЯ КОНСТРУКТОР КОПИРОВАНИЯ?

Если класс имеет ссылочные элементы на внешнюю память, нужно
создавать конструктор копирования. Подобными элементами явля-
ются указатели или ссылки. Однако и чужие классы могут содержать
такие элементы, например класс Strings (см. стр. 338).

Копирование данных внешней памяти нельзя сделать автоматически,

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

Конструктор копирования вызывается внутренними процессами ко-

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

Конструктор копирования должен сначала скопировать элементы

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

Его главной задачей является копирование данных, на которые ссыла-

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

Синтаксис

Конструктор копирования не возвращает значения и носит имя

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

Если в области данных класса tStack вместо целочисленных пере-

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

// программа демонстрации конструктора копирования

#include <iostream>
using namespace std;
class tClass
{
public:
tClass() // конструктор: создание внешних данных
{
pointer = new int;
*pointer = 5;
}
~tClass() // деструктор: освобождение внешней памяти
{
delete pointer;
pointer = 0;
}
void SetData(int a) { *pointer = a; }
int GetData() { return *pointer; }
tClass(tClass& k) // конструктор копировани
{
235
Глава 5

// для демонстрации он сообщает о себе

cout << "Конструктор копирования" << endl;
// внешние данные создаются и копируются
pointer = new int;
*pointer = k.GetData();
// обычные элементы данных также копируются
rest = k.rest;
}
int rest; // предназначается для обычных элементов
// данных
private:
int *pointer; // указатель, т.е. необходим конструктор
//копирования
};
// Функция служит только для демонстрации.Поскольку в пара-
метрах
// передается значение, при вызове также вызывается кон-
структор
// копирования
void func(tClass para)
{
cout << "Функция:" << para.GetData() << endl;
}
// Главная программа для тестирования
int main()
{
tClass Object;
Object.SetData(7);
func(Objekt); // здесь активизируется конструктор
// копирования
cout << Object.GetData() << endl;
}
Листинг 5.14. Внешняя память и конструктор копирования (copycons.cpp)

236
 Классы

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

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

~tClass() // деструктор: используется здесь в преступных целях

{
*pointer = 9; // только для тестирования
}

При закомментированном конструкторе копирования, последняя

строка программы выдаст 9 в качестве четкого указания на то, что де-
структор работал в той области, на которую ссылается указатель. Если
снова активировать конструктор копирования, опять появится 7.

5.5. Перегрузка элементных функций

Перегрузка уже была рассмотрена в разделе 3.7 в разделе «Функ-
ции» (см. стр. 138). Здесь эта тема всплывет еще раз — для рассмотрения
перегрузки элементных функций.

Для примера будем использовать класс tFraction, который позво-

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

class tFraction
{
public:
tFraction() {numerator=0; denominator=1;}
long get_denominator() {return denominator;}
long get_numerator() {return numerator;}
void set_denominator(long p)
{if (p!=0) denominator =p;}
void set_numerator(long p) {numerator=p;}
void Add(long);

237
Глава 5

void Add(tFraction);
void Show();
private:
long numerator;
long denominator;
};
void tFraction::Add(long summ)
{
numerator+=summ*denominator;
}
void tFraction::Add(tFraction summ)
{
numerator = numerator*summ.get_denominator()
+ summ.get_numerator()*denominator;
denominator = denominator * summ.get_denominator();
}
Листинг 5.15. Расчет дробей с перегруженными функциями (fraction.cpp)

Какую из функций сложения следует вызвать, решает компилятор

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

5.6. Выбор: перегрузка операторов

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

В языке C++ есть возможность реализации операторов. Для это-

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

new + % ~ > /= |= <<= >= -- ()

delete - ^ ! += %= << == && , []
new[] * & = -= ^= >> != || ->*
delete[] / | < *= &= >>= <= ++ ->

238
 Классы

То, что операторы были самостоятельно реализованы, не изменяет ни-

чего в контексте оператора. Сохраняется приоритет, количество операн-
дов и сочетаемость (левая или правая привязка). Также нельзя изменять
операторы, относящиеся к определенным типам данных. Минимум один
из двух операндов должен иметь тип, определенный пользователем.
Операторная функция не обязательно должна принадлежать клас-
су. Она может быть также глобальной. Однако некоторые операторы не
могут быть перегружены без принадлежности к определенному классу.
Это оператор присваивания =, вызов функции (), индекс [] и оператор
указателя ->. Если операторная функция принадлежит классу, объект
класса является первым операндом функции. В следующем примере
перегружается оператор плюс. Поскольку операторная функция при-
надлежит к классу tFraction, она представляет сложение, при котором
первый операнд имеет тип tFraction.
// элементная функция
tFraction tFraction::operator+(long summ);
Fraction = Fraction.operator+(Long); // вызов
Fraction = Fraction + Long; // вызов

Если оператор требует второй операнд, он передается параметром.

Пример иллюстрирует сложение. Здесь имеется два операнда. Второй
передается в качестве параметра функции operator+(), здесь он имеет
тип long.
Пользователь, работающий с функцией сложения, предполагает, что
параметры можно менять местами. Тогда первый операнд имел бы тип
long, то есть стандартный тип, для которого отсутствует класс. Только
в таком случае может быть написана глобальная операторная функция,
и она будет иметь два параметра.
// глобальная функция
tFraction operator+(long, const tFraction& o2);
Fraction = operator+(Long, Fraction); // вызов
Fraction = Long + Fraction; // вызов

Привычные связи не работают автоматически, когда оператор пере-

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

239
Глава 5

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

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

5.6.1. Сложение

Как и для функции Add(), которая рассматривалась при перегрузке

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

#include <iostream>
using namespace std;
class tFraction
{
public:
tFraction() { numerator=0; denominator=1;}
long GetDenominator() {return denominator;}
long GetNumerator() {return numerator;}
void SetDenominator(long p) {if (p!=0) denominator=p;}
void SetNumerator(long p) {numerator=p;}
tFraction operator+(long);
1 Такой печальный опыт привел к тому, что в языке Java перегрузка операторов во-
обще отсутствует.

240
 Классы

tFraction operator+(tFraction);
void Show();
private:
long numerator;
long denominator;
};
tFraction tFraction::operator+(long summand)
{
numerator+=summand*denominator;
return *this;
}
tFraction tFraction::operator+(tFraction summand)
{
numerator = numerator*summand.GetDenominator ()
+ summand.GetNumerator()*denominator;
denominator = denominator * summand.GetDenominator ();
return *this;
}
Листинг 5.16. Класс дробей с перегруженным оператором

Такую функцию можно вызывать непосредственно. Для этого тре-

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

tFraction Summ, Summand1, Summand2;

Summ = Summand1.operator+(Summand2);
Summ = Summand1 + Summand2;

Две последние строки идентичны. Первый операнд определяется

классом, чья элементная функция operator+(). Второй определяется
типом параметра. Тип возвращаемого значения функции operator+()
устанавливается в зависимости от типа переменной, которой присваи-
вается результат.

В следующем примере для класса tDate определен знак плюс. Нет

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

241
Глава 5

можно к некоторой дате прибавить определенное количество дней для

получения другого числа. Объявление и определение выглядит так:

class tDate
{
public:
tDate operator+(int Days);
};
tDate tDate::operator+(int Days)
{
// расчет даты
return *this;
}
Листинг 5.17. Перегрузка операторов

Сложение возвращает новую дату. В качестве правого операнда до-

пустимо использовать целое число. Так дата с помощью простого сложе-
ния может сместиться на 14 дней.

tDate today;
today = today + 14;
Листинг 5.18. Использование оператора

Возможно, вас посетила мысль, что строку today + 14 можно на-

писать иначе. Однако оператор += не определен. Было бы логично по-
требовать его создания, когда уже существует оператор +. Точно так же
дело обстоит и с оператором ++.

5.6.2. Глобальные операторные функции

Для класса дробей реализовано сложение, позволяющее исполь-

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

операторную функцию класса обозначить типом long. Но это, конечно,

недопустимо, поскольку long является базовым типом, а не классом.
Тем не менее можно добавить вместо этого глобальную операторную
функцию. У нее будет два параметра, и не составит никаких проблем
определить первый в качестве типа long.
tFraction operator+(long o1, const tFraction& o2)
{
tFraction summ;
summ.SetNumerator(o2.GetNumerator()+o1*o2.GetDenominator ());
summ.SetDenominator (o2.GetDenominator ());
return summ;
}
В таком случае для прямого доступа к элементам предлагается опре-
делять глобальную функцию в качестве «друга». Это показано в следу-
ющем листинге.
class tFraction
{
...
// глобальная функция operator+ может получить доступ к
// элементам
friend tFraction operator+(long one, const tFraction& two);
...
};
tFraction operator+(long one, const tFraction& two)
{
tFraction summ;
summ.numerator = two.numerator +one*two.denominator;
summ.denominator = two.denominator;
return summ;
}

5.6.3. Инкремент и декремент

Инкремент и декремент имеют две формы представления. В первой

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

243
Глава 5

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

а потом срабатывает оператор.
a = 5; a = 5;
b = ++a; b = a++;
// b==6 // b==5

Чтобы в операторе operator++ различать префиксную и постфикс-

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

class tFraction
{
tFraction& operator++(); // префикс
tFraction operator++(int); // постфикс
...
};
tFraction& tFraction::operator++()
// префикс-инкремент
{
// расчет новой дроби
// также можно использовать: *this = *this + 1;
numerator += denominator;
return *this;
}
tFraction tFraction::operator++(int)
// постфикс-инкремент
{
tFraction oldFraction =*this; // сохранено старое значение
numerator+=denominator; // увеличение переменной
return oldFraction; // возврат старого значения
}
Листинг 5.19. Инкрементирование с префиксом и постфиксом (fraction.cpp)

244
 Классы

Возвращаемое значение функции operator++ является результатом

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

5.6.4. Оператор присваивания

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

присваивания указан объект класса, в котором он реализован. Если
в классе не реализован оператор присваивания, объект при таком на-
писании будет скопирован побитно. Это прекрасно работает до тех пор,
пока класс не содержит указателей на внешнюю память. В таком случае
будет скопирован только указатель. Это приведет к тому, что оба объекта
после присваивания будут ссылаться на одну и ту же область внешней
памяти. Такая ситуация уже знакома вам по конструктору копирования
(см. стр. 233).

Рис. 5.2. Копирование объекта

Разница между конструктором копирования и оператором присваи-

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

Рисунок 5.2 отчетливо демонстрирует данную проблему. При копи-

ровании указатель также будет скопирован. Там, где указатель оригина-
ла содержит адрес на данные Data1, указатель целевого объекта после
присваивания также будет указывать на данные Data1. Предыдущая
245
Глава 5

область с Data2 останется в памяти без возможности доступа к ней. По-

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

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

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

Если объем внешней памяти источника и целевого объекта одина-

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

Чтобы знать, когда оператор присваивания должен быть вызван,

его нужно четко отличать от инициализации. Последняя всегда связана
с объявлением. В таком случае используется конструктор копирования
(см. стр. 233).

Также при передаче параметров и возвращении значения функции

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

Следующий пример рассматривает маленький класс tAuto, кото-

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

#include <iostream>
using namespace std;
class tAuto
{
public:
tAuto() { sign=0; Reader=4; }
~tAuto() { delete sign; sign = 0; }

246
 Классы

void SetSign(char *a);

char *GetSign () const { return sign; }
tAuto(const tAuto& k); // конструктор копирования
tAuto &operator=(const tAuto &k); // оператор
//присваивания
private:
// две приватные функции для работы со строками
int StringLength(char *s)
{
int len=0;
while (*s++) len++;
return len+1;
}
void StringCopy(char *source)
{
char *goal = sign;
while (*source) *goal++ = *source++;
*goal=0; // завершающий ноль
}
char *sign; // указатель на внешнюю память
int Reader; // нормальная переменная
};
// обычная запись номерного знака
void tAuto::SetSign(char *sn)
{
if (sign) delete sign; // память освобождена
int len = StringLength(sn); // определен размер
sign = new char[len]; // выделена новая область памяти
StringCopy(sn); // данные переданы
}
// конструктор копирования
tAuto::tAuto(const tAuto& s)
{
cout << " конструктор копирования " << endl;
int len = StringLength(s.GetSign ()); // размер?

247
Глава 5

sign = new char[len]; // выделение новой области памяти

StringCopy(s.GetSign ()); // передача данных
Reader = s.Reader; // копирование остальных данных
}
// оператор присваивания
tAuto &tAuto::operator=(const tAuto &s)
{
if (this != &s) // нет присваивания самому себе?
{
cout << "Присваивание:" << s.GetSign() << endl;
delete sign; // удалить старые данные
int len = StringLength(s.GetSign()); // размер?
sign = new char[len]; // выделить память
StringCopy(s.GetSign()); // передать данные
Reader = s.Reader; // скопировать остальные данные
}
return *this; // назад к текущему объекту
}
// для тестирования конструктора копирования и оператора //
присваивания
tAuto transfer(tAuto para)
{
cout << "Функция:" << para.GetSign() << endl;
return para;
}
int main()
{
tAuto Object;
tAuto goal;
Object.SetSign("HG-AW 409");
goal = transfer(Object);
cout << Object.GetSign() << endl;
cout << goal.GetSign() << endl;
}
Листинг 5.20. Определение оператора присваивания (assignment.cpp)

248
 Классы

В самом начале оператор присваивания проверяет, не происходит ли

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

После этой проверки оператор присваивания выполняет следую-

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

Оператор присваивания всегда имеет один параметр. Можно опре-

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

5.6.5. Оператор сравнения

Оператор сравнения возвращает значение типа bool. Для него, как

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

Даже без дополнительных мер два объекта можно сравнить между

собой оператором равенства. Код на языке C++ при этом побитно про-
веряет их равенство. Но такой метод сравнения иногда приводит к не-
верным результатам. Например, дроби 1/2 и 2/4 равны, однако вышео-
писанный метод этого не определит. При сравнении двух объектов типа
tDate день недели не учитывается. В итоге два дня отличаются между
собой только элементами Day, Month и Year, а не тем, рассчитан ли для
этой даты день недели. В тех случаях, когда класс содержит указатель,
ссылающийся на внешние данные, два неидентичных, но одинаковых по
содержанию объекта, никогда не будут равны между собой, поскольку
указатели ссылаются на различные участки памяти. Функция, написан-
ная самостоятельно, проверяла бы не равенство указателей, а равенство
данных, на которые они ссылаются.

Следующий пример демонстрирует оператор сравнения для класса

tFraction. Он заботится о том, чтобы дроби при сравнении сокращались.

249
Глава 5

bool tFraction::operator==(tFraction vgl)

{
short();
vgl.short();
return(numerator == vgl.numerator &&
denominator == vgl.denominator);
}
Листинг 5.21. Оператор сравнения для класса tFraction

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

и года. При сравнении классов с указателями будет сравниваться содер-
жимое памяти, на которую они указывают.
Операторы сравнения < и > выполняются по описанному образцу.
Особое значение имеет оператор «меньше». Он используется, к приме-
ру, в методе сортировки библиотеки STL и контейнере Map, который
записывает отсортированные объекты в файл для определения их по-
следовательности. В классе, который должен для этого использоваться,
следует определить знак сравнения «меньше».
Оператор равенства всегда должен быть реализован в паре с опера-
тором неравенства. Это не расточительство, ведь последнее легко опре-
делить через проверку первого.

class tFraction
{
...
bool operator==(tFraction op2);
bool operator!=(tFraction op2)
{
return !(*this == op2);
}
...
};
Листинг 5.22. Неравенство

Таким же образом через оператор >= можно определить оператор <.

250
 Классы

5.6.6. Оператор вывода

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

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

ostream& operator<<(ostream& Stream, const tFraction& B)

{
return Stream<<B.GetNumerator()<< "/" <<B.GetDenominator();
}
Листинг 5.23. Вывод дроби (fraction.cpp)

Поскольку параметр В объявлен в качестве константы, внутри функ-

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

Функции GetNumerator() и GetDenominator() определены далее

в качестве константных:

class tFraction
{
...
long GetDenominator() const {return denominator;}
long GetNumerator() const {return numerator;}
...
};
Листинг 5.24. Константные функции (fraction.cpp)

Также можно определить операторные функции в качестве «друзей»

класса. Тогда им будет разрешен доступ ко всем закрытым элементам.
Это определяет, что данные операторы также относятся к классу.
251
Глава 5

class tFraction
{
...
friend ostream& operator<<(ostream&, const tFraction&);
friend istream& operator>>(istream&, tFraction&);
...
};
ostream& operator<<(ostream& Stream, const tFraction& B)
{
return Stream << B.numerator << '/' << B.denominator;
}
Листинг 5.25. Константные функции (fraction.cpp)

5.6.7 Оператор индекса

Оператор индекса представлен в виде квадратных скобок, которые

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

#include <iostream>
using namespace std;
class tSafeString // класс строк с защищенным индексом
{
public:
tSafeString(int len) // максимальная длина строки
//должна быть установлена
{
maxLen = len;

252
 Классы

safestr = new char[len]; // запрос на выделение

//внешней памяти
mist = 0; // шаблон
}
~tSafeString()
{
delete[] safestr;
safestr=0;
}
char& operator[](int i);
// в настоящем классе должен быть реализован
//конструктор копирования и оператор присваивания
private:
char *safestr; // внешняя строка!
char mist; // шаблон для ошибочного доступа
int maxLen;
};
char& tSafeString::operator[](int i)
{
if (i<maxLen && i>=0)
{
return *(safestr+i); // буква найдена!
}
return mist; // возвращение 0 поскольку вернуть ссылку
//нельзя!
}
int main()
{
tSafeString str(6); // 6 знаков, от 0 до 5
str[5] = 'A'; // записать
char c = str[5]; // прочесть
cout << c << endl; // тест, является ли символ действительно
//буквой A
}
Листинг 5.26. Хранитель строк (safestr.cpp)

253
Глава 5

Пока индекс имеет корректное значение, операторная функция

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

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

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

Параметр operator[]() не обязательно должен быть целым числом.

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

AutoSign["HH"] = "Hansestadt Hamburg";

По такому же принципу работает контейнер STL map (см. стр. 430).

5.6.8. Оператор вызова ()

Оператор вызова позволяет обратиться к объекту класса в качестве

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

Например, в библиотеке STL функция find_if() (см. стр. 441) при-

нимает параметр, который вызывает функцию, возвращающую логиче-
ское значение. Так очень удобно производить поиск объекта. Условие

1
Бьерн Страуструп. Язык программирования С++. М.: Бином, 2011.

254
 Классы

устанавливается в функции. Но если она должна иметь память, напри-

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

Следующий класс tCallMe представляет собой такой объект.

class tCallMe
{
public:
int operator() (int)
{ /* сделать что-нибудь */ }
...
};
Листинг 5.27. Оператор вызова

Использование этого оператора выглядит совершенно так же, как

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

tCallMe Call(23); // вызов конструктора

...
Call(23); // оператор вызова
Листинг 5.28. Оператор вызова

5.6.9. Оператор конвертирования

Чтобы чужой тип преобразовать в объект собственного клас-

са используется конструктор конвертирования, который уже описан
на стр. 222.

Функция преобразования не имеет объявленного возвращаемого

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

255
Глава 5

полагается пара пустых скобок, поскольку функция преобразования не

имеет параметров. Она возвращает выражение целевого типа.

Было бы логично дополнить класс tFraction функцией преобразо-

вания, которая из дроби создает числа с плавающей запятой:
class tFraction
{
public:
operator double()
{
return double(numerator)/double(denominator);
}
...

5.7. Атрибуты
Атрибуты static и const уже были рассмотрены в связи с перемен-
ными. Применительно к классам они имеют несколько иное значение.

5.7.1. Статические переменные и функции в классах

Статические элементные переменные в классах имеют мало общего

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

В такой переменной можно хранить количество активных объектов.

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

Статическая элементная переменная объявляется точно так же, как

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

256
 Классы

class StatClass
{
...
static int Numerator;
};

Статическая переменная класса не может быть инициализирована

в конструкторе, поскольку тогда при создании нового объекта ее значе-
ние будет установлено заново. Вместо этого она определяется в качестве
глобальной переменной, которая указывается после имени класса. Та-
ким образом, она может также сразу быть инициализирована:
int StatClass::Numerator = 0;

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

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

#include <iostream>
using namespace std;
class StatClass
{

257
Глава 5

public:
StatClass() {Numerator++;}
~StatClass() {Numerator--;}
static int HowMuch() {return Numerator;}
private:
static int Numerator;
};
int StatClass::Numerator=0;
int main()
{
cout << StatClass::HowMuch() << endl;
StatClass field[4];
cout << StatClass::HowMuch() << endl;
{
StatClass field[5];
cout << StatClass::HowMuch() << endl;
}
cout << StatClass::HowMuch() << endl;
}
Листинг 5.29. Статические переменные и функции в классах (statclass.cpp)

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

массива из четырех элементов класса StatClass его конструктор будет
вызван четыре раза. Массив field будет определен еще раз во внутрен-
нем блоке и тем самым перекроет внешний массив field, который хотя
и недоступен в этот момент, тем не менее продолжает существовать. Затем
в блоке создается девять элементов. После того, как программа покинет
блок, внутренний массив освободится. Для каждого элемента будет вы-
зван деструктор. Программа возвратит соответственно числа 0, 4, 9 и 4.

5.7.2. Константы

Указатели и ссылки особенно часто определяются в качестве кон-

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

258
 Классы

предоставить ни прямой, ни косвенный доступ к элементам данных вну-

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

ostream& operator<<(ostream& Stream, const tFraction& B)

{
return Stream << B.GetNumerator() << "/"
<< B.GetDenominator();
}
Листинг 5.30. Вывод дроби (fraction.cpp)

Внутри функции для константных параметров вызывается эле-

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

Константные функции

Чтобы компилятор был уверен, что ни одна из вызываемых функ-

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

class tFraction
{
...
long GetDenominator () const {return denominator;}
long GetNumerator () const {return numerator;}
...
};
Листинг 5.31. Константные функции (fraction.cpp)

259
Глава 5

Только когда вызываются константные функции и элементные пе-

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

К рассмотрению вопроса о том, остается ли объект класса констант-

ным, привлекаются все переменные. В некоторых случаях класс имеет
элементные переменные, для которых не важно, изменяются ли они
в объекте. Так, например, элемент данных WeekDay класса tDate не вли-
яет на дату.

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

Инициализация констант

Константы могут объявляться внутри классов даже в том случае,

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

Присваивание в конструкторе также не работает, поскольку проис-

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

class tConstant
{
public:
const int MaxBuffer;
tConstant() : MaxBuffer(500) {}
tConstant(long size);
};
tConstant::tConstant(long size): MaxBuffer(size)
{

Инициализатор всегда устанавливается при определении функции

конструктора, но не при его объявлении.
260
 Классы

5.8. Наследование
Информатика полна аналогий. Так, в объектно ориентированном
программировании используется понятие «наследование», когда класс
является производным от другого класса и перенимает его свойства.

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

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

мерки вставляется в производный класс, такая форма повторного ис-
пользования кода не несет никакого риска.

За счет элементов, которые определяются в производном классе,

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

С точки зрения компьютерной программы все личности имеют име-

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

Для определения этой структуры создается исходный обобщен-

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

261
Глава 5

В данном случае эти отношения типа «является». Клиент «явля-

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

Рис. 5.3. Классы личностей

От какого класса наследуется новый, в языке C++ определяется сле-

дующим образом: при определении класса после ключевого слова class
и его имени указывается двоеточие, затем следует ключевое слово public
и имя базового класса. Чтобы не разрабатывать общие свойства для каждой
группы личностей заново, сначала создается базовый класс Person. Каждая
группа личностей может быть производной от класса Person и наследовать
все его свойства. Что общего есть у классов, определено в классе Person.
Страховка требуется только для сотрудников. Только клиент имеет адрес
доставки. Если требуется управлять поставщиками, можно также позаим-
ствовать тип Person. Поставщик наследует все от личности и имеет еще
некоторые отдельные свойства, как, например, список открытых счетов.

262
 Классы

class Person
{
public:
string Name, Address, Telephone;
};
class Partner : public Person
{
public:
string Kto, BLZ;
};
class employee : public Partner
{
public:
string health_insurance;
};
class customer: public Partner
{
public:
string deliver_address;
};
class supplier : public Partner
{
public:
tOpenPost *bills;
};
class out_duty : public employee
{
public:
tBlock Block;
};
Листинг 5.32. Личности

Открытые производные классы, которые полностью перенимают ин-

терфейс базового, совместимы с присваиванием. Объект типа employee
может быть присвоен объекту типа Person. Однако после присваива-

263
Глава 5

ния информация о страховке и банковском счете будет потеряна. Ско-

пированный объект не имеет расширенной информации производного
класса. Указателю на базовый класс можно присвоить адрес объекта
производного класса. В этом случае объект не потеряет информацию,
поскольку он не был изменен. В обратном порядке это не работает —
объекту производного класса нельзя присвоить объект базового.
Person person;
employee Employee;
person = Employee; // ok
Employee = person; // это не понравится компилятору

Если написан класс tDate, который нужно вставить в календарь, то

требуется определить праздничные дни.С точки зрения календаря они
отличаются тем, что каждый праздник имеет название. Можно, конечно,
присвоить название каждой дате. Однако большинство дней не являют-
ся праздниками. Лучше создать производный класс tHoliday и доба-
вить ему название.

class tHoliday : public tDate

{
public:
char Name[40];
};
...
tHoliday Easter;
Ostern.Day = 25;
Ostern.Month = 4;
Листинг 5.33. Праздник

С объектом Easter можно работать точно так же, как и с объектом

tDate. Класс tHoliday наследует все свойства класса tDate и добавляет
только одну отличительную характеристику — «праздник».

Важное преимущество состоит в том, что не нужно менять класс

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

264
 Классы

тому, что пользователь базового класса не обязан использовать его код,

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

5.8.1. Доступ к предкам

К элементу класса обычно могут получить доступ только элемен-

ты того же класса. Элементы, которые должны быть доступны другим
классам, определяются как public. Это действует и при наследовании.
Производный класс не может получить доступ к приватным элемен-
там базового, но ко всем открытым — легко, как к своим собственным.
Через наследование возможен еще один вид доступа, помимо private
и public, — это protected., Доступ к таким элементам могут получить
только производные классы.

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

дование.

protected

Помимо прав доступа private и public, наследование предлагает

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

class Basis
{
private:
int private;
protected:
int protect;
public:
int public;
};
class successor : public Basis
{
public:
void access()

265
Глава 5

{
a = private; // это приведет к ошибке!
a = protect; // это работает
a = public; // это работает в любом случае
}
};
int main()
{
Basis myVar;
a = myVar.private; // это, конечно же, не работает
a = myVar.protect; // это тоже
a = myVar.public; // это работает
}
Листинг 5.34. Ключевое слово protected

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

ему элементам базового класса, как это показано в следующем примере:

class Basis
{
private:
int private;
protected:
int protect;
public:
int public;
};
class successor : public Basis
{
protected:
using Basis::public;
public:
using Basis::protect;
};
266
 Классы

int main()
{
successor a;
b = a.protect; // о чудо, это работает!
}
Листинг 5.35. Изменение типа доступа

Подобный подход редко можно встретить на практике уже потому,

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

Атрибуты доступа при наследовании

До этого мы рассматривали только производные, перед именем ко-

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

 Открытые элементы базового класса в производном классе с атри-

бутом private становятся закрытыми.

class Basis
{
private:
int private;
protected:
int protect;
public:
int public;
};
class successor : Basis // осторожно: это private!
{
public:
267
Глава 5

int f1() { return private; } // так не работает!

int f2() { return protect; } // так работает
int f3() { return public; } // так работает
};
int main()
{
successor a;
Basis b;
i = a.public; // это неверно!
i = b.public; // это функционирует безупречно
b = a; // это снова не работает
}
Листинг 5.36. Закрытое наследование

Класс-наследник с атрибутом private, как приведенный в данном

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

protected

Класс-наследник с атрибутом protected не отличается в правах до-

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

Элементы базовых классов

При создании производного класса элементы базового класса наследу-

ются. Когда элементы определены как public или private, к ним можно
получить доступ внутри производного класса точно так же, как к собствен-

268
 Классы

ным. Если определяется элемент в классе-наследнике, и это имя уже ис-

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

class tBasis
{
public:
int doSmth(int a);
};
class tSpecialCase : public tBasis
{
public:
int doSmth(int a);
};
int tSpecialCase:: doSmth(int a)
{
int oldValue = tBasis:: doSmth(a);
...
return oldValue;
}
Листинг 5.37. Вызов функции базового класса (kasfunc.cpp)

В примере функция doSmth() в классе tSpecialCase сначала вы-

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

5.8.2. Конструкторы и присваивание

Прежде чем будет выполнен конструктор в производном классе, за-

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

269
Глава 5

логично, поскольку производные классы надстраивают собственные

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

Если классы наследуются от некоторого базового класса, у которо-

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

class tBasis
{
public:
tBasis(int i); // нет стандартного конструктора
};
class tSpecialCase : public tBasis
{
public:
tSpecialCase() : tBasis(5) // вызван базовый
//конструктор
{
...
}
};
Листинг 5.38. Вызов конструктора (kaskonstrukt.cpp)

Создание объекта типа tSpecialCase вызывает стандартный кон-

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

270
 Классы

конструктор базового класса tBasis. Но его не существует. С помощью

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

Конструктор копирования

Если базовый класс имеет конструктор копирования, он не будет ав-

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

tSpecialCase(const tSpecialCase& object) :tBasis(object)

{
...
}

Оператор присваивания

Оператор присваивания также не наследуется автоматически. Обыч-

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

tSpecialCase& operator=(const tSpecialCase& object)

{
if (this!=&object)
{
// не допускать собственного копирования!
tBasis::operator=(object);
// присваивание некоторых элементов
}
return *this;
}

5.8.3. Многократное наследование

В языке C++ возможно наследование от нескольких базовых клас-

сов. При этом они после двоеточия перечисляются через запятую со все-
ми своими атребутами.

271
Глава 5

class Auto : public Motor, public Carriage

{
...
};

Класс Auto наследует все свойства и функции классов Motor

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

class Auto : public Motor, public Carriage

{
...
a = Motor::Camp;
...
b = Carriage::Camp;
...
};

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

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

5.8.4. Полиморфизм посредством виртуальных

функций

В химии полиморфизм означает разнообразие кристаллов, а в био-

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

Производные классы наследуют функции базовых. Если функция

класса не подходит своей функциональностью классу-наследнику, ее

272
 Классы

можно переписать, и она будет перекрыта для всех объектов произво-

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

#include <iostream>
using namespace std;
class Bass
{
public:
void boom() { cout << "Bass" << endl; }
};
class Tuba : public Bass
{
public:
void boom() { cout << "Tuba" << endl; }
};
int main()
{
Tuba tuba.boom();
Bass bass.boom();
}
Листинг 5.39. Пример — музыка

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

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

категории. Но к нам на помощь приходит тот факт, что при открытом
наследовании производные классы совместимы с базовыми. Так объект
tuba может быть передан в качестве аргумента функции, которая ожи-
дает в качестве параметра объект типа Bass, поскольку туба в целом яв-
ляется басом. Речь здесь не может идти о копировании или присваива-

273
Глава 5

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

Расширим задачу функцией DoThis(). В качестве параметра ей бу-

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

#include <iostream>
using namespace std;
class Bass
{
public:
virtual void boom() { cout << "Бас" << endl; }
};
class Tuba : public Bass
{
public:
void boom() { cout << "Туба" << endl; }
};
void DoThis(Bass *tute)
{
tute->boom();
}
int main()
{
Tuba tuba;
Bass bass;
DoThis(&bass);
DoThis(&tuba);
}
Листинг 5.40. Пример — музыка

Если запустить программу, на экране сначала появится слово «Бас»,

а затем слово «Туба». Рассматривая листинг подробнее, станет понятно,

274
 Классы

что перед элементной функцией boom() у класса Bass указано ключевое

слово virtual.

Если убрать слово virtual, можно установить, что на экране дваж-

ды будет выведено слово «Бас». Очевидно, что компилятор при пере-
воде кода уже связывает функцию звучания баса с передаваемой тубой.
Здесь речь идет о «предварительном связывании». Компилятор узнает
внутри функции только объект указателя на тип Bass. Соответственно,
связь с элементной функцией Bass будет установлена при компилиро-
вании.

После объявления элементной функции boom() в базовом клас-

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

Ключевое слово virtual оповещает компилятор, что объект несет

ответственность за то, какая функция будет вызвана. Если в DoThis()
вызывается функция звучания, передаваемый объект берет ее вызов на
себя. При выполнении программы так сообщается об объекте Tuba.

Чтобы сделать возможным позднее связывание, во время выполне-

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

Пример: фирма
Вернемся еще раз к классу Person и его производным, которые были
созданы на стр. 261 в теме «Наследование».

Используется базовый класс Person. Его производными являются

customer, employee и supplier. Также здесь присутствует функция,
которая разным способом обрабатывает классы. Так, платежи всегда
одинаковы, — должен быть произведен банковский перевод. Для это-
го требуются специфические процессы. Например, платеж сотрудни-

275
Глава 5

ку, ожидающему в этом месяце определенную сумму зарплаты, должен

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

class Person
{
public:
virtual void payment(float money);
};
class employee : public Person
{
public:
virtual void payment(float money);
};
class customer : public Person
{
public:
virtual void payment(float money);
};
class supplier : public Person
{
public:
virtual void payment(float money);
};
void Payment(Person &Man, float Summ)
{
Man.payment(Summ);
}
int main()
{
supplier Ivanov, Stepanov;

276
 Классы

customer Kuznecov;
employee Vladimirov;
Payment(Ivanov, 100);
Payment(Stepanov, 100);
Payment(Kuznecov, 100);
Payment(Vladimirov, 100);
}
Листинг 5.41. Платеж

Функция payment() объявляется с ключевым словом virtual как

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

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

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

В главной функции main() определяются только четыре персоны:

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

Важно, чтобы передача персоны осуществлялась ссылкой. Если бы

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

277
Глава 5

работать с оригиналом, поскольку только оригинал «знает», что он за

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

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

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

Такое расширение при использовании полиморфизма приводит

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

Если возможно расширение с помощью полиморфизма, то это зна-

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

Таблица виртуальных методов

Виртуальные функции реализуются в компиляторе чаще всего

в виде массива, который содержит в себе указатели на все виртуальные
функции. Чаще всего он обозначается как VTable или vtbl.

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

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

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

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

Если вызывается функция полиморфного объекта, через указатель

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

278
 Классы

разница во времени выполнения едва ли заметна. Так Рихард Кайзер1

демонстрирует, что при вызове 100 миллионов пустых функций, вирту-
альные функции требуют 3,69 секунд, а обычным на это требуется 3,03
секунды.

Таким образом, виртуальные функции в целом на шесть миллисе-

кунд на миллион вызовов медленнее. На практике это не может играть
роли.

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

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

Виртуальный деструктор

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

с виртуальными функциями должен иметь виртуальный деструктор.
Как было показано выше, производный класс Tuba обращается к клас-
су Bass через указатель. Если через такой указатель вызвать команду
delete, то обычный (не виртуальный) деструктор освободил бы только
составные части класса Bass, но не достиг бы класса Tuba.

В этом простом примере все остальное не существенно. Если бы

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

Абстрактные базовые классы

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

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

Можно возле класса Bass написать длинный комментарий о том, что

никто не должен создавать объект такого класса. Но можно предотвра-
тить это с помощью компилятора. Для этого нужно присвоить вирту-
альной функции значение 0. Это означает, чтоона не может быть реали-
зована, поэтому нельзя создать объекты данного класса.
1
Keiser Richard. C++ mit dem Borland C++ Builder. Springer, Berlin Heidelberg, 2002.

279
Глава 5

class Bass
{
public:
virtual void boom() = 0;
};
Листинг 5.42. Абстрактный базовый класс

Такая элементная функция, как boom() называется «чисто виртуаль-

ной», а класс Bass — «абстрактным базовым классом». Нельзя постро-
ить ни одного объекта данного класса. Можно только создавать классы,
производные от него. При этом класс Bass определяет категорию ин-
струментов, которые имеют общие свойства.

Абстрактные базовые классы создаются, чтобы определить обяза-

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

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

иногда имеет смысл1. Некоторые авторы утверждают, что наследование
классов без полиморфизма является не объектно ориентированным,
а объектно-базисным программированием. Другие авторы обозначают
1
Keiser Richard. C++ mit dem Borland C++ Builder. Springer, Berlin Heidelberg, 2002.

280
 Классы

использование классов без участия наследования как объектно-базисное.

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

Полиморфизм на практике
При изучении полиморфизма иногда создается впечатление, что его
можно использовать только в редких, очень конструктивных случаях.
Но это совершенно не верно. Многие библиотеки классов вообще не-
мыслимы без полиморфизма. Особенно много классов приложений,
окон и диалоговых окон они предлагают для графических интерфейсов.
Чтобы вставить в приложение окно или диалоговое окно, следует соз-
дать на основании базовых классов собственные и добавить элементы,
которые отличают вашу программу от стандартного шаблона.
Как пример представляется класс CDialog класса MFC (Microsoft
Foundation Classes). Диалоговый класс сам по себе — особый случай
окна и является производным от класса CWnd. Если вы хотите создать
для своей программы собственное диалоговое окно, операционная си-
стема проинформирует вас обо всех событиях, которые произойдут
в связи с этим. Большинство из них вас вообще не интересует, они мо-
гут рассматриваться классом CDialog. Прежде всего вас интересуют
три события. Первое — это открытие диалогового окна. Как только оно
открывается, программа должна инициализировать контрольные эле-
менты, например, заполнять Listbox. Второе событие — это нажатие
пользователем кнопки OK, что означает подтверждение правильности
содержимого диалогового окна. В этот момент нужно прочесть содер-
жимое контрольных элементов и передать его переменным програм-
мы. Третье событие наступает, когда пользователь завершает диалог
клавишей Esc. В данном случае не существует длительной обработки
каких-либо данных, но программа хочет знать, не передумал ли поль-
зователь.
Для обработки этих трех событий класс CDialog предлагает элемент-
ную функцию OnInitDialog() для старта диалогового окна, функцию
OnOK() для нажатия клавиши OK и функцию OnCancel() для обработки

281
Глава 5

выхода из программы. Они вызываются полиморфно, если происходит

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

class tMyDialog : public CDialog

{
BOOL OnInitDialog();
void OnOK();
void OnCancel();
...
};
Листинг 5.43. Наследование диалога

Функции класса CDialog реализуют соответствующую функцио-

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

BOOL tMyDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// создание собственного диалога
...
}
Листинг 5.44. Диалоговая инициализация

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

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

282
 Классы

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

5.9. Определение классов

и синтаксический граф
В этом месте мы еще раз охватим синтаксис определения класса. Для
лучшей наглядности используется синтаксический граф (рис. 5.4).

Рис. 5.4. Граф синтаксиса для определения класса

Определение класса всегда начинается со слова class. Затем сле-

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

Рис. 5.5. Граф синтаксиса для списка базовых классов

Если называется базовый класс, следует также указывать, проис-

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

283
Глава 5

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

умолчанию, этот атрибут имеет значение private. На рис. 5.6 отобра-
жен синтаксический граф для элементов определения класса.

Рис. 5.6. Граф синтаксиса для элементов класса

• Доступ
С помощью ключевых слов public, private и protected обознача-
ется тип доступа к элементам. Если указание такого рода отсутству-
ет, то по умолчанию все элементы private.
• Объявление переменных
Этим устанавливаются элементы класса. Объявление переменных
здесь не отличается от их объявления, например, в функциях. В не-
которых случаях инициализация проводится не объявлением, а с по-
мощью конструктора.
• Объявление функций
Если функция полностью определяется в классе, она компилирует-
ся в качестве встроенной (см. стр. 183).
• Определение функций
В большинстве случаев элементные функции только объявляются
внутри определения класса. Это означает, что определяются они
в другом месте.
• Объявление абстрактных функций
В отличие от обычной, абстрактная функция является виртуальной
и может быть инициализирована 0.
 Глава 6
ИНСТРУМЕНТЫ
ПРОГРАММИРОВАНИЯ
Абсолютно все равно, насколько хорошо вы знаете
язык, без компилятора и компоновщика нельзя
создать программу.

Большинство книг по языку C++ не рассматривают вызов компи-

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

6.1. Компилятор C++

В операционных системах типа Linux используется компилятор С++
из пакета GCC, GNU Compiler Collection. Как правило, его нужно уста-
навливать отдельно. Компилятор можно получить в комплекте с любой
операционной системой. Сюда относятся распространенные версии
UNIX, такие как Solaris, HP-UX, AIX и OS X. В операционную систему
Windows данный компилятор уже встроен. Он также входит в состав бес-
платной среды Cygwin, которая обеспечивает тесную интеграцию прило-
жений, данных и ресурсов Windows с приложениями, данными и ресур-
сами UNIX-подобной системы. Кроме того, GNU-компилятор доступен
в составе интегрированной среды разработки Bloodshed Dev-C++. Этот
компилятор подтверждает свою надежность тем, что является централь-
ным инструментом при разработке продуктов с открытой лицензией.

6.1.1. Вызов компилятора

Компилятор вызывается командой g++. В качестве параметра пере-

дается имя файла программного кода.
g++ myprogramm.cpp

285
Глава 6

Если программа не содержит ошибок, через мгновение на экране

возникнет запрос на ввод данных. Компилятор сообщит о себе только
в том случае, если ему что-то не понравится в коде. Он переводит про-
грамму в машинный язык и компилирует ее. Результат этого процесса
записывается в файл a.out. Это стандартное имя для исполняемого фай-
ла. В операционной системе Linux его можно вызвать, введя в команд-
ной строке точку, слеш и имя файла.
./a.out

Если вам оно не нравится, можно с помощью дополнительного свой-

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

В данном случае, свойство выглядит как -o, поскольку речь идет

о выводе (от англ. output). Затем следует имя файла. Если файл должен
носить имя, например, myprogram.exe1, команда будет иметь вид:
g++ -o myprogram.exe myprogram.cpp

6.1.2. Свойства компилятора

В системе UNIX компилятор GNU Compiler имеет набор свойств.

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

Самые важные свойства при вызове компилятора:

• -o имя файла
Файл выходных данных называется имя файла.
• -c имя файла
Компилирует один-единственный источник кода, состоящий из
имени файла и расширения .о.
• -IПуть
Дополняет путь, в котором будет происходить поиск имени файла.
• -LПуть
Дополняет путь, по которому будет происходить поиск библиотек.

1 Расширение .exe не является обязательным для Linux. Однако оно и не мешает.

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

286
 Инструменты программирования

• -lИмя
(строчная l) Использует библиотеку libИмя.а. Поиск файла будет
выполняться по стандартному пути (например /usr/lib) и по допол-
нительному пути -L.
• -g
К коду добавляется информация для отладчика. Так можно в отлад-
чике обратиться к переменным и функциям по их именам.
• -DИмя
С помощью этого свойства можно определить имена. Такая коман-
да равнозначна #define. Если имени требуется присвоить значение,
следует указать -DИмя=Значение.

6.1.3. Сообщения об ошибках

Является скорее правилом, нежели исключением, то, что программа

содержит ошибки. В лучшем случае они настолько явные, что их замеча-
ет компилятор. Здесь приведены сообщения об ошибках GNU Compiler.
Другие компиляторы могут выводить другие сообщения, но в целом они
аналогичны.

Сообщения об ошибках от компилятора

Компилятор различает два вида сообщений. Первый — это ошибки.

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

main.cpp:33: Warning: не скомпилированный параметр «signalNr»

main.cpp: в функции >>int main(int, char**)<<:
main.cpp:174: Warning: Переменная "db" не используется
main.cpp:157: Error: >>Element<< не определен в данной области
действия

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

Затем следует номер строки, для того чтобы можно было найти место
287
Глава 6

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

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

• Неиспользуемая переменная
Если переменная определена, но ни разу не используется, компи-
лятор «удивится подобному расточительству», и сообщит об этом.
Такого же мнения он будет, если переменной в программе только
присваивается некоторое значение, и больше ничего. Эти предупре-
ждения помогают навести порядок в коде, если после значительных
изменений остаются лишние переменные.
main.cpp:161: Ошибка: >>class Database<< не имеет элемен-
тов с именем "writeURL"
• Отсутствует элемент класса
В этом случае компилятору также не хватает определения. Он мо-
жет отметить, что функция writeURL() хоть и обрабатывается в ка-
честве элемента класса Database, однако не определена в нем.
• …expected/ожидается
Сообщение об ошибке, которое содержит слово «ожидается», или
его английский вариант «expected», указывает, что компилятор не-
сколько удивлен обнаружением определенного элемента в этом ме-
сте. Следующее сообщение появилось по причине отсутствующей
скобки в операторе if.
Queue.cpp:30: Ошибка: expected '(' before >>myValue<<
288
 Инструменты программирования

Иногда ожидаемые элементы могут быть неочевидны. Это проис-

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

Ошибки компоновщика
Если компилятор удовлетворен исходным кодом, в действие всту-
пает компоновщик. Его задача — из отдельных модулей и библиотек
составить полноценную программу. Соответственно, его ошибками, как
правило, являются отсутствующие функции или глобальные перемен-
ные, которые обещаны в заголовочном файле перед реализацией.
/home/arnold/src/cpp/main.cpp:181: undefined reference
to 'Queue::getInstance()'
Сообщение указывает, что член-функция getInstance() класса
Queue не определена, хотя и вызывается в файле main.cpp в строке 181.
Причины таких ошибок могут быть следующее:
• Если при обработке кода компилятором уже было выдано предупре-
ждение, то имя функции может быть неверно написано или отсут-
ствовать команда #define
• Библиотека не подключена. В интегрированной среде разработки
библиотеки должны подключаться в настройках проекта, если они
не являются стандартными. При использовании инструмента make
(см. стр. 309) или при прямом вызове командной строкой, перед име-
нем библиотеки должно быть указано свойство -l (строчная буква L).
• Библиотека располагается в каталоге, где компоновщик не ищет би-
блиотеки. Если библиотека не расположена по стандартному пути,
ее каталог должен быть внесен в настройки проекта или указан в ко-
мандной строке компилятора со свойством -L.
• Компоновщик привязывает библиотеки только тогда, когда суще-
ствует открытое указание это делать. При этом компоновщик ра-
ботает быстро, а код программ становится короче, но программист
должен следить, чтобы зависимые друг от друга файлы вызывались
компоновщиком в правильной последовательности.

6.2. Препроцессор
Препроцессор унаследован от языка C. Перед тем, как компилятор
получает исходный текст программы, его просматривает препроцес-

289
Глава 6

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

торпа (#).

6.2.1. Связывание файлов: #include

Почти во всех листингах вам уже встречалась команда для привяз-

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

Следующие за ключевым словом имена файлов обычно размеща-

ются в кавычках или в угловых скобках. При этом кавычки означают,
что поиск файла будет проводиться в списке исходных файлов. Угло-
вые скобки указывают на то, что речь идет о стандартном подключении,
как например заголовок стандартной библиотеки. Компилятор может
найти ее в четко установленном каталоге. Для систем UNIX это /usr/
include. Для системы Windows не существует стандарта. Поэтому файлы
заголовков помещаются в поддиректорию компилятора. Он определяет
это место при установке. Список каталогов, где будет производиться по-
иск заголовочных файлов, имена которых указаны в угловых скобках,
можно расширить с помощью свойства компилятора -I.

При указании файлов после команды #include можно также ис-

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

6.2.2. Константы и макросы: #define

С помощью команды #define определяется имя. При этом речь идет

в некотором роде о препроцессорных переменных. С переменными языка
C++ они не имеют ничего общего. Эти имена могут быть позднее опроше-
ны командой #ifdef. Следующая команда определяет имя DEBUGCODE.

#define DEBUGCODE

Определенному имени может соответствовать некоторая констан-

та. Для этого она располагается после имени. Следующее определение
устанавливает VERSION в 5.

290
 Инструменты программирования

#define VERSION 5

В старых компиляторах языка C это была единственная возмож-

ность задать константу. В языках ANSI C и C++ появилось ключевое
слово const, которое более рекомендуется к использованию.

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

срабатывает до вызова компилятора. Следующий вызов компилятора
GNU Compiler также устанавливает имя VERSION в 5.

g++ -DVERSION=5 unix.cpp

Первый знак такого определения не может быть знаком подчеркива-

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

Макрос
Возможности препроцессора заходят дальше. Он позволяет создать
нечто наподобие маленькой функции. Следующая команда #define
определяет квазифункцию ADD(), которая складывает два передавае-
мых значения.

#define ADD(a, b) ((a) + (b))

Такое определение называется макросом. В макросе с параметрами

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

Макрос отличается от обычной функции тем, что вставляется пре-

процессором в код программы. Это дает небольшой выигрыш в скоро-
сти по сравнению с вызовом функции.

При использовании макросов имеется подводный камень, — его

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

#define FALSEINCR(a) a + 1
...
int i = FALSEINCR(4) * 2;
Листинг 6.1. Неожиданный результат

291
Глава 6

Препроцессор просто вставляет код макроса в позицию его вызова

и устанавливает значение переменной a равным 4. При этом получается
следующая строка:

int i = 4 + 1 * 2;

Но результатом будет не 10, как это, возможно, ожидалось, а 6. При

добавлении скобки макровставка может привести к необычным эффек-
там. Рассмотрим в следующей строке переменную Number, и подумаем,
какое содержимое она получит после выполнения этого кода.

#define SQUARE(a) ((a)*(a))

...
int Number = 5;
Value = SQUARE(++Number);
Листинг 6.2. Неожиданный результат

Переменная Value в итоге будет иметь значение 49. Причина в том,

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

Проблема состоит в следующем: обычно программист ожидает, что

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

Способность препроцессора вставлять код может быть полезна для

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

#define BEGIN {
#define END }

С точки зрения оформления программы такая возможность может

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

292
 Инструменты программирования

Однажды определенное имя может быть разыменовано с помощью

команды #undef.

#undef DEBUGCODE

6.2.3. Опросы: #if

Определение DEBUGCODE может быть использовано для того, что-

бы преобразовывать код при компилировании только тогда, когда имя
определено. Для этого используется команда #if. Аргументом служит
функция define(), которая получает имя в качестве параметра, и про-
веряет, определено оно или нет.

#if defined(DEBUGCODE)
...
#endif

Полный исходный код между двумя командами будет показан ком-

пилятору только тогда, когда определено имя DEBUGCODE. Для крат-
косрочного комментирования больших частей кода такой конструктор
очень полезен. Поскольку он часто используется, существует его сокра-
щенное написание — # ifdef.

#ifdef HUHU
// разные команды
/* также с комментариями */
#endif

После вставки команды весь закомментированный код будет по-

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

Можно не только проверять, было ли определено имя, но и исполь-

зовать его содержимое. В следующем примере опрашивается, является
ли значение MAX меньше 10.

#if MAX<10

293
Глава 6

Как и при использовании обычной команды if, можно связывать вы-

ражения с помощью && и ||. Также препроцессор знает команду #else
и комбинацию команд if и else: #elif.
#if MAX<10
...
#elif MAX==10
...
#else
...
#endif

6.2.4. Предопределенные макросы

Препроцессор знает некоторые предварительно определенные макро-

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

Таблица 6.1. Стандартные макросы

Макрос Определение
_LINE_ Текущая строка кода источника
_FILE_ Имя файла источника
_DATE_ Текущая дата в формате ММ\ДД\ГГГГ
_TIME_ Текущее время в формате чч:мм:сс

Некоторые макросы установлены компилятором. Так, например,

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

Таблица 6.2. Системные макросы

Макрос Определение
unix UNIX-системы, в т.ч. и Linux
_MSDOS_ MS DOS
_Windows MS Windows

В следующем примере системный вызов fork(), который доступен

только в операционной системе UNIX, будет скомпилирован лишь тог-
да, когда целевая машина работает под управлением UNIX.

294
 Инструменты программирования

#ifdef __unix__
fork();
#endif

Производители компиляторов кодируют версии компиляторов в ма-

кросах. Так Borland C++ Builder для кодирования номера его версии ис-
пользует макрос _BCPLUSPLUS_. Этим можно пользоваться, если требу-
ется применять механизмы, которые доступны только в новых версиях.
#if __BCPLUSPLUS__ >= 0x530
// работает под C++ Builder начиная с версии 3.0
#endif

Хотя многие компиляторы определяют этот макрос, для предот-

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

Макрос _cplusplus для всех компиляторов языка C++ обязательно

определен в файле stdlib.h. Если компилятор совместим со стандартом
ANSI, макрос возвращает шестизначный номер. В противном случае —
пятизначный. Компиляторы языка C вообще не имеют этого макроса.
Так можно было бы написать программу, которая скрывает расширен-
ные возможности языка C++ от компилятора языка C. Следующий
пример реализует функцию min() в качестве шаблона, если речь идет
о компиляторе языка C++. В противном случае определяется макрос.
#ifdef __cplusplus
template <class T> T min(T a, T b) { return a<b?a:b; }
#else
#define min(a,b) a>b?b:a
#endif

6.2.5. Другие препроцессорные команды

Команда #line изменяет счетчик строк. Следующая команда уста-

навливает номер текущей строки равным 2000.
#line 2000

С помощью команды #error можно остановить компиляцию. По

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

#error
#error Код, который потом будет выведен

Команда #pragma используется для того, чтобы компилятор мог вве-

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

6.3. Разделение исходного кода

• Если исходный код программы содержит несколько классов, для
легкости прочтения логичнее разделить его на несколько файлов.
В то время как язык Java предписывает программисту использовать
для каждого класса отдельный файл исходного кода, в языке C++
вопрос о разделении программы на части остается на усмотрении
программиста. Ниже приведены некоторые причины разделять код
программы на несколько файлов. В объемном коде сложно найти
определенные классы или функции. Разделение облегчает поиск.
Файлы должны носить соответствующие имена и быть легко читае-
мыми.
• При разработке программы командой программистов следует избе-
гать ситуаций, когда два программиста работают с одним файлом,
при этом один будет нарушать изменения второго и наоборот. Чем
лучше исходный код программы разделен на файлы, тем меньше
риск, что они будут друг другу мешать.
• Файлы должны компилироваться только тогда, когда они были из-
менены. Чем больше файлов могут оставаться нетронутыми, тем бы-
стрее проходит работа по редактированию, компиляции и тестиро-
ванию.

6.3.1. Пример: игра «Бермуда»

Проще всего продемонстрировать разделение программы на кон-

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

296
 Инструменты программирования

а исходный код класса кораблей — в файл ship.cpp. Основная программа

находится в файле bermuda.cpp.

Каждый отдельный файл может быть скомпилирован. Сначала ком-

пилируется главный файл bermuda.cpp. Команда для компилятора вы-
глядит так:

g++ -c bermuda.cpp

Будет выдан целый список ошибок, которые, в первую очередь, по-

явятся из-за того, что главной программе не знаком ни класс игрового
поля, ни класс кораблей, а для их успешной инициализации ей требу-
ется знать оба этих класса. Таким образом, каждый из двух файлов бу-
дет еще раз разделен. Файл ship.cpp содержит определение функций для
кораблей. Класс tShip, который необходим главной программе, должен
размещаться в специальном файле интерфейса с именем ship.h. То же
самое требуется сделать с игровым полем, чтобы файл field.h также был
вложен в код главной программы. Помимо классов здесь определяются
и константы для размеров поля и количества кораблей.

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

подключены файлы ship.h и field.h. Для этого служит старая знакомая
команда #include.

#include "ship.h"

#include "field.h"

Теперь компилирование должно пройти успешно. Хотя определение

элементных функций классов находится не в заголовочном файле, глав-
ная программа может быть скомпилирована. Она должна содержать
только прототипы используемых функций и переменных. В качестве
результата успешной компиляции создается файл bermuda.o. Этот файл
объекта содержит теперь скомпилированную функцию main(), но не
содержит ни класса tShip ни игрового поля. В целом он содержит толь-
ко ссылки на них и информацию о том, как должен выглядеть объект
класса tShip.

Теперь проведем таким же образом компиляцию файла ship.cpp.

g++ -c ship.cpp

Компиляция не сработает сразу. Некоторые классы незнакомы ком-

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

297
Глава 6

требуется подключить файл ship.h. После привязки его с помощью ко-

манды #include создается новый файл. Он носит имя ship.о.
При попытке компилировать файл field.cpp выяснится, что ему тре-
буются оба заголовочных файла. Здесь также понадобится #include.
Следующие строки должны быть добавлены в код файла field.cpp.
#include "field.h"
#include "ship.h"

Здесь снова появится ошибка! Компилятор будет недоволен тем,

что класс tShip неизвестен. Почему? Ведь заголовочный файл подклю-
чен. Если рассмотреть сообщение об ошибке внимательно, станет ясно,
что ошибка находится не в файле field.cpp, а в его заголовочном файле
field.h. Причина в том, что при определении класса игрового поля так-
же используется класс tShip. В последовательности команд #include
файл ship.h указан после файла field.h. В файле bermuda.cpp было иначе,
поскольку класс tShip был уже известен, а именно: подключен в к фай-
ле field.h.

Означает ли это, что надо всегда следить за тем, в какой последо-

вательности располагаются команды #include? Нет, это может только
привести к путанице. Обычно нужно подключать заголовочный файл
там, где он требуется. В этом случае нужно написать команду #include
для ship.h именно в заголовочном файле field.h, потому что там исполь-
зуется класс tShip.

Теперь еще раз скомпилируем файл field.cpp, и снова появится

ошибка. Но теперь причина совсем в другом. Компилятор «жалует-
ся», что класс tShip дважды определен в одном элементе компиля-
ции. Вероятно, вы полностью уверены, что класс tShip определен
только один раз в файле ship.h. Это тоже абсолютно верно. Но дело
в том, что этот файл подключен дважды. Один раз через файл field.h,
и еще раз прямо в field.cpp. И если сейчас попробовать скомпили-
ровать файл bermuda.cpp, вы получите точно такое же сообщение об
ошибке.

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

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

298
 Инструменты программирования

процессор может определять и опрашивать константы. Заключим класс

tShip и файл ship.h в команды:

#ifndef SHIP_H
#define SHIP_H
class tShip {
...
};
#endif

Первая команда #ifndef проверяет, не была ли константа SHIP_H

определена ранее. Этого наверняка не произошло, так что компилятор
может продолжать работать. В следующей строке будет определена
именно эта константа и подключен класс tShip. В конце препроцессор
обрабатывает команду #endif, которая принадлежит к первой строке
#ifndef. Если позднее при процессе компиляции снова будет подклю-
чаться файл ship.h, препроцессор снова будет опрашивать константу
SHIP_H, была ли она уже определена или нет. На этот раз она уже опре-
делена, поэтому препроцессор переходит к последней строке и прячет
содержимое файла от компилятора. Неважно, сколько раз вы подключа-
ете ship.h, класс tShip определяется единожды. Теперь можно скомпи-
лировать все три модуля и получить три файла объектов. Но не хватает
самого программного файла. Для его создания нужно связать три файла
друг с другом. Для этого снова вызывается компилятор GNU Compiler
и ему передаются файлы с именем bermuda и затем все файлы объектов.
Компилятор настолько сообразительный, что знает: что здесь он должен
не компилировать, а связывать.
g++ -o bermuda bermuda.o field.o ship.o
Если используется операционная система Windows, в качестве имени
файла вместо bermuda следует ввести bermuda.exe. Система Windows
нуждается в расширении, чтобы отличить исполняемый файл.
В следующей главе рассмотренный пример будет сформулирован
в общих понятиях и рассмотрен по порядку.

6.3.2. Распознавание файлов

Файл исходного кода программы на языке C обычно имеет расши-

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

299
Глава 6

поскольку в операционной системе Windows нет различия между строч-

ными и прописными буквами в именах файлов. Периодически встре-
чается расширение .сс, но обычно файлы имеют расширение .срр. За-
головочные файлы имеют расширение .h, как в языке C, так и в C++.
Некоторые программисты используют также .hpp или .hh. Для заголо-
вочных файлов стандартных библиотек можно опустить расширение1.

Компилятор обрабатывает отдельно каждый файл исходного кода

и создает из него отдельный файл объекта. Файл объекта в системе UNIX
имеет расширение .о, а в системе Windows — .obj. Файлы объектов при
компиляции без ошибок привязываются к программе компоновщиком.

Чтобы из файла объекта создать работоспособную программу, ком-

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

6.3.3. Объявление и определение

Понятия «объявление» и «определение» значат для классов немно-

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

Определение класса содержит его объявление и составные элемен-

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

Проще обстоит дело с глобальными переменными и функциями.

Компилятор требует только их объявление. Если оно указано в начале

1 Заголовочные файлы без расширения используют пространство имен std

(см. стр. 327).

300
 Инструменты программирования

исходного кода программы, переменные и функции можно использо-

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

int myFunction(int, char *); // объявление функции

extern char *Pos; // объявление переменной
Листинг 6.3. Прототипы функций и переменных

Функции, как и переменные, можно определить в программе толь-

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

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

Чтобы разделить необходимое объявление и определение между

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

Все команды, которые начинаются с символа октоторпа (#), обраба-

тываются препроцессором. Команда #include действует так, что файл
встраивается на место ее написания. Имя файла указывается в угловых
скобках. Иногда речь идет о системных файлах или файлах компилято-
ра. Путь к ним устанавливается условно или в настройках компилятора.
Также можно указать имя файла в кавычках. Тогда заголовочные файлы
будут принадлежать проекту и находиться в том же каталоге, что и дру-
гие файлы проекта. Обычно они имеют расширение .h. Заголовочные
файлы стандартных библиотек языка C++ не имеют расширения.
301
Глава 6

В определении пути к файлу допустим прямой слеш (/). В опера-

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

Если заголовочный файл находится в каком-то каталоге, который

не принадлежит к стандартным путям, не рекомендуется указывать его
прямо в строке include, лучше расширить список путей подключаемых
файлов. В интегрированной среде разработки (IDE) для этого суще-
ствует протокол проектных свойств. В командной строке компилятора
он доступен с помощью свойства -I. Если вы не примете это всерьез
и напишете в вашем программном коде строку, подобную следующей,
программа будет скомпилирована только в среде Windows и скорее все-
го только на вашем компьютере:
#include "F:\mysrc\firma\incl\standards.h" // нехорошо

В некоторых случаях требуется подключить старые библиотеки

языка C к программам на языке C++. Тогда может оказаться, что вызов
функции C++ не подходит к номенклатуре языка C, которую ожидает
библиотека. Поскольку язык C++ кодирует также параметры функции,
они не совместимы с функциями, которые генерирует компилятор язы-
ка C. При этом вызов функций языка C возможен, если их объявление
будет подключено через описание extern "C". Часто при подключении
соответствующих файлов заголовков это выглядит, как в следующем
примере:

extern "C" {
#include <cheader1.h>
#include "cheader2.h"
}

Заголовочный файл открывает часть модуля, которая требуется для

программирования других модулей. Таким образом он выстраивает ин-
терфейс между модулем и частями программы, которые его использу-
ют. При этом изменения в модуле не касаются других частей програм-
мы до тех пор, пока заголовочный файл остается неизменным. Если же
он изменяется, все модули, к которым подключен этот файл, должны
быть скомпилированы заново. Чтобы использовать инструмент make
(см. стр. 309), требуется также предусмотреть зависимости заголовоч-
ных файлов. Если вы работаете с интегрированной средой разработки,
такая зависимость будет автоматически установлена. Изменения в за-

302
 Инструменты программирования

головочных файлах приведут к тому, что все зависимые модули снова

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

6.3.5. Статические функции

Как правило, любую функцию можно вызывать в разных модулях.

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

Если многие функции должны использоваться в качестве локальных,

в языке C++ предлагается анонимное пространство имен (см. стр. 330),
работать с которым проще, чем указывать каждой функции свойство
static.

6.3.6. Скрытая реализация

Немножко неудачно, что также и приватные операции класса выно-

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

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

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

class CardGame
{
public:
Card *next_card();
void new_mix();
private:
Card card[MAXCARDS];
};
Листинг 6.4. Класс CardGame

303
Глава 6

Здесь в закрытом разделе определяется массив карт. К его реализа-

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

class localCardGame;
class CardGame {
public:
Card *next_card();
void new_mix();
CardGame();
~CardGame();
private:
localCardGame *my;
};
Листинг 6.5. Карточная игра со скрытой реализацией

Все, что не касается закрытой части класса, но и не должно быть откры-

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

class localCardGame
{
public:
Card card[MAXCARDS];

304
 Инструменты программирования

};
CardGame::CardGame()
{
my = new localCardGame;
}
CardGame::~CardGame()
{
delete my;
}
Листинг 6.6. Реализация

Такая дискретность дается нелегко. Для доступа к приватным клас-

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

6.4. Компоновщик и библиотеки

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

Чтобы использовать содержимое библиотеки для корректного вызо-

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

6.4.1. Подключение статических библиотек

Компоновщик будет искать в библиотеках функции, которые вы-

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

В средах UNIX и Linux компоновщик обозначается ld, а в операци-

онной системе Windows — часто LINK. В целом, имя не имеет значения,
305
Глава 6

поскольку компоновщик в основном вызывается компилятором или ин-

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

Если компоновщик вызывается в командной строке или командой

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

Опция -l (строчная буква L) передает в качестве параметра имя тре-

буемой библиотеки. Если в операционной системе Windows передает-
ся имя файла библиотеки, то оно, как правило, имеет расширение .LIB,
в среде UNIX имя обычно иное. В системе UNIX имя всегда начинается
с lib и имеет расширение .а. Оба параметра не могут передаваться свой-
ством -l. Библиотека libxml.a будет подключаться как -lxml.

В среде UNIX библиотеки компилятора языка C и библиотека опе-

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

Если требуется подключить библиотеку, которая находится не по

стандартному пути, расположение должно передаваться в свойстве -L.

Для интегрированной среды разработки эту информацию можно

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

6.4.2. Динамические библиотеки

Начиная с победного шествия графических оболочек, стало не-

возможным подключать все библиотеки к каждому приложению, по-
скольку в таком случае каждое приложение Windows должно включать
собственную среду Windows. Вместо этого в системе существуют дина-
мические библиотеки, которые управляются операционной системой.
В среде UNIX они называются «Shared Libraries». В операционной си-
стеме Windows — «Dynamic Link Library». Их можно узнать по расши-
рению DLL.
306
 Инструменты программирования

Использование динамических библиотек системы происходит неяв-

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

Среда Windows

C помощью любой интегрированной среды разработки (IDE) мож-

но создать DLL-проект, и тем самым выполнить бо́льшую часть работы.
Автоматический конструктор IDE создаст функцию DllEntryPoint(),
которую должна содержать каждая библиотека DLL. Вам потребуется
только написать функции, к которым можно получить доступ извне.

Библиотеки DLL для операционной системы Windows не имеют

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

__declspec(dllexport) double fkt(double w)

{
...

В среде Visual C++ корпорации Microsoft функция для DLL выгля-

дит так2:

extern "C"
__declspec(dllexport) double __stdcall fkt(double w)
{
...

После генерации проекта создается файл с расширением .DLL, кото-

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

1
Keiser Richard. C++ mit dem Borland C++ Builder. Springer, Berlin Heidelberg, 2002.
2
Wigard Susanne. Visual C++ 6. bhv, Kaarst, 1999.

307
Глава 6

или папке Windows. Наряду с ним создается файл импорта с расшире-

нием .LIB. Последний должен подключатся вызываемой программой,
которая запрашивает настоящий DLL. Вызываемая программа требует
при этом еще и прототип, чтобы корректно вызывать функции. Он легко
выводится из определения функции. В Borland C++ прототип выглядит
следующим образом:
__declspec(dllexport) double fkt(double w);
Сам вызов не отличается от вызова обычной локальной функции.

Среда UNIX/Linux

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

#include <iostream>
using namespace std;
void print_hello()
{
cout << "Hello" << endl;
}
Листинг 6.7. Программа libhello.cpp

Вызов происходит через программу usehello.cpp. Здесь создается

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

void print_hello();
int main()
{
print_hello();
}
Листинг 6.8. Программа usehello.cpp

1 Майкл К. Джонсон, Эрик В. Троан. Разработка приложений в среде Linux. М.: Ви-
льямс, Диалектика, 2007.

308
 Инструменты программирования

Секрет заключается в том, как обрабатываются оба модуля. Файл

libhello.cpp компилируется сначала в файл объекта. При этом свойство
-fPIC заботится о том, чтобы был создан позиционно независимый код.
Второй вызов привязывает файл объекта в качестве динамической би-
блиотеки. Центральное свойство здесь -Wl, -soname, libhello.so.0.
Оно позволяет создать новые библиотеки с именем libhello.so.0. При
этом номер версии сразу же кодируетсясимволом 0. Последние коман-
ды связывания позволяют получить доступ к файлам с несколькими
именами. Серийный номер задавать необязательно.

c++ -fPIC -c libhello.cpp

c++ -shared -Wl,-soname,libhello.so.0 -o libhello.so.0.0\
libhello.o -lc
ln -sf libhello.so.0.0 libhello.so.0
ln -sf libhello.so.0 libhello.so
Листинг 6.9. Команды для создания динамической библиотеки

В конце нужно скомпилировать параметр usehello.cpp.

c++ usehello.cpp -L. -lhello

Листинг 6.10. Компиляция главной программы

6.5. Программа make

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

Проект myprog состоит из файлов исходного кода main.cpp, test.

cpp и tools.cpp. Каждый из них имеет заголовочный файл (main.h, test.h
и tools.h), которые проект каждый раз подключает сам. При этом файл
main.cpp подключает заголовочные файлы каждого из других файлов,
а модули подключает main.h.

309
Глава 6

Добавляется файл Makefile, в котором определяется путь компи-

ляции. Программа myprog зависит от файлов main.о, test.о и tools.о. Это
определяется в следующем файле таким образом (рис. 6.1).
myprog: test.o main.o tools.o

test.h haupt.h tools.h

test.cpp haupt.cpp tools.cpp

test.o haupt.o tools.o

meinprog

Рис. 6.1. Пример проекта make

Программа myprog обозначается как «цель». Далее следующие строки

определяют, как создается целевой файл. Файл myprog генерируется, ког-
да компилятор вызывается с файлами объектов в качестве параметров.
С помощью свойства -о устанавливается, что результат должен иметь
имя myprog. Компилятор отмечает для себя, что здесь он должен только
скомпоновать программу, поскольку нет файлов исходного кода. Такие
строки должны начинаться с табуляции. Нельзя использовать пробел:
myprog: test.o main.o tools.o
g++ -o myprog test.o main.o tools.o

Если вы вызовите make просто так, то к своему удивлению получите

уже полностью скомпилированную программу. На экране появятся сле-
дующие строки:
gaston> make
g++ -c -o test.o test.cpp

310
 Инструменты программирования

g++ -c -o main.o main.cpp

g++ -c -o tools.o tools.cpp
g++ -o myprog test.o main.o tools.o
gaston>

Фактически программа make «знает», как из c-файла сделать o-файл,

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

Если изменить файл test.cpp, то только он будет скомпилирован,

а myprog создастся заново. Если изменить test.h, ничего не произойдет.
Программа make не знает зависимостей заголовков. Поскольку она сле-
дит за изменениями заголовочных файлов, требуются следующие изме-
нения в файле Makefile:

test.o : test.cpp test.h main.h

tools.o : tools.cpp tools.h main.h
main.o : main.cpp main.h test.h tools.h

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

test.o : test.cpp test.h main.h
g++ -c -o test.o test.cpp

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

нать их не нужно.

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

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

Программа make распознает, если исходный файл программы создан

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

 Цель: зависимости
команда генерации

311
Глава 6

Эта основная структура называется правилом. Новое правило долж-

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

Пример:
try :
cd .. ; pwd
pwd

Результаты обоих вызовов pwd не одинаковы. Обмен с cd .. дей-

ствует только для текущих строк, ав следующих снова обрабатывается
предыдущий каталог:
cd .. ; pwd
/home/arnold/my/src/unix
pwd
/home/arnold/my/src/unix/make

Следует составлять команды так, чтобы они обрабатывались в одной

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

Символ комментария здесь — октоторп (#).

6.5.1. Макросы в make-файле

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

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

В примере файл объекта обрабатывается и дважды перечисляется —

один раз в отношении определения myprog, второй раз в вызове компи-
лятора.

312
 Инструменты программирования

myprog: test.o main.o tools.o

g++ -o myprog test.o main.o tools.o
Здесь можно определить переменную OBJS, которая обозначает объ-
ект. С внедрением переменной OBJS создаются следующие make-файлы:

OBJS = test.o main.o tools.o

myprog: $(OBJS)
g++ -o myprog $(OBJS)
Переменные не должны определяться в make-файле. Он может по-
лучить доступ к переменным среды, которая установлена для вызван-
ной оболочки.

Предопределенный макрос
Несколько строк допустимо обрабатывать одним правилом. На-
пример, использовать $(OBJS) в качестве цели. Одна строка может
разделяться на несколько строк. В команде генерирования допустимо
ссылаться на текущую цель. Для этого существуют предопределенные
макросы, показанные в табл. 6.3 на примере файла main.o.

Таблица 6.3. Предопределенные make-макросы

Макрос Значение
$@ Имя целевого файла (main.o)
$* Базовое имя целевого файла (main)

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

.source.target:
Типичный переход — от C-источника к объектам. Источники име-
ют расширение .с, а объекты — .о. Соответствующее правило суффикса
имеет вид:
.c.o:
g++ -c $<

Внутренний макрос $< может использоваться только при суффикс-

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

313
Глава 6

6.5.2. Несколько строк

Make-файл может генерировать несколько программ. Эта возмож-

ность используется, когда один и тот же исходный код требуется для
создания нескольких проектов, которые при этом могут также зависеть
друг от друга. Типичным примером служит программа клиент-сервер,
которая использует в заголовке одинаковые структуры данных:
all: client server
client: $(SENDHEADER) $(COMMONOBJS) $(CLTOBJS)
...
server: $(SENDHEADER) $(COMMONOBJS) $(SRVOBJS)
...
Первая цель — это всегда цель общих make-файлов. В данном случае при
вызове make в первую очередь был бы сгенерирован файл all. Поскольку
нет никакого связанного действия, будет просто проверяться, выполняется
ли зависимость. Соответственно, следующей целью будет построен client,
а затем server. Не обязательно, но чаще всего, псевдоцель, которую гене-
рируют все программы обработки make-файлов, называется all.

6.6. Отладка с помощью GNU Debugger

Отладчик — это инструмент, которым можно проверить программу во
время ее выполнения. Программист запускает отладчик для исследуемой
программы. При этом он берет программу за руку, позволяет ей идти и при
этом наблюдает. Если программа спотыкается, отладчик демонстрирует,
где произошел сбой. Программист может сам установить позицию, в ко-
торой произойдет остановка выполнения программы. Отладчик способен
при этом показать содержимое переменных и пошагово продолжить вы-
полнение, пока программист не определит, почему программа работает не
так, как требуется. В этой главе будет описано, как отладчик GNU Debugger
запускается из командной строки. Он доступен как в интегрированной
среде разработки Bloodshed, так и в KDevelop. Кроме того, он входит в со-
став пакета GCC. Отладчик GNU Debugger запускается с исследуемой
программой в качестве параметра. Остальные параметры можно добавить
в качестве Coredump1. Часто создание таких файлов пропускается, чтобы
они не засоряли систему или не пугали неопытного пользователя. По-
1
Coredump называется файл с именем core, который создает UNIX, если в програм-
ме происходит сбой. Этот файл содержит полное описание памяти программы, включая
стек и содержимое регистров, и позволяет сделать дальнейшие выводы о причине сбоя.

314
 Инструменты программирования

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

следует разрешить его создание командой ulimit -c 1000000 в файле
.profile. Значение после -с устанавливает его максимальный размер1.

Если отладчик запущен, становятся доступными различные его ко-

манды. С помощью run можно запустить программу, командой kill снова
ее остановить. С помощью команды quit отладчик будет покинут. Чтобы
прервать работу программы, в критическом месте следует установить точ-
ку останова. Команда break ожидает в качестве параметра номер строки
в листинге или имя функции. Номер строки можно получить из листинга
программы, который вызывается командой list. Если точка останова до-
стигнута, с помощью команды step или next можно пройти программу
шаг за шагом. При этом команда step будет заходить внутрь встречаю-
щихся функций, а команда next — нет. Путем ввода команды continue
программа запускается до следующей точки останова или до конца. Если
требуется окинуть взглядом переменные, самая простая команда для это-
го — print. Командой watch можно выбрать переменные для наблюдения.
Она демонстрирует содержимое, как только оно изменяется.

Таблица 6.4. Команды отладчика GNU Debugger

Команда Действие
quit Покинуть отладчик
run Запустить программу
kill Остановка выполнения программы
print переменная Показать содержимое переменных
watch переменная Наблюдение за переменной
list Показать код
break имя_функции Установить точку останова
break номер_строки Установить точку останова
clear имя_функции Удалить точку останова
clear номер_строки Удалить точку останова
next Выполнить следующую строку
step Выполнить следующую строку с возможностью за-
continue хода в функцию
Завершить выполняющийся процесс

Отладчик может взять под свое покровительство выполняющую-

ся программу. Для этого его нужно запустить и ввести команду at или
attach. Процесс будет остановлен и свяжется с отладчиком.
attach PID
1 В случае, если вы не настолько хорошо знакомы со средой UNIX или Linux, чтобы
выполнить эти настройки, спросите администратора или обзаведитесь книгой по UNIX.

315
Глава 6

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

отладчика. Далее следует пример1:

gaston> ps -ef | grep one

arnold 1339 1223 0 11:37 pts/3 00:00:00 one
gaston> gdb one 1339
GCC gdb 20010316
Copyright 2001 Free Software Foundation, Inc.
/home/arnold/my/src/unix/ipc/1339: No such file or directory.
Attaching to program: /home/arnold/src/unix/one, process 1339
Reading symbols from /lib/libc.so.6...done.
Loaded symbols for /lib/libc.so.6
0x400f3d64 in read () from /lib/libc.so.6
(gdb) next
Single stepping until exit from function read,
...

Этот несколько сокращенный протокол демонстрирует, как про-

цесс one протекает под контролем отладчика. Сначала PID обозначает-
ся в качестве one и запускается отладчик. Затем появляется сообщение
о правах копирования. Далее отладчик пытается открыть файл 1339.
Поскольку это не выходит, он пробует получить соответствующий про-
цесс, что ему удается.

В IDE точка останова устанавливается с помощью нажатия клавиши

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

1 Команда ps используется в UNIX системах и показывает список процессов. В дан-

ном случае программа получит номер процесса one.

316
 Глава 7
ДРУГИЕ ЭЛЕМЕНТЫ ЯЗЫКА C++
Итак, основы для программирования на языке C++
заложены. Рассмотрено обращение с переменными
и полиморфизм. Также и самоопределение
операторов больше не должно быть
для вас проблемой.

В этой главе мы осветим другие важные элементы языка C++. Обоб-

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

7.1. Обобщенное программирование

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

С помощью шаблонов язык C++ предлагает инструмент для опреде-

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

Язык C++ «знает» шаблонные функции, для которых программист

оставляет открытыми типы параметров, а также шаблоны классов. По-
317
Глава 7

следние определяют, к примеру, структуры данных, которые могут хра-

нить различные типы.

7.1.1. Шаблонные функции

Простая форма шаблона — шаблонные функции. Они определяют

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

Классический пример обобщенной функции — функция min().

Функция выбирает минимальный параметр из двух заданных. Процесс
одинаков для всех типов, для которых может использоваться знак срав-
нения. Перед тем, как будет показано определение шаблона, рассмотрим
сначала обычную функцию min(), которая использует переменные типа
long в качестве параметров.

long min(long a, long b)

{
return (a < b) ? a : b;
}
Листинг 7.1. Функция min() для типа long

Теперь создадим шаблонную функцию:

template <class T>

T min(T a, T b)
{
return (a < b) ? a : b;
}
Листинг 7.2. Шаблонная функция min()

Шаблонная функция начинается с ключевого слова template.

В угловых скобках следует шаблонный параметр. Он состоит из клю-
чевого слова class или typename и имени. Оно будет использоваться
в шаблоне в качестве представителя оставшегося неопределенным типа.
318
 Другие элементы языка C++

Традиционно для этого берется прописная буква Т. Но имя, конечно,

можно выбрать самостоятельно. В позиции, где в программе должен ис-
пользоваться тип, в шаблоне идет имя шаблонного параметра.
Функция min() использует оставшийся неопределенным тип сразу
три раза. Оба параметра и возвращаемое значение имеют тип Т.
Слов typename и class полностью равнозначны. Ключевое слово
typename вводится, чтобы обозначить, что здесь также могут использо-
ваться типы, которые не определены в качестве классов. Хотя некото-
рые компиляторы еще не знают ключевое слово typename.
На рис. 7.1 показан синтаксический граф шаблонной функции.
Граф определения функции, представленный на рисунке, изображен на
рис. 4.1 на стр. 163.

Рис. 7.1. Граф синтаксиса шаблонной функции

Когда вызывается шаблонная функция, компилятор создает такую

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

int i=15;
int j=7;
cout << min(i,j) << endl;
Листинг 7.3. Команды шаблонной функции min()

В следующем примере функция swap() демонстрирует, что можно

использовать локальные переменные еще неизвестных типов, и что па-
раметр может быть передан также по ссылке.
319
Глава 7

template <typename T> void swap(T& a, T& b)

{
T help;
help = a;
a = b;
b = help;
}
Листинг 7.4. Шаблонная функция swap()

Можно использовать несколько разных типов. Для этого они пере-

числяются в угловых скобках:
template <class T1, class T2>
int myFunction(T1 t1, T2 &t2)
{
...
Не всегда из передаваемых параметров четко понятно, для какого
типа вызывается шаблон. Проблема возникает тогда, когда шаблон не
имеет входных параметров, а только возвращаемое значение. Чтобы
установить, с каким типом он должен использоваться в таком случае,
при вызове функции целевой тип указывается в угловых скобках между
именем функции и скобками параметров.
int a = Create<int>();
Если шаблон использует несколько открытых типов, они могут быть
заданы перечислением через запятую. Но можно задавать только пер-
вый параметр. Следующий вызов myFunction() указывает, что первый
параметр должен пониматься в качестве short.
int a = myFunction<short>(12, 5.5);
Если требуется установить, что первый параметр должен быть ин-
терпретирован в качестве short, а второй как float, вызов функции бу-
дет иметь вид:
int a = myFunction<short,float>(12, 5.5);
С помощью шаблонных параметров можно не только установить
типы, но также передать значения или выражения. В следующем при-
мере функция SuperArray() передает, сколько места должно быть вы-
делено под массив.

320
 Другие элементы языка C++

template <class T, int max>

int SuperArray(T t)
{
T a[max];
...
}
int main()
{
SuperArray<int, 100>(12);
}
Шаблоны предназначаются в качестве замены внушающих опасение
макросов (см. стр. 325). Поскольку последние функционируют на осно-
ве простой замены кода, источники ошибок слабо обозримы. Прежде
всего, макросы не могут предоставить защиту типа. Даже если шаблон-
ная функция оставляет тип открытым, она гарантирует, что все одина-
ковые типы остаются одинаковыми. Если тип Т1 используется в каче-
стве float, при этом вызове все переменные типа Т1 обслуживаются
как float.

7.1.2. Шаблоны классов

Можно целый класс определить как шаблон. Так решается пробле-

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

// стек для некоторого класса T

template<class T> class Stack
{
public:
// конструктор с инициализацией констант
maxStack
Stack() : maxStack(256)

321
Глава 7

{ s = new T[maxStack]; index=0;}

~Stack() {delete[] s;}
bool pop(T *); // изъять
bool push(T ); // поместить
private:
const int maxStack; // константа для размера стека
T *s; // сам стек
int index; // текущая позиция в массиве стека
};
// получить элемент из стека и освободить память
template<class T> bool Stack<T>::pop(T *get)
{
if (index==0 ) return false; // стек пуст?
*get = s[--index]; // получить элемент
return true;
}
// записать новый элемент в стек
template<class T> bool Stack<T>::push(T set)
{
if (index>=maxStack) return false; // стек переполнен?
s[index++] = set; // записать элемент
return true;
}
int main() // тестирования стека
{
Stack<int> iStack; // создание стека для целых чисел
iStack.push(8); // запись тестовых значений
iStack.push(4);
iStack.push(2);
// прочесть значения из стека и вывести их на экран
for (int i=0; i<3; i++)
{
int a;
if (iStack.pop(&a))

322
 Другие элементы языка C++

{
cout << a << endl;
}
}
}
Листинг 7.5. Шаблон класса стека

Элементные функции push() и pop() объявляются в шаблонном

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

template<class T> bool Stack<T>::push(T set)

В функции main() создается стек для переменных типа int. Для

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

Stack<int> iStack;

При дальнейшей работе программы в стек записывается пара значе-

ний и затем считывается из него обратно. При этом незаметно, что стек
является шаблоном.

Шаблонные классы с параметрами

В примере выше мы установили размер стека 256. Между угловыми

скобками можно передать это значение в качестве параметра, а в данном
примере — в качестве значения max. При создании объекта оно должно
определяться в качестве константы. С помощью инициализатора в кон-
структоре оно будет использоваться для установки значения константы
класса maxStack.

#include <iostream>
using namespace std;
template<class T, int max> class Stack
{
public:

323
Глава 7

Stack() : maxStack(max) // устанавливается при

//определении
{ s = new T[maxStack]; index=0;}
~Stack() {delete[] s;}
bool pop(T *); // изъять
bool push(T ); // поместить
private:
const int maxStack; // константа размера стека
T *s; // сам стек
int index; // текущая позиция в массиве стека
};
// получить элементы из стека и освободить память
template<class T, int max> bool Stack<T,max>::pop(T *get)
{
if (index==0 ) return false; // стек пуст?
*get = s[--index]; // изъять элемент
return true;
}
// записать новый элемент в стек
template<class T, int max> bool Stack<T,max>::push(T set)
{
if (index>=maxStack) return false; // стек переполнен?
s[index++] = set; // записать элемент
return true;
}
int main() // тестирование
{
Stack<int, 2> iStack; // стек с двумя целыми значениями
int a;
iStack.push(8); // записать!
iStack.push(4);
iStack.push(2); // уже тесно!
// вывод стека
for (int i=0; i<3; i++)

324
 Другие элементы языка C++

{
if (iStack.pop(&a))
{
cout << a << endl;
}
}
}
Листинг 7.6. Шаблонный класс с параметрами (templstack2.cpp)

В функции main() создается стек из двух элементов. Для тестиро-

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

Упражнение
• Напишите шаблонный класс Stack заново так, чтобы он был реа-
лизован линейным списком. Для этого можно использовать класс
tStack (см стр. 229). Само собой разумеется, что при этом не требу-
ется ограничение размера. Пример решения приведен на стр. 513.

7.1.3. Макропрограммирование с помощью

команды #define

Обобщенное программирование началось не с языка C++. В языке C

также можно с помощью препроцессорных макросов разработать обоб-
щенные функции. По причине совместимости эта возможность осталась
и в языке C++, но не следует ее использовать для новых программ. Ко-
манда #define является базисом макропрограммирования, поскольку
все команды, которые начинаются с символа октоторпа (#), выполня-
ются препроцессором. Он может выполнить только вставку кода, но не
имеет никаких знаний по языку C или C++.

После команды #define указывается имя макроса. Если у макро-

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

325
Глава 7

После пробела вставляется код, который препроцессор добавляет на

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

Рис. 7.2. Граф синтаксиса #define

Очень часто обобщенную функцию min() можно встретить в виде

макроса. Она будет реализована таким или подобным образом:

#define min(a,b) a>b?b:a

Листинг 7.7. Пример макроса min()

Везде, где в программе встречается функция min(), ее вызов будет

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

Макрос, с точки зрения программиста на языке C, имеет следующие

преимущества:
1. Он может писать код для различных типов.
2. Не требуется код для вызова функции. Макрос выполняется незна-
чительно быстрее функции.

В языке C++ оба аргумента действительны, но не могут рассматри-

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

326
 Другие элементы языка C++

С точки зрения программиста на языке C++ макросы имеют следую-

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

#define mul(a,b) a*b

int a=-5;
int c = mul(a+4,2);
Листинг 7.8. Коварный макрос

Результат в любом случае будет равен не –2, а –3! Причина в том,

что выражение а+4 будет пересчитано при вызове –1, поскольку проис-
ходит вставка кода:

c = a+4*2;

Отсюда получится -5+8.

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

7.2. Пространство имен

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

При этом объявление и определение может быть объединено под од-

ним именем и отделено от другого.

327
Глава 7

7.2.1. Определение пространства имен

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

namespace util
{
int counter;
void find_begin(string s)
{
...
}
}
Листинг 7.9. Код в пространстве имен util

Внутри пространства имен для программиста ничего не меняется.

Функция find_begin() может прямо обращаться к глобальной пере-
менной counter.

Поскольку функции и переменные находятся в одном простран-

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

namespace util
{
int counter;
void find_begin (string s);
int find_end(string s);
}
Листинг 7.10. Прототип пространства имен util

Функция find_end() определена не в файле util.cpp. Если она будет

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

int util::find_end(string s)
{
...
}
Листинг 7.11. Функция для пространства имен util

7.2.2. Доступ

Если функции и переменные должны вызываться извне, из про-

странства имен util, для каждого элемента нужно указать util::.

all = util::find_end(filename);
all += util::counter + file::counter;
Листинг 7.12. Доступ к пространству имен

В первой строке функция find_end() вызывается из пространства

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

7.2.3. Особые пространства имен

Стандартные библиотеки языка C++ используют для всех функций

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

Также с помощью команды using можно пояснить, что требуется

использовать пространство имен std, чтобы все определенные в нем
переменные и функции объявлять без имени пространства имен. Код
имеет вид:

using namespace std;

Приведенные в примере имена пространств имен util или file не

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

можно более выразительное и однозначное имя. Недостаток в том, что

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

namespace file=CustomerConfigurationFile;

7.2.4. Анонимное пространство имен

Пространства имен можно применять так, чтобы имена, которые ис-

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

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

стить несколько функций в одно пространство имен.

Поскольку данное пространство имен недоступно извне, его можно

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

Функции и переменные в пространстве имен доступны при указании

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

#include "util.h"
#include <iostream>
using namespace std;
namespace
{
int little_help(int a)
{
cout << "Little help" << a << endl;
}
} // namespace
void util::service()

330
 Другие элементы языка C++

{
little_help(12);
}
Листинг 7.13. Анонимное пространство имен (namespace/util.cpp)

Соответствующий заголовочный файл с именем util.h содержит толь-

ко пространство имен util и доступную в нем функцию service().

namespace util
{
void service();

}
Листинг 7.14. Заголовочный файл (namespace/util.h)

Вызов осуществляется, как уже видно, с помощью указания имени

util и двойного двоеточия.

#include "util.h"
int main()
{
util::service();
}
Листинг 7.15. Вызов (namespace/main.cpp)

7.2.5. Граф синтаксиса

На рис. 7.3 представлен граф синтаксиса определения пространства

имен.

Рис. 7.3. Граф синтаксиса namespace

331
Глава 7

7.3. Защита от сбоев при помощи ключевых

слов try и catch
«Невозможно написать программу, защищенную от дурака, по-
скольку дураки очень изобретательны». Действительно, бороться с за-
коном Мерфи1 непросто. Программист должен не только разработать
алгоритм, но также предусмотреть и исключить все попытки неверного
ввода, системные ошибки и невозможность использования на других
платформах. Язык C++ предлагает механизм, который позволяет защи-
тить блок программного кода от сбоев. Все возникающие ошибки будут
передаваться блоку обработки. Защитный командный блок начинается
с ключевого слова try2. Блок обработки ошибок начинается ключевым
словом catch3. В блоке команд производится попытка выполнения про-
граммы, и блок обработки ошибок ловит сбои, словно сетью.

try
{
int divisor=0;
int dividend=1;
int quotient = dividend/divisor; // здесь появляется ошибка!
}
catch (...)
{
cout << "Проблема обнаружена" << endl;
}
Листинг 7.16.

Деление на 0 в обычном случае приведет к сбою программы. Такая

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

1 «Если что-то может пойти не так, то это непременно произойдет».

2
В пер. с англ. — «пытаться». Прим. ред.
3 В пер. с англ. — «ловить». Прим. ред.
4
Во многих версиях компилятора GNU Compilier (в любом случае для gcc-2.9.2.
и gcc-2.95.2, и вероятно для более новых) деление на 0 и исключительные ситуации для
чисел с плавающей запятой не обрабатываются командой catch(…).

332
 Другие элементы языка C++

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

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

Три точки после команды catch не означают, что у автора кончи-

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

Обработка ошибок влияет не только на сам блок, но и на все функ-

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

7.3.1. Создание собственных исключительных

ситуаций

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

ко она может быть обработана с помощью команды catch. Поэтому очень
интересно определять собственные исключительные ситуации. Команда
throw определяет такое исключение. Она сразу прерывает работу про-
граммы и переходит прямо к соответствующему блоку обработки.

#include <iostream>
using namespace std;
void do_smth(int Problem)
{
333
Глава 7

if (Problem>0)
{
throw 0;
}
}
int main()
{
try
{
do_smth(1);
}
catch(...)
{
cout << "Возникла ошибка!" << endl;
}
}
Листинг 7.17. Исключение, сгенерированное throw

Команда throw в функции do_smth() вызывает исключение, если

значение параметра Problem больше 0. Обработка происходит сразу же
в блоке catch.

Иногда недостаточно просто вызвать программу обработки. Чтобы

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

#include <iostream>
using namespace std;
void do_smth(int Problem)
{
if (Problem>0)
{

334
 Другие элементы языка C++

throw 5;
}
}
int main()
{
try
{
do_smth(1);
}
catch(int a)
{
cout << "Исключение: " << a << endl;
}
}
Листинг 7.18. Команда throw передает номер ошибки

Если блок catch получает параметр типа int, он обрабатывает только

исключения, которые с помощью команды throw вызываются с помощью
числа как аргумента. Чтобы обработать другие параметры, определяется
другой блок catch с другими параметрами. Чтобы обработать все остав-
шиеся исключения, в самом конце можно разместить еще один блок catch
с тремя точками в качестве параметра. Точно так же, как и при перегрузке
функций (см. стр. 183) подходящий блок catch выбирается по подходя-
щим параметрам. Вообще, catch всегда имеет параметр. Автоматически
подходящий тип, как в функциях, здесь не срабатывает. Если, например,
использовать throw с аргументом 1.2, подходящий catch должен иметь
параметр double, а не float, потому что константы с плавающей запятой
обрабатываются компилятором как double. Следующий пример демон-
стрирует несколько блоков catch для различных типов.

// программа демонстрации различных блоков catch

#include <iostream>
using namespace std;
// do_smth использует различные типы, в
// зависимости от значения параметра ошибки.

335
Глава 7

void do_smth(int Problem)

{
switch (Problem)
{
case 0: throw 5; break; // передает int
case 1: throw (char *)"test.dat"; break;
// передает char *
case 2: throw 2.1; break; // передает double
case 3: throw 'c'; break; // передает char
}
}
// тестовая программа
int main()
{
// задать номер проблемы
int number;
cout << "Введите число от 0 до 3:" << endl;
cin >> number;
// блок try ловит значение do_smth
try
{
do_smth(number);
}
catch(int i) // обработка для int
{
cout << "Integer " << i << endl;
}
catch(char *s) // обработка для char*
{
cout << "Символьная последовательность " << s << endl;
}
catch(double f) // обработка для double
{
cout << "Число с плавающей запятой " << f << endl;

336
 Другие элементы языка C++

}
catch(...) // обработка для остальных исключений
{
cout << "Общий случай " << endl;
}
}
Листинг 7.19. Несколько блоков catch (throwtyp.cpp)

Если запустить программу, можно, выбирая числа от 0 до 3, опреде-

лить, какое исключение будет обработано. При 1 вам предложат сим-
вольную последовательность, которая затем обработается в блоке catch
в качестве параметра s. При 3 будет передан char, для которого не пред-
усмотрен catch. Поэтому для данного случая будет применен общий
catch.

7.3.2. Разработка классов ошибок

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

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

#include <iostream>
class no_data_already
{
};
void do_smth(int Problem)
{
...
throw no_data_already();
...
}
int main()
{
try

337
Глава 7

{
do_smth(0);
}
catch(no_data_already& )
{
std::cout << "Информация отсутствует " << std::endl;
}
}
Листинг 7.20. Собственный тип ошибки

Класс no_data_already ничего не содержит. Он не передает в об-

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

На основе этого легко добавить в класс ошибок также информацию

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

#include <iostream>
using namespace std;
class no_data_already
{
public:
no_data_already(int a) { nr = a; }
void show_error() { cout << nr << endl; }
private:
int nr;

338
 Другие элементы языка C++

};
void do_smth(int Problem)
{
if (Problem==0)
{
throw no_data_already(8);
}
}
int main()
{
try
{
do_smth(0);
}
catch(no_data_already& error)
{
error.show_error();
}
}
Листинг 7.21. Активный класс ошибки

Чтобы обработать различные ситуации возникновения ошибок,

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

#include <iostream>
using namespace std;
class meaCulpa // базовый класс ошибок
{
public:

339
Глава 7

virtual void show_error() = 0;

};
class any_data_already : public meaCulpa
{
public:
no_data_already(int a) { nr = a; }
void show_error() { cout << nr << endl; }
private:
int nr;
};
class missing_source : public meaCulpa
{
public:
missing_source() {}
void show_error()
{ cout << "Источник данных отсутствует " << endl; }
};
void do_smth(int Problem)
throw (no_data_already, missing_source)
{
if (Problem==0)
{
throw no_data_already(8);
}
if (Problem==1)
{
throw missing_source();
}
}
int main()
{
try
{
do_smth(0);

340
 Другие элементы языка C++

}
catch(meaCulpa& error)
{
error.show_error();
}
}
Листинг 7.22. Полиморфизм класса ошибки (tryclass.cpp)

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

пользуется указатель на передаваемый объект. Объект вызывает через
собственную таблицу виртуальных методов соответствующую функ-
цию show_error() (см. стр. 269). Такой же подход предлагают стандарт-
ные библиотеки. Используются классы, которые базируются на классе
exeption. Далее описано, как можно создать на базе него производный
класс.

В листинге 7.22 показано, что к функции do_smth() добавляется код,

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