Язык программирования C++. Пятое издание - Стенли Липпман

Спецификация запрета передачи исключения (nonthrowing specification). Спецификация исключения, обещающая, что функция не будет передавать исключений. Если такая функция передаст исключение, то будет вызвана функция terminate(). К спецификаторам запрета передачи исключения относятся спецификатор noexcept без аргумента или с аргументом, возвращающим значение true, а также throw().

Статический файловый объект (file static). Локальное для файла имя, которое было объявлено с использованием ключевого слова static. В языке С и версиях языка С++, выпущенных до появления стандарта, статические файловые объекты использовались для объявления таких объектов, которые применимы только в одном файле. Применение статических файловых объектов осуждено стандартом С++. Сейчас они заменены безымянными пространствами имен.

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

Глава 19

Специализированные инструменты и технологии

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

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

19.1. Контроль распределения памяти

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

19.1.1. Перегрузка операторов new и delete

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

Выражение new используется так:

// выражение new

string *sp = new string("a value"); // зарезервировать и

                                    // инициализировать строку

string *arr = new string[10]; // зарезервировать десять строк,

                              // инициализированных значением по

                              // умолчанию

Фактически здесь три этапа: сначала выражение вызывает библиотечную функцию operator new() (или operator new[]()). Эта функция резервирует не типизированную область памяти достаточного размера для содержания объекта (или массива объектов) определенного типа. Затем компилятор запускает соответствующий конструктор, чтобы создать объект (объекты) из переданных инициализаторов. И наконец, возвращается указатель на вновь зарезервированный и созданный объект.

Выражение delete применяется для удаления динамически созданного объекта:

delete sp;     // удалить *sp и освободить память,

               // на которую указывает sp

delete [] arr; // удалить элементы массива и освободить память

Здесь два этапа: сначала для объекта, на который указывает указатель sp, или для элементов массива, на который указывает имя arr, выполняется соответствующий деструктор. Затем компилятор освобождает память, вызвав библиотечную функцию operator delete() или operator delete[]() соответственно.

Приложения, которые собираются самостоятельно контролировать распределение памяти, определяют собственные версии функций operator new() и operator delete(). Даже при том, что библиотека содержит определения этих функций, вполне можно определить их собственные версии, и компилятор не пожалуется на двойное определение. Вместо этого компилятор использует пользовательскую версию, а не определенную библиотекой.

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

Функции operator new() и operator delete() можно определить в глобальной области видимости или как функции-члены. Когда компилятор встречает выражение new или delete, он ищет соответствующую вызову функцию оператора. Если резервируемый (освобождаемый) объект имеет тип класса, то компилятор ищет сначала в пределах класса, включая все его базовые классы. Если у класса есть функции-члены operator new() и operator delete(), эти функции и используются в выражении new или delete. В противном случае компилятор ищет соответствующую функцию в глобальной области видимости. Если компилятор находит пользовательскую версию функции, он ее и использует для выполнения выражения new или delete. В противном случае используется версия из стандартной библиотеки.

Чтобы заставить выражение new или delete обойти функцию, предоставленную классом, и использовать таковую из глобальной области видимости, можно использовать оператор области видимости. Например, выражение ::new имеет в виду функцию operator new() только из глобальной области видимости. Аналогично для выражения ::delete.

Библиотека определяет восемь перегруженных версий функций operator new() и operator delete(). Первые четыре версии оператора new способны передавать исключение bad_alloc. Следующие четыре версии оператора new не передают исключений:

// версии, способные передавать исключения

void *operator new(size_t);              // резервирует объект

void *operator new[](size_t);            // резервирует массив

void *operator delete(void*) noexcept;   // освобождает объект

void *operator delete[](void*) noexcept; // освобождает массив

// версии, обещающие не передавать исключений; см. p. 12.1.2

void *operator new(size_t, nothrow_t&) noexcept;

void *operator new[](size_t, nothrow_t&) noexcept;

void *operator delete(void*, nothrow_t&) noexcept;

void *operator delete[](void*, nothrow_t&) noexcept;

Тип nothrow_t является структурой, определенной в заголовке new. У этого типа нет никаких членов. Заголовок new определяет также константный объект nothrow, который пользователи могут передавать как сигнал, что необходима версия оператора new, не передающего исключения (см. раздел 12.1.2). Будучи деструктором, функция operator delete() не должна передавать исключения (см. раздел 18.1.1). При перегрузке этих операторов следует определить, будут ли они передавать исключения. Для этого используется спецификатор исключения noexcept (см. раздел 18.1.4).

Приложение может определить свою собственную версию любой из этих функций. Если это так, то следует определить эти функции в глобальной области видимости или как функцию-член класса. Когда эти функции операторов определены как члены класса, они неявно являются статическими (см. раздел 7.6). Нет никакой необходимости объявлять их статическими явно, хотя сделать это вполне допустимо. Функции-члены операторов new и delete должны быть статическими, поскольку они используются до создания объекта (operator new) или после его удаления (operator delete). Поэтому у них нет никаких переменных-членов, которыми они могли бы манипулировать.

У функций operator new() и operator new[]() должен быть тип возвращаемого значения void*, а их первый параметр должен иметь тип size_t. У этого параметра не может быть аргумента по умолчанию. Функция operator new() используется при резервировании объекта; функция operator new[]() вызывается при резервировании массива. Когда компилятор вызывает функцию operator new(), он инициализирует параметр типа size_t количеством байтов, необходимых для содержания объекта заданного типа; при вызове функции operator new[]() передается количество байтов, необходимых для хранения массива заданного количества элементов.