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

Операторы new и delete резервируют объекты по одному. Некоторым приложениям нужен способ резервировать хранилище для многих объектов сразу. Например, векторы и строки хранят свои элементы в непрерывной памяти и должны резервировать несколько элементов сразу всякий раз, когда контейнеру нужно повторное резервирование (см. раздел 9.4).

Для этого язык и библиотека предоставляют два способа резервирования всего массива объектов. Язык определяет второй вид оператора new, резервирующего и инициализирующего массив объектов. Библиотека предоставляет шаблон класса allocator, позволяющий отделять резервирование от инициализации. По причинам, описанным в разделе 12.2.2, применение класса allocator обычно обеспечивает лучшую производительность и более гибкое управление памятью.

У многих (возможно, у большинства) приложений нет никакой непосредственной необходимости в динамических массивах. Когда приложение нуждается в переменном количестве объектов, практически всегда проще, быстрей и безопасней использовать вектор (или другой библиотечный контейнер), как было сделано в классе StrBlob. По причинам, описанным в разделе 13.6, преимущества использования библиотечного контейнера даже более явны по новому стандарту. Библиотеки, поддерживающие новый стандарт, работают существенно быстрее, чем предыдущие версии.

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

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

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

12.2.1. Оператор new и массивы

Чтобы запросить оператор new зарезервировать массив объектов, после имени типа следует указать в квадратных скобках количество резервируемых объектов. В данном случае оператор new резервирует требуемое количество объектов и (при успешном резервировании) возвращает указатель на первый из них:

// вызов get_size() определит количество резервируемых целых чисел

int *pia = new int[get_size()]; // pia указывает на первое из них

Значение в скобках должно иметь целочисленный тип, но не обязано быть константой.

Для представления типа массива при резервировании можно также использовать псевдоним типа (см. раздел 2.5.1). В данном случае скобки не нужны:

typedef int arrT[42]; // arrT - имя типа массива из 42 целых чисел

int *p = new arrT;    // резервирует массив из 42 целых чисел;

                      // p указывает на первый его элемент

Здесь оператор new резервирует массив целых чисел и возвращает указатель на его первый элемент. Даже при том, что никаких скобок в коде нет, компилятор выполняет это выражение, используя оператор new[]. Таким образом, компилятор выполняет это выражение, как будто код был написан так:

int *p = new int[42];

Резервирование массива возвращает указатель на тип элемента

Хотя обычно память, зарезервированную оператором new T[], называют "динамическим массивом", это несколько вводит в заблуждение. Когда мы используем оператор new для резервирования массива, объект типа массива получен не будет. Вместо этого будет получен указатель на тип элемента массива. Даже если для определения типа массива использовать псевдоним типа, оператор new не резервирует объект типа массива. И в данном случае резервируется массив, хотя часть [число] не видима. Даже в этом случае оператор new возвращает указатель на тип элемента.

Поскольку зарезервированная память не имеет типа массива, для динамического массива нельзя вызвать функцию begin() или end() (см. раздел 3.5.3). Для возвращения указателей на первый и следующий после последнего элементы эти функции используют размерность массива (являющуюся частью типа массива). По тем же причинам для обработки элементов так называемого динамического массива нельзя также использовать серийный оператор for. 

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

Инициализация массива динамически созданных объектов

Зарезервированные оператором new объекты (будь то одиночные или их массивы) инициализируются по умолчанию. Для инициализации элементов массива по умолчанию (см. раздел 3.3.1) за размером следует расположить пару круглых скобок:

int *pia = new int[10];    // блок из десяти неинициализированных

                           // целых чисел

int *pia2 = new int[10](); // блок из десяти целых чисел,

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

                           // значением 0

string *psa = new string[10];    // блок из десяти пустых строк

string *psa2 = new string[10](); // блок из десяти пустых строк

По новому стандарту можно также предоставить в скобках список инициализаторов элементов:

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

// инициализатором

int *pia3 = new int[10]{0,1,2,3,4,5,6,7,8,9};

// блок из десяти строк; первые четыре инициализируются заданными

// инициализаторами, остальные элементы инициализируются значением

// по умолчанию

string *psa3 = new string[10]{"a", "an", "the", string(3, 'x')};

При списочной инициализации объекта типа встроенного массива (см. раздел 3.5.1) инициализаторы используются для инициализации первых элементов массива. Если инициализаторов меньше, чем элементов, остальные инициализируются значением по умолчанию. Если инициализаторов больше, чем элементов, оператор new потерпит неудачу, не зарезервировав ничего. В данном случае оператор new передает исключение типа bad_array_new_length. Подобно исключению bad_alloc, этот тип определен в заголовке new.

Хотя для инициализации элементов массива по умолчанию можно использовать пустые круглые скобки, в них нельзя предоставить инициализаторы для элементов. Благодаря этому факту при резервировании массива нельзя использовать ключевое слово auto (см. раздел 12.1.2).

Динамическое резервирование пустого массива вполне допустимо

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

size_t n = get_size(); // get_size() возвращает количество необходимых

                       // элементов

int* p = new int[n];   // резервирует массив для содержания элементов

for (int* q = p; q != p + n; ++q)

 /* обработка массива */ ;

Возникает интересный вопрос: что будет, если функция get_size() возвратит значение 0? Этот код сработает прекрасно. Вызов функции new[n] при n равном 0 вполне допустим, даже при том, что нельзя создать переменную типа массива размером 0:

char arr[0]; // ошибка: нельзя определить массив нулевой длины

char *cp = new char[0]; // ok: но обращение к значению cp невозможно

При использовании оператора new для резервирования массива нулевого размера он возвращает допустимый, а не нулевой указатель. Этот указатель гарантированно будет отличен от любого другого указателя, возвращенного оператором new. Он будет подобен указателю на элемент после конца (см. раздел 3.5.3) для нулевого элемента массива. Этот указатель можно использовать теми способами, которыми используется итератор после конца. Его можно сравнивать в цикле, как выше. К нему можно добавить нуль (или вычесть нуль), такой указатель можно вычесть из себя, получив в результате нуль. К значению такого указателя нельзя обратиться, в конце концов, он не указывает на элемент.

В гипотетическом цикле, если функция get_size() возвращает 0, то n также равно 0. Вызов оператора new зарезервирует нуль объектов. Условие оператора for будет ложно (p равно q + n, поскольку n равно 0). Таким образом, тело цикла не выполняется.