Шаблон класса auto_ptr обеспечивает значительные удобства и безопасность использования динамически выделяемой памяти. Однако все равно надо не терять бдительности, чтобы не навлечь на себя неприятности:

∙нельзя инициализировать объект auto_ptr указателем, полученным не с помощью оператора new, или присвоить ему такое значение. В противном случае

после применения к этому объекту оператора delete поведение программы непредсказуемо;

∙два объекта auto_ptr не должны получать во владение один и тот же объект. Очевидный способ допустить такую ошибку – присвоить одно значение двум

auto_ptr< string >

pstr_auto( new string( "Brontosaurus" ) );

//ошибка: теперь оба указывают на один объект

//и оба являются его владельцами

объектам. Менее очевидный – с помощью операции get(). Вот пример: auto_ptr< string > pstr_auto2( pstr_auto.get() );

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

//правильно: оба указывают на один объект,

//но pstr_auto больше не является его владельцем auto_ptr< string >

Предыдущий фрагмент кода нужно переписать так: pstr_auto2( pstr_auto.release() );

8.4.3. Динамическое создание и уничтожение массивов

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

//создание единственного объекта типа int

//с начальным значением 1024

int *pi = new int( 1024 );

//создание массива из 1024 элементов

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

int *pia = new int[ 1024 ];

// создание двумерного массива из 4x1024 элементов

элемент массива. Например:

int (*pia2)[ 1024 ] = new int[ 4 ][ 1024 ];

pi содержит адрес единственного элемента типа int, инициализированного значением 1024; pia – адрес первого элемента массива из 1024 элементов; pia2 – адрес начала

массива, содержащего четыре массива по 1024 элемента, т.е. pia2 адресует 4096 элементов.

В общем случае массив, размещаемый в хипе, не может быть инициализирован. (В разделе 15.8 мы покажем, как с помощью конструктора по умолчанию присвоить начальное значение динамическому массиву объектов типа класса.) Задавать инициализатор при выделении оператором new памяти под массив не разрешается. Массиву элементов встроенного типа, размещенному в хипе, начальные значения

for (int index = 0; index < 1024; ++index )

присваиваются с помощью цикла for: pia[ index ] = 0;

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

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

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

Оператор new допустимо использовать для задания первого измерения массива с помощью значения, вычисляемого во время выполнения. Предположим, у нас есть

const char *noerr = "success"; // ...

const char *err189 = "Error: a function declaration must "

следующие C-строки:

"specify a function return type!";

Размер создаваемого с помощью оператора new массива может быть задан значением,

#include <cstring>

const char *errorTxt;

if (errorFound) errorTxt = errl89;

else

errorTxt = noerr;

int dimension = strlen( errorTxt ) + 1; char *strl = new char[ dimension ];

// копируем текст ошибки в strl

вычисляемым во время выполнения: strcpy( strl, errorTxt );

//обычная для С++ идиома,

//иногда удивляющая начинающих программистов

dimension разрешается заменить выражением:

char *strl = new char[ str1en( errorTxt ) + 1 ];

Единица, прибавляемая к значению, которое возвращает strlen(), необходима для учета завершающего нулевого символа в C-строке. Отсутствие этой единицы – весьма распространенная ошибка, которую достаточно трудно обнаружить, поскольку она проявляет себя косвенно: происходит затирание какой-либо другой области программы. Почему? Большинство функций, которые обрабатывают массивы, представляющие собой С-строки символов, пробегают по элементам, пока не встретят завершающий нуль.

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

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

int getDim();

// создание двумерного массива

int (*pia3)[ 1024 ] = new int[ getDim() ][ 1024 ]; // правильно

// ошибка: второе измерение задано не константой

должны задаваться константами, известными во время компиляции. Например: int **pia4 = new int[ 4 ][ getDim() ];

Оператор delete для уничтожения массива имеет следующую форму:

delete[] str1;

Пустые квадратные скобки необходимы. Они говорят компилятору, что указатель адресует массив, а не единичный элемент. Поскольку тип str1 – указатель на char, без этих скобок компилятор не поймет, что удалять следует целый массив.

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

Чтобы избежать проблем, связанных с управлением динамически выделяемой памятью для массивов, рекомендуется пользоваться контейнерными типами из стандартной библиотеки, такими, как vector, list или string. Они управляют памятью автоматически. (Тип string был представлен в разделе 3.4, тип vector – в разделе 3.10. Подробное описание контейнерных типов см. в главе 6.)

8.4.4. Динамическое создание и уничтожение константных объектов

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

const int *pci = new const int(1024);

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

Во-вторых, указатель, возвращаемый выражением new, должен адресовать константу. В предыдущем примере pci служит указателем на const int.

Константность динамически созданного объекта подразумевает, что значение, полученное при инициализации, в дальнейшем не может быть изменено. Но поскольку объект динамический, временем его жизни управляет оператор delete. Например:

delete pci;

Хотя операнд оператора delete имеет тип указателя на const int, эта инструкция является корректной и освобождает область памяти, на которую ссылается pci.

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

const int *pci = new const int[100]; // ошибка

8.4.5. Оператор размещения new А

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

new (place_address) type-specifier

place_address должен быть указателем. Такая форма (она включается заголовочным файлом <new>) позволяет программисту предварительно выделить большую область памяти, которая впоследствии будет содержать различные объекты. Например:

#include <iostream> #include <new>

const int chunk = 16; class Foo {

public:

int val() { return _val; } FooQ(){ _val = 0; }

private:

int _val;

};

// выделяем память, но не создаем объектов Foo char *buf = new char[ sizeof(Foo) * chunk ];

int main() {

//создаем объект Foo в buf Foo *pb = new (buf) Foo;

//проверим, что объект помещен в buf if ( pb.val() == 0 )

cout << "Оператор new сработал!" << endl;

// здесь нельзя использовать pb delete[] buf;

return 0;

}

Результат работы программы:

Оператор new сработал!

Для оператора размещения new нет парного оператора delete: он не нужен, поскольку эта форма не выделяет память. В предыдущем примере необходимо освободить память, адресуемую указателем buf, а не pb. Это происходит в конце программы, когда буфер больше не нужен. Поскольку buf ссылается на символьный массив, оператор delete

имеет форму

delete[] buf;

При уничтожении buf прекращают существование все объекты, созданные в нем. В нашем примере pb больше не ссылается на существующий объект класса Foo.

Упражнение 8.5

(a)const float *pf = new const float[100];

(b)double *pd = new doub1e[10] [getDim()];

(c)int (*pia2)[ 1024 ] = new int[ ][ 1024 ];

Объясните, почему приведенные операторы new ошибочны:

(d) const int *pci = new const int;

Упражнение 8.6

Как бы вы уничтожили pa?

typedef int arr[10];

int *pa = new arr;

Упражнение 8.7

Какие из следующих операторов delete содержат потенциальные ошибки времени

int globalObj; char buf[1000];

void f() {

int *pi = &global0bj; double *pd = 0;

float *pf = new float(O); int *pa = new(buf)int[20];

de1ete[] pa; // (d)

выполнения и почему:

}

Упражнение 8.8

Какие из данных объявлений auto_ptr неверны или грозят ошибками времени

int ix = 1024; int *pi = & ix;

int *pi2 = new int ( 2048 );

(a)auto_ptr<int> p0(ix);

(b)auto_ptr<int> pl(pi);

(c)auto_ptr<int> p2(pi2);

(d)auto_ptr<int> p3(&ix);

(e)auto_ptr<int> p4(new int(2048));

(f)auto_ptr<int> p5(p2.get());

(9) auto_ptr<int> p6(p2.release());

выполнения? Объясните каждый случай.

(h) auto_ptr<int> p7(p2);

Упражнение 8.9

int *pi0 = p2.get();

Объясните разницу между следующими инструкциями: int *pi1 = p2.release() ;

Для каких случаев более приемлем тот или иной вызов? Упражнение 8.10