Дизайн и эволюция С++
Покупка
Тематика:
Программирование на C и C++
Издательство:
ДМК Пресс
Автор:
Страуструп Бьерн
Год издания: 2007
Кол-во страниц: 448
Дополнительно
Вид издания:
Учебно-методическая литература
Уровень образования:
Аспирантура
ISBN: 978-5-97060-419-9
Артикул: 616303.01.99
К покупке доступен более свежий выпуск
Перейти
В книге, написанной создателем языка C++ Бьерном Страуструпом, представлено описание процесса проектирования и разработки языка программирования C++. Здесь изложены цели, принципы и практические ограничения, наложившие отпечаток на структуру и облик C++, обсужден дизайн недавно добавленных в язык средств: шаблонов, исключений, идентификации типа во время исполнения и пространств имен. Автор анализирует решения, принятые в ходе работы над языком, и демонстрирует, как правильно применять «реальный объектно-ориентированный язык программирования». Книга удобно организована, поучительна, написана с юмором. Описание ключевых идей даст начинающему пользователю ту основу, на которой позже он выстроит свое понимание всех деталей языка. Опытный программист найдет здесь обсуждение принципиальных вопросов проектирования, что позволит ему лучше понять язык, с которым он работает.
Тематика:
ББК:
УДК:
ОКСО:
- ВО - Бакалавриат
- 09.03.01: Информатика и вычислительная техника
- 09.03.02: Информационные системы и технологии
- 09.03.03: Прикладная информатика
- 09.03.04: Программная инженерия
ГРНТИ:
Скопировать запись
Фрагмент текстового слоя документа размещен для индексирующих роботов.
Для полноценной работы с документом, пожалуйста, перейдите в
ридер.
Бьерн Страуструп Дизайн и эволюция С++
The Design and Evolution of C++ Bjarne Stroustrup An imprint of Addison Wesley Longman, Inc. Reading, Massachusetts • Harlow, England • Menlo Park, California Berkeley, California • Don Mills, Ontario • Sydney Bonn • Amsterdam • Tokyo • Mexico City
Дизайн и эволюция С++ Бьерн Страуструп Серия «Для программистов» Москва
ББК 32.973.26018.1 С80 Страуструп Б. С80 Дизайн и эволюция С++: Пер. с англ. – М.: ДМК Пресс. – 448 с.: ил. (Серия «Для программистов»). ISBN 5940740057 В книге, написанной создателем языка C++ Бьерном Страуструпом, представлено описание процесса проектирования и разработки языка программирования C++. Здесь изложены цели, принципы и практические ограничения, наложившие отпечаток на структуру и облик C++, обсужден дизайн недавно добавленных в язык средств: шаблонов, исключений, идентификации типа во время исполнения и пространств имен. Автор анализирует решения, принятые в ходе работы над языком, и демонстрирует, как правильно применять «реальный объектноориентированный язык программирования». Книга удобно организована, поучительна, написана с юмором. Описание ключевых идей даст начинающему пользователю ту основу, на которой позже он выстроит свое понимание всех деталей языка. Опытный программист найдет здесь обсуждение принципиальных вопросов проектирования, что позволит ему лучше понять язык, с которым он работает. ББК 32.973.26018.1 Права на издание книги были получены по соглашению с Addison Wesley Longman, Inc. и Литературным агенством Мэтлок (СанктПетербург). Все права защищены. Любая часть этой книги не может быть воспроизведена в какой бы то ни было форме и какими бы то ни было средствами без письменного разрешения владельцев авторских прав. Материал, изложенный в данной книге, многократно проверен. Но, поскольку вероятность технических ошибок все равно существует, издательство не может гарантировать абсолютную точность и правильность приводимых сведений. В связи с этим издательство не несет ответственности за возможные ошибки, связанные с использованием книги. ISBN 0201543303 (англ.) Copyright © by AT&T Bell Labs. ISBN 5940740057 (рус.) © Перевод на русский язык, оформление. ДМК Пресс
Содержание Предисловие .................................................................................................... 13 Благодарности ................................................................................................ 15 Обращение к читателю ............................................................................... 16 Часть I ............................................................................................................ 29 Глава 1. Предыстория C++ ........................................................................ 30 1.1. Язык Simula и распределенные системы ............................................... 30 1.2. Язык C и системное программирование ............................................... 33 1.3. Немного об авторе книги ....................................................................... 33 Глава 2. Язык С with Classes ....................................................................... 36 2.1. Рождение C with Classes ......................................................................... 36 2.2. Обзор языковых возможностей ............................................................. 38 2.3. Классы ...................................................................................................... 39 2.4. Эффективность исполнения ................................................................... 41 2.4.1. Встраивание ...................................................................................... 42 2.5. Модель компоновки ................................................................................ 43 2.5.1. Простые реализации ........................................................................... 46 2.5.2. Модель размещения объекта в памяти .................................................. 48 2.6. Статический контроль типов .................................................................. 49 2.6.1. Сужающие преобразования ................................................................ 50 2.6.2. О пользе предупреждений ................................................................... 51 2.7. Почему C? ................................................................................................ 52 2.8 Проблемы синтаксиса ............................................................................. 54 2.8.1. Синтаксис объявлений в языке C ........................................................... 54 2.8.2. Тэги структур и имена типов ................................................................. 56 2.8.3. Важность синтаксиса .......................................................................... 58 2.9. Производные классы ............................................................................... 58 2.9.1. Полиморфизм без виртуальных функций ................................................ 59 2.9.2. Контейнерные классы без шаблонов ..................................................... 60 2.9.3. Модель размещения объекта в памяти .................................................. 61 2.9.4. Ретроспектива ................................................................................... 62 2.10. Модель защиты ...................................................................................... 62
2.11. Гарантии времени исполнения ............................................................ 65 2.11.1. Конструкторы и деструкторы .............................................................. 65 2.11.2. Распределение памяти и конструкторы ................................................ 66 2.11.3. Функции call и return .......................................................................... 67 2.12. Менее существенные средства ........................................................... 67 2.12.1. Перегрузка оператора присваивания ................................................. 67 2.12.2. Аргументы по умолчанию ................................................................... 68 2.13. Что не реализовано в C with Classes ................................................. 69 2.14. Рабочая обстановка ............................................................................. 70 Глава 3. Рождение С++ ............................................................................... 73 3.1. От C with Classes к C++ .......................................................................... 73 3.2. Цели С++ .................................................................................................. 74 3.3. Компилятор Cfront ................................................................................... 76 3.3.1. Генерирование Скода ........................................................................ 77 3.3.2. Синтаксический анализ C++ ................................................................ 79 3.3.3. Проблемы компоновки ........................................................................ 80 3.3.4. Версии Cfront ..................................................................................... 80 3.4. Возможности языка ................................................................................. 82 3.5. Виртуальные функции .............................................................................. 82 3.5.1. Модель размещения объекта в памяти .................................................. 85 3.5.2. Замещение и поиск подходящей виртуальной функции ............................ 87 3.5.3. Сокрытие членов базового класса ........................................................ 87 3.6. Перегрузка ............................................................................................... 88 3.6.1. Основы перегрузки ............................................................................. 89 3.6.2. Функциичлены и дружественные функции .............................................. 91 3.6.3. Операторные функции ........................................................................ 93 3.6.4. Перегрузка и эффективность ................................................................ 94 3.6.5. Изменение языка и новые операторы .................................................... 96 3.7. Ссылки ...................................................................................................... 96 3.7.1. Lvalue и Rvalue .................................................................................... 98 3.8. Константы ................................................................................................. 99 3.9. Управление памятью ............................................................................. 101 3.10. Контроль типов .................................................................................... 103 3.11. Второстепенные возможности ........................................................... 104 3.11.1. Комментарии ................................................................................. 104 3.11.2. Нотация для конструкторов .............................................................. 104 3.11.3. Квалификация ................................................................................ 105 3.11.4. Инициализация глобальных объектов ................................................ 106 3.11.5. Предложения объявления ................................................................ 109 3.12. Языки C и C++ ...................................................................................... 111 3.13. Инструменты для проектирования языка .......................................... 114 Дизайн и эволюция С++
3.14. Книга «Язык программирования С++» .............................................. 116 3.15. Статья «Whatis?» .................................................................................. 117 Глава 4. Правила проектирования языка C++ ................................ 120 4.1. Правила и принципы ........................................................................... 120 4.2. Общие правила ................................................................................... 121 4.3. Правила поддержки проектирования ............................................... 125 4.4. Технические правила .......................................................................... 128 4.5. Правила поддержки низкоуровневого программирования ........... 132 4.6. Заключительное слово ........................................................................ 134 Глава 5. Хронология 1985–1993 гг. .................................................. 135 5.1. Введение ............................................................................................... 135 5.2. Версия 2.0 ............................................................................................ 136 5.2.1. Обзор возможностей ...................................................................... 137 5.3. Аннотированное справочное руководство ...................................... 138 5.3.1. Обзор ARM ................................................................................... 139 5.4. Стандартизация ANSI и ISO .............................................................. 140 5.4.1. Обзор возможностей ...................................................................... 143 Глава 6. Стандартизация ......................................................................... 144 6.1. Что такое стандарт? ............................................................................ 144 6.1.1. Детали реализации ........................................................................ 145 6.1.2. Тест на реалистичность .................................................................... 146 6.2. Работа комитета .................................................................................. 146 6.2.1. Кто работает в комитете .................................................................. 148 6.3. Как велась работа ............................................................................... 148 6.3.1. Разрешение имен ........................................................................... 149 6.3.2. Время жизни объектов ..................................................................... 153 6.4. Расширения .......................................................................................... 157 6.4.1. Критерии рассмотрения предложений .............................................. 159 6.4.2. Текущее состояние дел .................................................................... 161 6.4.3. Проблемы, связанные с полезными расширениями ............................. 162 6.4.4. Логическая непротиворечивость ....................................................... 163 6.5. Примеры предлагавшихся расширений ........................................... 164 6.5.1. Именованные аргументы ................................................................. 164 6.5.2. Ограниченные указатели ................................................................ 168 6.5.3. Наборы символов ........................................................................... 169 Глава 7. Заинтересованность и использование ............................. 174 7.1. Рост интереса к C++ ............................................................................ 174 7.1.1. Отсутствие маркетинга C++ ............................................................. 175 7.1.2. Конференции ................................................................................. 175 Содержание
7.1.3. Журналы и книги ............................................................................... 176 7.1.4. Компиляторы .................................................................................... 177 7.1.5. Инструментальные средства и среды программирования ...................... 177 7.2. Преподавание и изучение C++ ........................................................... 178 7.3. Пользователи и приложения ................................................................ 183 7.3.1. Первые пользователи ........................................................................ 183 7.3.2. Сферы применения C++ .................................................................... 184 7.4. Коммерческая конкуренция ................................................................. 184 7.4.1. Традиционные языки ......................................................................... 185 7.4.2. Современные языки .......................................................................... 186 7.4.3. Как выдержать конкуренцию .............................................................. 187 Глава 8. Библиотеки .................................................................................... 189 8.1. Введение ................................................................................................. 189 8.2. Проектирование библиотеки C++ ...................................................... 189 8.2.1. Альтернативы при проектировании библиотеки .................................... 190 8.2.2. Языковые средства и построение библиотеки ....................................... 190 8.2.3. Как работать с разнообразными библиотеками ................................... 191 8.3. Ранние библиотеки ............................................................................... 192 8.3.1. Библиотека потокового ввода/вывода ................................................ 193 8.3.2. Поддержка параллельности ............................................................... 196 8.4. Другие библиотеки ................................................................................ 198 8.4.1. Базовые библиотеки ......................................................................... 199 8.4.2. Устойчивость и базы данных ............................................................... 200 8.4.3. Библиотеки для численных расчетов .................................................... 200 8.4.4. Специализированные библиотеки ...................................................... 201 8.5. Стандартная библиотека ..................................................................... 201 Глава 9. Перспективы развития языка С++ ....................................... 203 9.1. Введение ................................................................................................. 203 9.2. Оценка пройденного пути .................................................................... 203 9.2.1. Достигнуты ли основные цели C++? ..................................................... 204 9.2.2. Является ли C++ логически последовательным языком? ......................... 204 9.2.3. Основная недоработка языка ............................................................ 207 9.3. Всего лишь мост? ................................................................................... 208 9.3.1. Мост нужен надолго ......................................................................... 208 9.3.2. Если C++ – это ответ, то на какой вопрос? .......................................... 209 9.4. Что может сделать C++ более эффективным ..................................... 213 9.4.1. Стабильность и стандарты ................................................................. 213 9.4.2. Обучение и приемы .......................................................................... 213 9.4.3. Системные вопросы .......................................................................... 213 9.4.4. За пределами файлов и синтаксиса .................................................... 214 9.4.5. Подведение итогов и перспективы ...................................................... 215 Дизайн и эволюция С++
Часть II ........................................................................................ 217 Глава 10. Управление памятью .............................................................. 218 10.1. Введение .............................................................................................. 218 10.2. Отделение распределения памяти и инициализации ...................... 219 10.3. Выделение памяти для массива .......................................................... 220 10.4. Размещение объекта в памяти .......................................................... 221 10.5. Проблемы освобождения памяти ...................................................... 222 10.5.1. Освобождение памяти для массивов ................................................. 224 10.6. Нехватка памяти .................................................................................. 225 10.7. Автоматическая сборка мусора ........................................................ 226 10.7.1. Необязательный сборщик мусора ..................................................... 226 10.7.2. Как должен выглядеть необязательный сборщик мусора? ..................... 228 Глава 11. Перегрузка ................................................................................. 230 11.1. Введение .............................................................................................. 230 11.2. Разрешение перегрузки ..................................................................... 230 11.2.1. Детальное разрешение ................................................................... 231 11.2.2. Управление неоднозначностью ........................................................ 233 11.2.3. Нулевой указатель .......................................................................... 236 11.2.4. Ключевое слово overload ................................................................. 238 11.3. Типобезопасная компоновка ............................................................. 239 11.3.1. Перегрузка и компоновка ................................................................ 239 11.3.2. Реализация компоновки в C++ ......................................................... 240 11.3.3. Анализ пройденного пути ................................................................ 241 11.4. Создание и копирование объектов .................................................. 244 11.4.1. Контроль допустимости копирования ................................................ 244 11.4.2. Управление распределением памяти ................................................. 244 11.4.3. Управление наследованием ............................................................. 245 11.4.4. Почленное копирование .................................................................. 246 11.5. Удобство нотации ................................................................................ 248 11.5.1. «Умные» указатели .......................................................................... 248 11.5.2. «Умные» ссылки .............................................................................. 249 11.5.3. Перегрузка операторов инкремента и декремента ............................. 252 11.5.4. Перегрузка >* ............................................................................... 254 11.5.5. Перегрузка оператора «запятая» ..................................................... 254 11.6. Добавление в C++ операторов ........................................................ 254 11.6.1. Оператор возведения в степень ....................................................... 254 11.6.2. Операторы, определяемые пользователем ........................................ 257 11.6.3. Составные операторы ..................................................................... 258 11.7. Перечисления ...................................................................................... 259 11.7.1 Перегрузка на базе перечислений ..................................................... 261 11.7.2. Тип Boolean .................................................................................... 261 Содержание
Глава 12. Множественное наследование .......................................... 263 12.1. Введение .............................................................................................. 263 12.2. Базовые классы ................................................................................... 264 12.3. Виртуальные базовые классы ............................................................ 265 12.3.1. Виртуальные базовые классы и виртуальные функции .......................... 267 12.4. Модель размещения объекта в памяти ............................................. 270 12.4.1. Размещение в памяти объекта виртуального базового класса .............. 272 12.4.2. Виртуальные базовые классы и приведение типов ............................... 273 12.5. Комбинирование методов .................................................................. 274 12.6. Полемика о множественном наследовании .................................... 276 12.7. Делегирование .................................................................................... 279 12.8. Переименование ................................................................................. 280 12.9. Инициализаторы членов и базовых классов .................................... 282 Глава 13. Уточнения понятия класса .................................................... 284 13.1 Введение ............................................................................................... 284 13.2. Абстрактные классы ............................................................................ 284 13.2.1. Абстрактные классы и обработка ошибок ......................................... 284 13.2.2. Абстрактные типы ........................................................................... 286 13.2.3. Синтаксис ...................................................................................... 288 13.2.4. Виртуальные функции и конструкторы ................................................ 288 13.3. Константные функциичлены .............................................................. 291 13.3.1. Игнорирование const при приведении типов ...................................... 291 13.3.2. Уточнение определения const ........................................................... 292 13.3.3. Ключевое слово mutable и приведение типов ..................................... 293 13.4. Статические функциичлены ............................................................... 294 13.5. Вложенные классы ............................................................................... 295 13.6. Ключевое слово inherited ................................................................... 297 13.7. Ослабление правил замещения ........................................................ 299 13.7.1. Ослабление правил аргументов ....................................................... 301 13.8. Мультиметоды ...................................................................................... 303 13.8.1. Когда нет мультиметодов ................................................................. 305 13.9. Защищенные члены ............................................................................. 307 13.10. Улучшенная генерация кода ............................................................ 308 13.11. Указатели на функциичлены ........................................................... 309 Глава 14. Приведение типов ................................................................... 311 14.1. Крупные расширения .......................................................................... 311 14.2. Идентификация типа во время исполнения ...................................... 312 14.2.1. Зачем нужен механизм RTTI ............................................................. 313 14.2.2. Оператор dynamic_cast .................................................................. 313 14.2.3. Правильное и неправильное использование RTTI ................................ 319 Дизайн и эволюция С++
14.2.4. Зачем давать «опасные средства» ..................................................... 321 14.2.5. Оператор typeid() ........................................................................... 322 14.2.6. Модель размещения объекта в памяти .............................................. 326 14.2.7. Простой ввод/вывод объектов .......................................................... 327 14.2.8. Другие варианты ............................................................................. 329 14.3. Новая нотация для приведения типов ............................................... 333 14.3.1. Недостатки старых приведений типов ................................................ 334 14.3.2. Оператор static_cast ....................................................................... 335 14.3.3. Оператор reinterpret_cast ................................................................ 337 14.3.4. Оператор const_cast ....................................................................... 339 14.3.5. Преимущества новых приведений типов ............................................ 340 Глава 15. Шаблоны ..................................................................................... 343 15.1. Введение .............................................................................................. 343 15.2. Зачем нужны шаблоны ....................................................................... 344 15.3. Шаблоны классов ............................................................................... 346 15.3.1. Аргументы шаблонов, не являющиеся типами ..................................... 347 15.4. Ограничения на аргументы шаблонов ............................................. 348 15.4.1. Ограничения за счет наследования ................................................... 349 15.4.2. Ограничения за счет использования ................................................. 350 15.5. Устранение дублирования кода ........................................................ 351 15.6. Шаблоны функций ............................................................................... 353 15.6.1. Выведение аргументов шаблона функции .......................................... 354 15.6.2. Задание аргументов шаблона функции ............................................. 355 15.6.3. Перегрузка шаблона функции .......................................................... 357 15.7. Синтаксис ............................................................................................. 360 15.8. Методы композиции ............................................................................ 361 15.8.1. Представление стратегии реализации ............................................... 362 15.8.2. Представление отношений порядка .................................................. 363 15.9. Соотношения между шаблонами классов ....................................... 365 15.9.1. Отношения наследования ................................................................ 365 15.9.2. Преобразования ............................................................................ 367 15.9.3. Шаблонычлены ............................................................................. 368 15.10. Инстанцирование шаблонов ........................................................... 369 15.10.1. Явное инстанцирование ................................................................. 371 15.10.2. Точка инстанцирования ................................................................. 372 15.10.3. Специализация ............................................................................. 378 15.10.4. Нахождение определений шаблонов ............................................... 381 15.11. Последствия введения шаблонов .................................................... 383 15.11.1. Отделение реализации от интерфейса ............................................ 384 15.11.2. Гибкость и эффективность .............................................................. 384 15.11.3. Влияние на другие компоненты C++ ................................................ 385 Содержание
Глава 16. Обработка исключений ........................................................ 387 16.1. Введение .............................................................................................. 387 16.2. Цели и предположения ....................................................................... 388 16.3. Синтаксис ............................................................................................. 389 16.4. Группировка ......................................................................................... 390 16.5. Управление ресурсами ...................................................................... 391 16.5.1. Ошибки в конструкторах ................................................................. 393 16.6. Возобновление или завершение? ..................................................... 394 16.6.1. Обходные пути для реализации возобновления .................................. 397 16.7. Асинхронные события ......................................................................... 398 16.8. Распространение на несколько уровней ......................................... 399 16.9. Статическая проверка ........................................................................ 399 16.9.1. Вопросы реализации ....................................................................... 401 16.10. Инварианты ....................................................................................... 402 Глава 17. Пространства имен ................................................................ 403 17.1. Введение .............................................................................................. 403 17.2. Для чего нужны пространства имен .................................................. 404 17.2.1. Обходные пути ............................................................................... 404 17.3. Какое решение было бы лучшим? ..................................................... 406 17.4. Решение: пространства имен ............................................................ 408 17.4.1. Мнения по поводу пространств имен ................................................. 410 17.4.2. Внедрение пространств имен .......................................................... 411 17.4.3. Псевдонимы пространства имен ....................................................... 412 17.4.4. Использование пространств имен для управления версиями ................ 413 17.4.5. Технические детали ......................................................................... 415 17.5. Классы и пространства имен ............................................................. 421 17.5.1. Производные классы ....................................................................... 421 17.5.2. Использование базовых классов ...................................................... 423 17.5.3. Исключение глобальных статических объявлений ................................ 424 17.6. Совместимость с C .............................................................................. 425 Глава 18. Препроцессор C ...................................................................... 427 Алфавитный указатель ............................................................................... 431 Дизайн и эволюция С++
Предисловие Кто не пашет, должен писать. Мартин А. Хансен На второй конференции ACM по истории языков программирования (HOPL2) меня попросили написать статью по истории C++. Мысль показалась мне разумной, предложение – лестным, поэтому я приступил к работе. Чтобы работа получилась более полной и неискаженной, я обратился за помощью к друзьям. Вслед за этим молва разнесла известие о готовящемся проекте. Не обошлось без преувеличений – и однажды я получил по электронной почте письмо с вопросом, где можно купить мою новую книгу о дизайне C++. Оно и положило начало этой серьезной работе. Обычно в книгах по программированию и его языкам объясняется, чтó представляет собой язык и как им пользоваться. Но многих интересует вопрос, почему язык оказался именно таким и как он создавался. Именно об этом, применительно к C++, и говорится в данной книге. В ней рассказывается, как шла эволюция языка от первоначального проекта до нынешнего состояния, объясняются основные задачи и цели проектирования, заложенные в языке идеи и ограничения, описывается развитие языковых концепций. Естественно, ни C++, ни представления о его дизайне и применении не изменялись сами собой. В действительности эволюционировали сознание пользователей и их представления о том, какие перед ними стоят цели и какие инструменты необходимы для решения. А значит, в книге говорится о наиболее важных вопросах, которые снимались с помощью C++, а также о людях, решавших эти задачи и оказавших влияние на развитие языка, и их воззрениях. C++ – все еще сравнительно молодой язык. Некоторые из обсуждаемых в книге проблем пока неизвестны широкой публике. Для полного осознания всех последствий описываемых решений потребуется еще немало лет. В этой книге представлена только моя точка зрения на то, почему появился C++, что он собой представляет и каким ему следовало бы быть. Надеюсь, что данная работа будет способствовать дальнейшей эволюции этого языка и поможет людям понять, как лучше всего использовать его. Основное внимание в книге уделено общим целям дизайна, практическим ограничениям. Ключевые проектные решения, относящиеся к языковым средствам, излагаются в историческом контексте. Я прослеживаю эволюцию языка от C with Classes (C с классами) к версиям 1.0 и 2.0 и далее к проводимой в настоящее время комитетом ANSI/ISO работе по стандартизации. В книге анализируются и такие аспекты: резкое увеличение количества приложений по C++, возросший
интерес пользователей к языку, усиление коммерческой активности, появление большого количества компиляторов, инструментальных средств, сред программирования и библиотек. Подробно обсуждаются связи между языками C++ и Simula. Взаимодействие C++ с другими языками затрагивается лишь мимоходом. Дизайн основных языковых средств, к которым можно отнести классы, наследование, абстрактные классы, перегрузку, управление памятью, шаблоны, обработку исключений, идентификацию типов во время исполнения и пространства имен, рассматривается довольно подробно. Основная цель книги – дать программистам на C++ правильное представление о фундаментальных концепциях языка и побудить их к экспериментам с теми его возможностями, о которых они не подозревали. Книга будет полезна как опытным программистам, так и студентам и, возможно, поможет решить, стоит ли тратить время на изучение C++. Предисловие
Благодарности Я выражаю глубокую признательность Стиву Клэмиджу (Steve Clamage), Тони Хансену (Tony Hansen), Лорейн Джуль (Lorraine Juhl), Питеру Джулю (Peter Juhl), Брайану Кернигану (Brian Kernighan), Ли Найту (Lee Knight), Дугу Леа (Doug Lea), Дугу Макилрою (Doug MacIlroy), Барбаре Му (Barbara Moo), Йенсу Палсбергу (Jens Palsberg), Стиву Рамсби (Steve Rumsby) и Кристоферу Скелли (Christopher Skelly) за то, что они прочли все черновые варианты этой книги. Их конструктивные замечания привели к кардинальным изменениям в содержании и организации работы. Стив Бурофф (Steve Buroff), Мартин Кэролл (Martin Caroll), Шон Корфилд (Sean Corfield), Том Хагельскяер (Tom Hagelskjaer), Рик Холлинбек (Rick Hollinbeck), Деннис Манкль (Dennis Mancl) и Стэн Липпман (Stan Lippman) высказали замечания по отдельным главам. Отдельное спасибо Арчи Лахнеру (Archie Lachner), поинтересовавшемуся, где достать эту книгу еще до того, как я всерьез задумался о ее написании. Естественно, я признателен всем тем, кто участвовал в создании языка C++. В некотором смысле моя книга – дань уважения этим людям; имена некоторых из них упомянуты в разных главах и в предметном указателе. Впрочем, если отмечать конкретных людей, то более всех помогали мне и поддерживали меня Брайан Керниган (Brian Kernighan), Эндрю Кениг (Andrew Koenig), Дуг Макилрой (Doug MacIlroy) и Джонатан Шопиро (Jonathan Shopiro). Они также щедро делились своими идеями на протяжении более десяти лет. Спасибо Кристену Найгаарду (Kristen Nygaard) и Деннису Ричи (Dennis Ritchie) – разработчикам соответственно Simula и C, откуда я позаимствовал многие ключевые компоненты. Со временем я оценил Кристена и Денниса не только как блестящих разработчиков языков, но и как очень порядочных и симпатичных людей. Бьерн Страуструп
Обращение к читателю Писательство – это единственное искусство, которым нужно овладевать посредством писания. Анонимный автор Введение C++ проектировался с целью обеспечить средства организации программ, присущие языку Simula, а также необходимую для системного программирования эффективность и гибкость, свойственные C. Предполагалось, что от замысла до его первой реализации пройдет примерно полгода. Так оно и вышло. Тогда – в середине 1979 г. – я еще не осознавал, насколько эта цель была скромной и в то же время абсурдной. Скромной – потому что не предполагалось вводить какие бы то ни было новшества, абсурдной – изза слишком жестких временных рамок и драконовских требований к эффективности и гибкости языка. Новшества со временем все же появились, но в вопросах эффективности и гибкости ни на какие компромиссы я не пошел. С годами цели C++ уточнялись, видоизменялись и формулировались более четко, но и сегодня язык в точности отражает первоначально поставленные цели. Назначение книги, которую вы держите в руках, – документировать эти цели, проследить их эволюцию и представить на суд читателей тот C++, который появился в результате. Я старался уделять равное внимание историческим фактам (именам, местам и событиям) и техническим вопросам дизайна, реализации и применения языка. Я стремился фиксировать не каждое событие, а лишь ключевые идеи и направления развития, которые уже повлияли на определение C++ и, возможно, еще скажутся на его дальнейшей эволюции и практике применения. Если я упоминаю некоторое событие, то стараюсь не выдавать желаемое за действительное. Там, где это уместно, приводятся цитаты из различных статей, иллюстрирующие, как разные цели, принципы или свойства языка представлялись в то время. Я не пытаюсь давать оценку прошлому с позиций сегодняшнего дня. Воспоминания о событиях и замечания по поводу последствий принятых тогда решений отделены от основного текста и помечены. Я вообще питаю отвращение к историческому ревизионизму и стараюсь этого избегать. Приведу в пример свое старое высказывание: «Я пришел к выводу, что система типов в языке Pascal не просто бесполезна– это смирительная рубашка, которая создает проблем больше, чем решает, заставляя меня жертвовать чистотой дизайна ради удовлетворения причуд компилятора». Так я думал в то время, и данное мнение существенно повлияло на эволюцию C++. Было ли это резкое осуждение Pascal справедливым и стал бы я сегодня
(по прошествии более десяти лет) судить точно так же, не имеет значения. Я не могу притвориться, что этого не было (чтобы пощадить чувства приверженцев Pascal или избавить себя от чувства неловкости и лишних споров) или както пригладить свое высказывание (приведя более полную и сбалансированную точку зрения), не исказив при этом историю C++. Когда я говорю о людях, которые внесли вклад в дизайн и эволюцию С++, то по возможности уточняю, в чем именно их заслуга и когда это происходило. Но тут есть опасность. Поскольку память моя несовершенна, я вполне мог чтото забыть. Приношу свои извинения. Я называю имена тех, кто способствовал принятию того или иного решения относительно C++. Увы, не всегда это именно тот человек, который впервые столкнулся с определенной проблемой или задумался о ее решении. Досадно, однако вообще отказаться от упоминания имен было бы еще хуже. Не стесняйтесь сообщать мне обо всем, что могло бы внести ясность в этот вопрос. Когда описываешь исторические события, всегда задумываешься об объективности. Неизбежную предвзятость я старался компенсировать получением информации о событиях, в которых сам не принимал участия, и беседами с другими участниками событий. Еще я попросил нескольких человек, имеющих отношение к эволюции C++, прочесть эту книгу. Их имена приведены в конце предисловия. Ну и, кроме того, статья, представленная на второй конференции по истории языков программирования [Stroustrup, 1993] и содержащая основные исторические факты, упоминаемые в этой книге, была тщательно переработана и освобождена от излишней предвзятости. Как читать эту книгу В части I описывается дизайн, эволюция, практика применения и процесс стандартизации C++ в относительной хронологической последовательности. Такая схема выбрана потому, что решения, принимавшиеся в ранние годы, выстраиваются в четкую, логичную временную цепочку. В главах 1, 2 и 3 описываются истоки C++ и его эволюция от C with Classes к версии 1.0. В главе 4 излагаются правила, по которым C++ развивался в течение этого периода и позже. Главы 5, 6 посвящены соответственно хронологии разработки после выхода версии 1.0 и процессу стандартизации C++ под эгидой ANSI/ISO. О перспективе развития языка говорится в 7 и 8 главах, где анализируются приложения, инструментальные средства и библиотеки. И, наконец, в главе 9 представлены ретроспективный взгляд и некоторые общие мысли о перспективах развития С++. В части II описывается разработка C++ после выхода версии 1.0. Язык развивался в тех направлениях, которые были определены уже ко времени выпуска версии 1.0: добавление желательных свойств (к примеру, шаблонов и обработки исключений) и принципов их дизайна. После появления версии 1.0 хронологический порядок событий был уже не так важен для разработки C++. Определение языка в основных чертах осталось бы таким же, как сейчас, даже если бы последовательность реализации расширений была бы иной. То, в каком порядке решались задачи и как к языку добавлялись новые свойства, представляет лишь исторический интерес. Строго хронологическое изложение помешало бы логически естественному Введение
представлению идей, поэтому в основу построения части II положено описание важнейших свойств языка. Отдельные главы части II не зависят друг от друга, так что читать их можно в любом порядке. Глава 10 посвящена управлению памятью, 11 – перегрузке, 12 – множественному наследованию, 13 – уточнениям концепции класса, 14 – приведению типов, 15 – шаблонам, 16 – обработке исключений, 17 – пространствам имен, 18 – препроцессору C. Люди ждут от книги по дизайну и эволюции языка программирования разного. Не найдется двух человек, имеющих одинаковое мнение о степени детализации, необходимой при обсуждении некоторой темы. Так, все рецензии на варианты статьи, представленной на конференции HOPL2, строились по одинаковому шаблону: «Статья слишком длинная… пожалуйста, уделите больше внимания темам x, y и z». И пока одни рецензенты говорили: «Исключите философскую дребедень, пусть будет побольше технических деталей», другие требовали: «Избавьте от этих утомительных деталей, мне интересна философия проектирования». Чтобы выйти из этого положения, я написал книгу внутри книги. Если вас не интересуют детали, то для начала пропустите все подразделы, имеющие номера x.y.z, где x – номер главы, а y – номер раздела. А из оставшегося читайте то, что вам интереснее. Впрочем, читать можно и последовательно, от первой до последней страницы. Правда, при этом вы рискуете увязнуть в деталях. Я вовсе не хочу сказать, что они несущественны. Напротив, никакой язык программирования нельзя понять, рассматривая только его общие принципы. Без конкретных примеров никак не обойтись. Но, если изучать только детали и не представлять общей картины, можно окончательно запутаться. Стремясь облегчить участь читателя, я поместил в часть II обсуждение почти всех новых свойств языка, которые принято считать «продвинутыми». Поэтому о базовых конструкциях говорится в I части. Почти вся информация о нетехнических аспектах эволюции C++ сосредоточена здесь же. Те, кто не любит «философских материй», могут пропустить главы с 4 по 9 и сразу перейти к техническим деталям, описанным в части II. Я предвижу, что коекто захочет использовать эту книгу как справочный материал, а многие прочтут лишь отдельные главы, не обращая внимания на то, что им предшествует. Такой подход тоже возможен, поскольку я постарался сделать главы по возможности замкнутыми и, как опытный программист на C++, не поскупился на перекрестные ссылки и составил подробный предметный указатель. Пожалуйста, имейте в виду, что в книге я не пытаюсь строго определить возможности языка C++. Здесь излагаются лишь подробности, необходимые для описания того, как появилось на свет то или иное средство. Я не ставлю себе целью научить программированию или проектированию с использованием C++. Тех, кому это интересно, отсылаю к работе [2nd]. Хронология C++ Приведенная ниже хронологическая таблица поможет вам лучше представить то, о чем говорится дальше. Обращение к читателю
К покупке доступен более свежий выпуск
Перейти