- •Предварительные замечания
- •Структура книги
- •Глава 6 посвящена понятию производных классов, которое позволяет строить
- •Раздел 3.4 главы 2. Для обозначения справочного руководства применяется
- •1.1 Введение
- •1.2 Парадигмы программирования
- •1.2.1 Процедурное программирование
- •1.2.2 Модульное программирование
- •1.2.3 Абстракция данных
- •1.2.4 Пределы абстракции данных
- •1.2.5 Объектно-ориентированное программирование
- •1.3 "Улучшенный с"
- •1.3.1 Программа и стандартный вывод
- •1.3.2 Переменные и арифметические операции
- •1.3.3 Указатели и массивы
- •1.3.4 Условные операторы и циклы
- •1.3.5 Функции
- •1.3.6 Модули
- •1.4 Поддержка абстракции данных
- •1.4.1 Инициализация и удаление
- •1.4.2 Присваивание и инициализация
- •1.4.3 Шаблоны типа
- •1.4.4 Обработка особых ситуаций
- •1.4.5 Преобразования типов
- •1.4.6 Множественные реализации
- •1.5 Поддержка объектно-ориентированного программирования
- •1.5.1 Механизм вызова
- •1.5.2 Проверка типа
- •1.5.3 Множественное наследование
- •1.5.4 Инкапсуляция
- •1.6 Пределы совершенства
- •* Глава 2. Описания и константы
- •2.1 Описания
- •2.1.1 Область видимости
- •2.1.2 Объекты и адреса
- •2.1.3 Время жизни объектов
- •2.2 Имена
- •2.3 Типы
- •2.3.1 Основные типы
- •2.3.2 Неявное преобразование типа
- •2.3.3 Производные типы
- •2.3.4 Тип void
- •2.3.5 Указатели
- •2.3.6 Массивы
- •2.3.7 Указатели и массивы
- •2.3.8 Структуры
- •2.3.9 Эквивалентность типов
- •2.3.10 Ссылки
- •2.4 Литералы
- •2.4.1 Целые константы
- •2.4.2 Константы с плавающей точкой
- •2.4.3 Символьные константы
- •2.4.4 Строки
- •2.4.5 Нуль
- •2.5 Поименованные константы
- •2.5.1. Перечисления
- •2.6. Экономия памяти
- •2.6.1 Поля
- •2.6.2. Объединения
- •2.7 Упражнения
- •* Глава 3. Выражения и операторы
- •3.1 Калькулятор
- •3.1.1 Анализатор
- •3.1.2 Функция ввода
- •3.1.3 Таблица имен
- •3.1.4 Обработка ошибок
- •3.1.5 Драйвер
- •3.1.6 Параметры командной строки
- •3.2 Сводка операций
- •3.2.1 Скобки
- •3.2.2 Порядок вычислений
- •3.2.3 Инкремент и декремент
- •3.2.4 Поразрядные логические операции
- •3.2.5 Преобразование типа
- •3.2.6 Свободная память
- •3.3 Сводка операторов
- •3.3.1 Выбирающие операторы
- •3.3.2 Оператор goto
- •3.4 Комментарии и расположение текста
- •3.5 Упражнения
- •* Глава 4
- •4.1 Введение
- •4.2 Связывание
- •4.3 Заголовочные файлы
- •4.3.1 Единственный заголовочный файл
- •4.3.2 Множественные заголовочные файлы
- •4.4 Связывание с программами на других языках
- •4.5 Как создать библиотеку
- •4.6 Функции
- •4.6.1 Описания функций
- •4.6.2 Определения функций
- •4.6.3 Передача параметров
- •4.6.4 Возвращаемое значение
- •4.6.5 Параметр-массив
- •4.6.6 Перегрузка имени функции
- •4.6.7 Стандартные значения параметров
- •4.6.8 Неопределенное число параметров
- •4.6.9 Указатель на функцию
- •4.7 Макросредства
- •4.8 Упражнения
- •* Глава 5. Классы
- •5.1 Введение и краткий обзор
- •5.2 Классы и члены
- •5.2.1 Функции-члены
- •5.2.2 Классы
- •5.2.3 Ссылка на себя
- •5.2.4 Инициализация
- •5.2.5 Удаление
- •5.2.6 Подстановка
- •5.3 Интерфейсы и реализации
- •5.3.1 Альтернативные реализации
- •5.3.2 Законченный пример класса
- •5.4 Еще о классах
- •5.4.1 Друзья
- •5.4.2 Уточнение имени члена
- •5.4.3 Вложенные классы
- •5.4.4 Статические члены
- •5.4.5 Указатели на члены
- •5.4.6 Структуры и объединения
- •5.5 Конструкторы и деструкторы
- •5.5.1 Локальные переменные
- •5.5.2 Статическая память
- •5.5.3 Свободная память
- •5.5.4 Объекты класса как члены
- •5.5.5 Массивы объектов класса
- •5.5.6 Небольшие объекты
- •5.6 Упражнения
- •* Глава 6
- •6.1 Введение и краткий обзор
- •6.2 Производные классы
- •6.2.1 Функции-члены
- •6.2.2 Конструкторы и деструкторы
- •6.2.3 Иерархия классов
- •6.2.4 Поля типа
- •6.2.5 Виртуальные функции
- •6.3 Абстрактные классы
- •6.4 Пример законченной программы
- •6.4.1 Монитор экрана
- •6.4.2 Библиотека фигур
- •6.4.3 Прикладная программа
- •6.5 Множественное наследование
- •6.5.1 Множественное вхождение базового класса
- •6.5.2 Разрешение неоднозначности
- •6.5.3 Виртуальные базовые классы
- •6.6 Контроль доступа
- •6.6.1 Защищенные члены
- •6.6.2 Доступ к базовым классам
- •6.7 Свободная память
- •6.7.1 Виртуальные конструкторы
- •6.7.2 Указание размещения
- •6.8 Упражнения
- •* Глава 7
- •7.1 Введение
- •7.2 Операторные функции
- •7.2.1 Бинарные и унарные операции
- •7.2.2 Предопределенные свойства операций
- •7.2.3 Операторные функции и пользовательские типы
- •7.3 Пользовательские операции преобразования типа
- •7.3.1 Конструкторы
- •7.3.2 Операции преобразования
- •7.3.3 Неоднозначности
- •7.4 Литералы
- •7.5 Большие объекты
- •7.6 Присваивание и инициализация
- •7.7 Индексация
- •7.8 Вызов функции
- •7.9 Косвенное обращение
- •7.10 Инкремент и декремент
- •7.11 Строковый класс
- •7.12 Друзья и члены
- •7.13 Предостережения
- •7.14 Упражнения
- •* Глава 8. Шаблоны типа
- •8.1 Введение
- •8.2 Простой шаблон типа
- •8.3 Шаблоны типа для списка
- •8.3.1 Список с принудительной связью
- •8.3.2 Список без принудительной связи
- •8.3.3 Реализация списка
- •8.3.4 Итерация
- •8.4 Шаблоны типа для функций
- •8.4.1 Простой шаблон типа для глобальной функции
- •8.4.2 Производные классы позволяют ввести новые операции
- •8.4.3 Передача операций как параметров функций
- •8.4.4 Неявная передача операций
- •8.4.5 Введение операций с помощью параметров шаблонного класса
- •8.5 Разрешение перегрузки для шаблонной функции
- •8.6 Параметры шаблона типа
- •8.7 Шаблоны типа и производные классы
- •8.7.1 Задание реализации с помощью параметров шаблона
- •8.8 Ассоциативный массив
- •8.9 Упражнения
- •* Глава 9
- •9.1 Обработка ошибок
- •9.1.1 Особые ситуации и традиционная обработка ошибок
- •9.1.2 Другие точки зрения на особые ситуации
- •9.2 Различение особых ситуаций
- •9.3 Имена особых ситуаций
- •9.3.1 Группирование особых ситуаций
- •9.3.2 Производные особые ситуации
- •9.4 Запросы ресурсов
- •9.4.1 Конструкторы и деструкторы
- •9.4.2 Предостережения
- •9.4.3 Исчерпание ресурса
- •9.4.4 Особые ситуации и конструкторы
- •9.5 Особые ситуации могут не быть ошибками
- •9.6 Задание интерфейса
- •9.6.1 Неожиданные особые ситуации
- •9.7 Неперехваченные особые ситуации
- •9.8 Другие способы обработки ошибок
- •9.9 Упражнения
- •* Глава 10. Потоки
- •10.1 Введение
- •10.2 Вывод
- •10.2.1 Вывод встроенных типов
- •10.2.2 Вывод пользовательских типов
- •10.3 Ввод
- •10.3.1 Ввод встроенных типов
- •10.3.2 Состояния потока
- •10.3.3 Ввод пользовательских типов
- •10.4 Форматирование
- •10.4.1 Класс ios
- •10.4.1.1 Связывание потоков
- •10.4.1.2 Поля вывода
- •10.4.1.3 Состояние формата
- •10.4.1.4 Вывод целых
- •10.4.1.5 Выравнивание полей
- •10.4.1.6 Вывод плавающих чисел.
- •10.4.2 Манипуляторы
- •10.4.2.1 Стандартные манипуляторы ввода-вывода
- •10.4.3 Члены ostream
- •10.4.4 Члены istream
- •10.5 Файлы и потоки
- •10.5.1 Закрытие потоков
- •10.5.2 Строковые потоки
- •10.5.3 Буферизация
- •10.6 Ввод-вывод в с
- •10.7 Упражнения
- •* Проектирование и развитие
- •11.1 Введение
- •11.2 Цели и средства
- •11.3 Процесс развития
- •11.3.1 Цикл развития
- •11.3.2 Цели проектирования
- •11.3.3 Шаги проектирования
- •11.3.3.1 Шаг 1: определение классов
- •11.3.3.2 Шаг 2: определение набора операций
- •11.3.3.3 Шаг 3: указание зависимостей
- •11.3.3.4 Шаг 4: определение интерфейсов
- •11.3.3.5 Перестройка иерархии классов
- •11.3.3.6 Использование моделей
- •11.3.4 Эксперимент и анализ
- •11.3.5 Тестирование
- •11.3.6 Сопровождение
- •11.3.7 Эффективность
- •11.4 Управление проектом
- •11.4.1 Повторное использование
- •11.4.2 Размер
- •11.4.3 Человеческий фактор
- •11.5 Свод правил
- •11.6 Список литературы с комментариями
- •12.1 Проектирование и язык программирования.
- •12.1.1 Игнорирование классов
- •12.1.2 Игнорирование наследования
- •12.1.3 Игнорирование статического контроля типов
- •12.1.4 Гибридный проект
- •12.2 Классы
- •12.2.1 Что представляют классы?
- •12.2.2 Иерархии классов
- •12.2.3 Зависимости в рамках иерархии классов.
- •12.2.4 Отношения принадлежности
- •12.2.5 Принадлежность и наследование
- •12.2.6 Отношения использования
- •12.2.7 Отношения внутри класса
- •12.2.7.1 Инварианты
- •12.2.7.2 Инкапсуляция
- •12.2.8 Программируемые отношения
- •12.3 Компоненты
- •12.4 Интерфейсы и реализации
- •12.5 Свод правил
- •* Проектирование библиотек
- •13.1 Введение
- •13.2 Конкретные типы
- •13.3 Абстрактные типы
- •13.4 Узловые классы
- •13.5 Динамическая информация о типе
- •13.5.1 Информация о типе
- •13.5.2 Класс Type_info
- •13.5.3 Как создать систему динамических запросов о типе
- •13.5.4 Расширенная динамическая информация о типе
- •13.5.5 Правильное и неправильное использование динамической
- •13.6 Обширный интерфейс
- •13.7 Каркас области приложения
- •13.8 Интерфейсные классы
- •13.9 Управляющие классы
- •13.10 Управление памятью
- •13.10.1 Сборщик мусора
- •13.10.2 Контейнеры и удаление
- •13.10.3 Функции размещения и освобождения
- •13.11 Упражнения
12.1 Проектирование и язык программирования.
Если бы мне надо было построить мост, то я серьезно подумал бы, из
какого материала его строить, и проект моста сильно зависел бы от
выбранного материала, а, следовательно, разумные проекты каменного
моста отличаются от разумных проектов металлического моста или
от разумных проектов деревянного моста и т.д. Не стоит
рассчитывать на выбор подходящего для моста материала без определенных
знаний о материалах и их использовании. Конечно, вам не надо быть
специалистом плотником для проектирования деревянного моста, но вы
должны знать основы конструирования из дерева, чтобы предпочесть его
металлу в качестве материала для моста. Более того, хотя для
проектирования деревянного моста вы и не должны быть специалистом
плотником, вам необходимо достаточно детально знать свойства
дерева и еще больше знать о плотниках.
Аналогично, при выборе языка программирования для
определенного программного обеспечения надо знать несколько языков,
а для успешного проектирования программы надо достаточно детально
знать выбранный язык реализации, даже если вам лично не предстоит
написать ни одной строчки программы. Хороший проектировщик моста
ценит свойства используемых им материалов и применяет их для улучшения
проекта. Аналогично, хороший разработчик программ использует сильные
стороны языка реализации и, насколько возможно, стремится избежать такого
его использования, которое вызовет трудности на стадии реализации.
Можно подумать, что так получается естественным образом, если
в проектировании участвует только один разработчик или программист, однако
даже в этом случае программист в силу недостатка опыта или из-за
неоправданной приверженности к стилю программирования, рассчитанному на
совершенно другие языки, может сбиться на неверное использование языка.
Если разработчик существенно отличается от программиста, особенно
если у них разная программистская культура, возможность появления
в окончательной версии системы ошибок, неэффективных и неэлегантных решений
почти наверняка превратится в неизбежность.
Итак, чем может помочь разработчику язык программирования? Он
может предоставить такие языковые средства, которые позволят
выразить прямо на языке программирования основные понятия проекта.
Тогда облегчается реализация, проще поддерживать ее соответствие
проекту, проще организовать общение между
разработчиками и программистами, и появляется возможность создать
более совершенные средства как для разработчиков, так и для
программистов.
Например, многие методы проектирования уделяют значительное внимание
зависимостям между различными частями программы (обычно с целью
их уменьшения и гарантии того, что эти части будут понятны и хорошо
определены). Язык, допускающий явное задание интерфейсов между
частями программы, может помочь в этом вопросе
разработчикам. Он может гарантировать, что действительно будут
существовать только предполагаемые зависимости. Поскольку
большинство зависимостей явно выражено в программе на таком языке,
можно разработать средства, читающие программу и выдающие графы
зависимостей. В этом случае разработчику и другим исполнителям легче
уяснить структуру программы. Такие языки программирования как С++
помогают сократить разрыв между проектом и программой, а значит
уменьшают возможность путаницы и недопониманий.
Базовое понятие С++ - это класс. Класс имеет определенный
тип. Кроме того, класс является первичным средством упрятывания
информации. Можно описывать программы в терминах пользовательских
типов и иерархий этих типов. Как встроенные, так и пользовательские
типы подчиняются правилам статического контроля типов. Виртуальные
функции предоставляют, не нарушая правил статических типов,
механизм связывания на этапе выполнения. Шаблоны типа позволяют
создавать параметризованные типы. Особые ситуации позволяют сделать
регулярной реакцию на ошибки. Все эти средства С++ можно
использовать без дополнительных накладных
расходов в сравнении с программой на С. Таковы главнейшие
средства С++, которые должен представлять и учитывать разработчик.
Кроме того, существенно повлиять на принятие решений на стадии
проектирования может наличие доступных больших библиотек
следующего назначения: для работы с матрицами, для связи с
базами данных, для поддержки параллельного
программирования, графические библиотеки и т.д.
Страх перед новизной, непригодный здесь опыт работы на других
языках, в других системах или областях приложения, бедные средства
проектирования - все это приводит к неоптимальному использованию С++.
Следует отметить три момента, когда разработчику не удается
извлечь выгоду из возможностей С++ и учесть ограничения языка:
[1] Игнорирование классов и составление проекта таким образом, что
программистам приходится ограничиваться только С.
[2] Игнорирование производных классов и виртуальных функций,
использование только подмножества абстрактных данных.
[3] Игнорирование статического контроля типов и составление проекта
таким образом, что программисты вынуждены применять динамические
проверки типов.
Обычно указанные моменты возникают у разработчиков, связанных с:
[1] C, или традиционной системой CASE или методами структурного
проектирования;
[2] Адой или методами проектирования с помощью абстракции данных;
[3] языками, близкими Smalltalk или Lisp.
В каждом случае следует решить: неправильно выбран язык
реализации (считая, что метод проектирования выбран верно), или
разработчику не удалось приспособиться и оценить язык (считая, что
язык реализации выбран верно).
Следует сказать, что нет ничего необычного или позорного в
таком расхождении. Просто это расхождение, которое приведет к
неоптимальному проекту, возложит дополнительную работу на
программистов, а в случае, когда структура понятий проекта
значительно беднее структуры языка С++, то и на самих разработчиков.
Отметим, что необязательно все программы должны
структурироваться опираясь на понятия классов и (или) иерархий классов,
и необязательно всякая программа должна использовать все средства,
предоставляемые С++. Как раз наоборот, для успеха проекта необходимо,
чтобы людям не навязывали использование языковых средств, с которыми
они только познакомились. Цель последующего изложения не в том,
чтобы навязать догматичное использование классов, иерархий и
строго типизированных интерфейсов, а в том, чтобы показать
возможности их использования всюду, где позволяет область
приложения, ограничения С++ и опыт исполнителей. В $$12.1.4 будут
рассмотрены подходы к различному использованию С++ в проекте
под заголовком "Проект-гибрид".