Язык программирования C++. Пятое издание - Стенли Липпман
Шрифт:
Интервал:
Закладка:
string *ps = new string(10, '9'); // *ps = "9999999999"
// вектор на десять элементов со значениями от 0 до 9
vector<int> *pv = new vector<int>{0,1,2,3,4,5,6,7,8,9};
Динамически созданный объект можно также инициализировать значением по умолчанию (см. раздел 3.3.1), сопроводив имя типа парой пустых круглых скобок:
string *ps1 = new string; // инициализация по умолчанию пустой строкой
string *ps = new string(); // инициализация значением по умолчанию
// (пустой строкой)
int *pi1 = new int; // инициализация по умолчанию;
// значение *pi1 не определено
int *pi2 = new int(); // инициализация значением по умолчанию 0;
// *pi2 = 0
Для типов классов (таких как string), определяющих собственные конструкторы (см. раздел 7.1.4), запрос инициализации значением по умолчанию не имеет последствий; независимо от формы, объект инициализируется стандартным конструктором. Различие существенно в случае встроенных типов: инициализация объекта встроенного типа значением по умолчанию присваивает ему вполне конкретное значение, а инициализация по умолчанию — нет. Точно так же полагающиеся на синтезируемый стандартный конструктор члены класса встроенного типа также не будут не инициализированы, если эти члены не будут инициализированы в теле класса (см. раздел 7.1.4).
По тем же причинам, по которым обычно инициализируют переменные, имеет смысл инициализировать и динамически созданные объекты.
Когда предоставляется инициализатор в круглых скобках, для вывода типа объекта, который предстоит зарезервировать для этого инициализатора, можно использовать ключевое слово auto (см. раздел 2.5.2). Но, поскольку компилятор использует тип инициализатора для вывода резервируемого типа, ключевое слово auto можно использовать только с одиночным инициализатором в круглых скобках:
auto p1 = new auto(obj); // p указывает на объект типа obj
// этот объект инициализируется значением obj
auto p2 = new auto{a,b,c}; // ошибка: для инициализатора нужно
// использовать круглые скобки
Тип p1 — это указатель на автоматически выведенный тип obj. Если obj имеет тип int, то тип p1 — int*; если obj имеет тип string, то тип p1 — string* и т.д. Вновь созданный объект инициализируется значением объекта obj.
Динамически созданные константные объектыДля резервирования константных объектов вполне допустимо использовать оператор new:
// зарезервировать и инициализировать
const int const int *pci = new const int(1024);
// зарезервировать и инициализировать значением по умолчанию
const string const string *pcs = new const string;
Подобно любым другим константным объектам, динамически созданный константный объект следует инициализировать. Динамический константный объект типа класса, определяющего стандартный конструктор (см. раздел 7.1.4), можно инициализировать неявно. Объекты других типов следует инициализировать явно. Поскольку динамически зарезервированный объект является константой, возвращенный оператором new указатель является указателем на константу (см. раздел 2.4.2).
Исчерпание памятиХотя современные машины имеют огромный объем памяти, всегда существует вероятность исчерпания динамической памяти. Как только программа использует всю доступную ей память, выражения с оператором new будут терпеть неудачу. По умолчанию, если оператор new неспособен зарезервировать требуемый объем памяти, он передает исключение типа bad_alloc (см. раздел 5.6). Используя иную форму оператора new, можно воспрепятствовать передаче исключения:
// при неудаче оператор new возвращает нулевой указатель
int *p1 = new int; // при неудаче оператор new передает
// исключение std::bad_alloc
int *p2 = new (nothrow) int; // при неудаче оператор new возвращает
// нулевой указатель
По причинам, рассматриваемым в разделе 19.1.2, эта форма оператора new упоминается как размещающий оператор new (placement new). Выражение размещающего оператора new позволяет передать дополнительные аргументы. В данном случае передается определенный библиотекой объект nothrow. Передача объекта nothrow оператору new указывает, что он не должен передавать исключения. Если эта форма оператора new окажется неспособна зарезервировать требуемый объем памяти, она возвратит нулевой указатель. Типы bad_alloc и nothrow определены в заголовке new.
Освобождение динамической памятиЧтобы предотвратить исчерпание памяти, по завершении использования ее следует возвратить операционной системе. Для этого используется оператор delete, получающий указатель на освобождаемый объект:
delete p; // p должен быть указателем на динамически созданный объект
// или нулевым указателем
Подобно оператору new, оператор delete выполняет два действия: удаляет объект, на который указывает переданный ему указатель, и освобождает соответствующую область памяти.
Значения указателя и оператор deleteПередаваемый оператору delete указатель должен либо указывать на динамически созданный объект, либо быть нулевым указателем (см. раздел 2.3.2). Результат удаления указателя на область памяти, зарезервированную не оператором new, или повторного удаления значения того же указателя непредсказуем:
int i, *pi1 = &i, *pi2 = nullptr;
double *pd = new double(33), *pd2 = pd;
delete i; // ошибка: i - не указатель
delete pi1; // непредсказуемо: pi1 - локальный
delete pd; // ok
delete pd2; // непредсказуемо: память, на которую указывает pd2,
// уже освобождена
delete pi2; // ok: освобождение нулевого указателя всегда допустимо
Компилятор сообщает об ошибке оператора delete i, поскольку знает, что i — не указатель. Ошибки, связанные с выполнением оператора delete для указателей pi1 и pd2, коварней: обычно компиляторы неспособны выяснить, указывает ли указатель на объект, созданный статически или динамически. Точно так же компилятор не может установить, была ли уже освобождена память, на которую указывает указатель. Большинство компиляторов примет такие выражения delete, несмотря на их ошибочность.
Хотя значение константного объекта не может быть изменено, сам объект вполне может быть удален. Подобно любым динамическим объектам, константный динамический объект освобождается выполнением оператора delete для указателя, указывающего на этот объект:
const int *pci = new const int(1024);
delete pci; // ok: удаляет константный объект
Динамически созданные объекты существуют до тех пор, пока не будут освобожденыКак упоминалось в разделе 12.1.1, управляемая указателем shared_ptr память автоматически освобождается при удалении последнего указателя shared_ptr. Динамический объект, управляемый указателем встроенного типа, существует до тех пор, пока к областям памяти, управляемой при помощи указателей встроенных типов, не будет удален явно.
Функции, возвращающие обычные (а не интеллектуальные) указатели на области динамической памяти, возлагают ответственность за их удаление на вызывающую сторону:
// возвращает указатель на динамически созданный объект
Foo* factory(Т arg) {
// обработать аргумент соответственно
return new Foo(arg); // за освобождение этой памяти отвечает
// вызывающая сторона
}
Подобно прежней версии функции factory() (см. раздел 12.1.1), эта версия резервирует объект, но не удаляет его. Ответственность за освобождение памяти динамического объекта, когда он станет больше не нужен, несет вызывающая сторона функции factory(). К сожалению, вызывающая сторона слишком часто забывает сделать это:
void use_factory(Т arg) {
Foo *p = factory(arg);
// использовать p, но не удалить его