Операторы new и delete c. Всё ли мы знаем об операторах new и delete? Преимущества использования указателей при работе с элементами массива
Оператор new позволяет выделять память под массивы. Он возвращает
указатель на первый элемент массива в квадратных скобках. При выделении памяти под многомерные массивы все размерности кроме крайней левой должны быть константами. Первая размерность может быть задана переменной, значение которой к моменту использования new известно пользователю, например:
int *p=new int[k]; // ошибка cannot convert from "int (*)" to "int *"
int (*p)=new int[k]; // верно
При выделении памяти под объект его значение будет неопределенным. Однако объекту можно присвоить начальное значение.
int *a = new int (10234);
Этот параметр нельзя использовать для инициализации массивов. Однако
на место инициализирующего значения можно поместить через запятую список
значений, передаваемых конструктору при выделении памяти под массив (мас-
сив новых объектов, заданных пользователем). Память под массив объектов
может быть выделена только в том случае, если у соответствующего класса
имеется конструктор, заданный по умолчанию.
matr(){}; // конструктор по умолчанию
matr(int i,float j): a(i),b(j) {}
{ matr mt(3,.5);
matr *p1=new matr; // верно р1 − указатель на 2 объекта
matr *p2=new matr (2,3.4); // неверно, невозможна инициализация
matr *p3=new matr (2,3.4); // верно р3 – инициализированный объект
{ int i; // компонента-данное класса А
A(){} // конструктор класса А
~A(){} // деструктор класса А
{ A *a,*b; // описание указателей на объект класса А
float *c,*d; // описание указателей на элементы типа float
a=new A; // выделение памяти для одного объекта класса А
b=new A; // выделение памяти для массива объектов класса А
c=new float; // выделение памяти для одного элемента типа float
d=new float; // выделение памяти для массива элементов типа float
delete a; // освобождение памяти, занимаемой одним объектом
delete b; // освобождение памяти, занимаемой массивом объектов
delete c; // освобождение памяти одного элемента типа float
delete d; } // освобождение памяти массива элементов типа float
Организация внешнего доступа к локальным компонентам класса(friend)
Мы уже познакомились с основным правилом ООП – данные (внутренние
переменные) объекта защищены от воздействий извне и доступ к ним можно
получить только с помощью функций (методов) объекта. Но бывают такие слу-
чаи, когда нам необходимо организовать доступ к данным объекта, не исполь-
зуя его интерфейс (функции). Конечно, можно добавить новую public-функцию
к классу для получения прямого доступа к внутренним переменным. Однако в
большинстве случаев интерфейс объекта реализует определенные операции, и
новая функция может оказаться излишней. В то же время иногда возникает не-
обходимость организации прямого доступа к внутренним (локальным) данным
двух разных объектов из одной функции. При этом в С++ одна функция не мо-
жет быть компонентой двух различных классов.
Для реализации этого в С++ введен спецификатор friend. Если некоторая
функция определена как friend-функция для некоторого класса, то она:
Не является компонентой-функцией этого класса;
Имеет доступ ко всем компонентам этого класса (private, public и protected).
Ниже рассматривается пример, когда внешняя функция получает доступ к
внутренним данным класса.
#include
using namespace std;
kls(int i,int J) : i(I),j(J) {} // конструктор
int max() {return i>j? i: j;} // функция-компонента класса kls
friend double fun(int, kls&); // friend-объявление внешней функции fun
double fun(int i, kls &x) // внешняя функция
{ return (double)i/x.i;
cout << obj.max() << endl;
В С(С++) известны три способа передачи данных в функцию: по значе-
можно на некоторый существующий объект. Можно выделить следующие раз-
личия ссылок и указателей. Во-первых, невозможность существования нулевых
ссылок подразумевает, что корректность их не требуется проверять. А при использовании указателя требуется проверять его на ненулевое значение. Во-вторых, указатели могут указывать на различные объекты, а ссылка всегда на один объект, заданный при ее инициализации. Если требуется предоставить возможность функции изменять значения
передаваемых в нее параметров, то в языке С они должны быть объявлены либо
глобально, либо работа с ними в функции осуществляется через передаваемые в
нее указатели на эти переменные. В С++ аргументы в функцию можно переда-
ром ставится знак &.
void fun1(int,int);
void fun2(int &,int &);
{ int i=1,j=2; // i и j – локальные параметры
cout << "\n адрес переменных в main() i = "<<&i<<" j = "<<&j;
cout << "\n i = "< #include cstddef // статические члены инициализируются // в исходных файлах программы, а не в заголовочных файлах Screen *Screen::freeStore = 0; const int Screen::screenChunk = 24; void *Screen::operator new(size_t size) if (!freeStore) { // связанный список пуст: получить новый блок // вызывается глобальный оператор new size_t chunk = screenChunk * size; reinterpret_cast Screen* (new char[ chunk ]); // включить полученный блок в список p != &freeStore[ screenChunk - 1 ]; freeStore = freeStore-next; А вот реализация оператора delete(): void Screen::operator delete(void *p, size_t) // вставить "удаленный" объект назад, // в список свободных (static_cast Screen* (p))-next = freeStore; freeStore = static_cast Screen* (p); Оператор new() можно объявить в классе и без соответствующего delete(). В таком случае объекты освобождаются с помощью одноименного глобального оператора. Разрешается также объявить и оператор delete() без new(): объекты будут создаваться с помощью одноименного глобального оператора. Однако обычно эти операторы реализуются одновременно, как в примере выше, поскольку разработчику класса, как правило, нужны оба. Они являются статическими членами класса, даже если программист явно не объявит их таковыми, и подчиняются обычным ограничениями для подобных функций-членов: им не передается указатель this, а следовательно, напрямую они могут получить доступ только к статическим членам. (См. обсуждение статических функций-членов в разделе 13.5.) Причина, по которой эти операторы делаются статическими, заключается в том, что они вызываются либо перед конструированием объекта класса (new()), либо после его уничтожения (delete()). Выделение памяти с помощью оператора new(), например: Screen *ptr = new Screen(10, 20); // Псевдокод на C++ ptr = Screen::operator new(sizeof(Screen)); Screen::Screen(ptr, 10, 20); Иными словами, сначала вызывается определенный в классе оператор new(), чтобы выделить память для объекта, а затем этот объект инициализируется конструктором. Если new() неудачно завершает работу, то возбуждается исключение типа bad_alloc и конструктор не вызывается. Освобождение памяти с помощью оператора delete(), например: эквивалентно последовательному выполнению таких инструкций: // Псевдокод на C++ Screen::~Screen(ptr); Screen::operator delete(ptr, sizeof(*ptr)); Таким образом, при уничтожении объекта сначала вызывается деструктор класса, а затем определенный в классе оператор delete() для освобождения памяти. Если значение ptr равно 0, то ни деструктор, ни delete() не вызываются. 15.8.1. Операторы new и delete Оператор new(), определенный в предыдущем подразделе, вызывается только при выделении памяти для единичного объекта. Так, в данной инструкции вызывается new() класса Screen: Screen *ps = new Screen(24, 80); тогда как ниже вызывается глобальный оператор new() для выделения из хипа памяти под массив объектов типа Screen: // вызывается Screen::operator new() Screen *psa = new Screen; В классе можно объявить также операторы new() и delete() для работы с массивами. Оператор-член new() должен возвращать значение типа void* и принимать в качестве первого параметра значение типа size_t. Вот его объявление для Screen: void *operator new(size_t); Когда с помощью new создается массив объектов типа класса, компилятор проверяет, определен ли в классе оператор new(). Если да, то для выделения памяти под массив вызывается именно он, в противном случае – глобальный new(). В следующей инструкции в хипе создается массив из десяти объектов Screen: Screen *ps = new Screen; В этом классе есть оператор new(), поэтому он и вызывается для выделения памяти. Его параметр size_t автоматически инициализируется значением, равным объему памяти в байтах, необходимому для размещения десяти объектов Screen. Даже если в классе имеется оператор-член new(), программист может вызвать для создания массива глобальный new(), воспользовавшись оператором разрешения глобальной области видимости: Screen *ps = ::new Screen; Оператор delete(), являющийся членом класса, должен иметь тип void, а в качестве первого параметра принимать void*. Вот как выглядит его объявление для Screen: void operator delete(void *); Чтобы удалить массив объектов класса, delete должен вызываться следующим образом: Когда операндом delete является указатель на объект типа класса, компилятор проверяет, определен ли в этом классе оператор delete(). Если да, то для освобождения памяти вызывается именно он, в противном случае – его глобальная версия. Параметр типа void* автоматически инициализируется значением адреса начала области памяти, в которой размещен массив. Даже если в классе имеется оператор-член delete(), программист может вызвать глобальный delete(), воспользовавшись оператором разрешения глобальной области видимости: Добавление операторов new() или delete() в класс или удаление их оттуда не отражаются на пользовательском коде: вызовы как глобальных операторов, так и операторов-членов выглядят одинаково. При создании массива сначала вызывается new() для выделения необходимой памяти, а затем каждый элемент инициализируется с помощью конструктора по умолчанию. Если у класса есть хотя бы один конструктор, но нет конструктора по умолчанию, то вызов оператора new() считается ошибкой. Не существует синтаксической конструкции для задания инициализаторов элементов массива или аргументов конструктора класса при создании массива подобным образом. При уничтожении массива сначала вызывается деструктор класса для уничтожения элементов, а затем оператор delete() – для освобождения всей памяти. При этом важно использовать правильный синтаксис. Если в инструкции ps указывает на массив объектов класса, то отсутствие квадратных скобок приведет к вызову деструктора лишь для первого элемента, хотя память будет освобождена полностью. У оператора-члена delete() может быть не один, а два параметра, при этом второй должен иметь тип size_t: // заменяет // void operator delete(void*); void operator delete(void*, size_t); Если второй параметр присутствует, то компилятор автоматически инициализирует его значением, равным объему отведенной под массив памяти в байтах. R.5.3.4 Операция delete
Операция delete уничтожает объект, созданный с помощью new.выражение-освобождения: ::opt delete выражение-приведения::opt delete выражение-приведенияРезультат имеет тип void. Операндом delete должен быть указатель, который возвращает new. Эффект применения операции delete Операторы new и delete
Оператор new создает объект заданного типа. При этом он выделяет память, необходимую для хранения объекта и возвращает указатель, указывающий на него. Если по каким-либо причинам получить память не удается, оператор возвращает нулевое значение. Оператор Правило 16: Используйте одинаковые формы new и delete
Что неправильно в следующем фрагменте?std::string *stringArray = new std::string;...delete stringArray;На первый взгляд, все в полном порядке – использованию new соответствует применение delete, но кое-что здесь совершенно неверно. Поведение программы Глава 8
Настройка new и delete
В наши дни, когда вычислительные среды снабжены встроенной поддержкой «сборки мусора» (как, например, Java и. NET), ручной подход C++ к управлению памятью может показаться несколько устаревшим. Однако многие разработчики, создающие требовательные к Метод Delete
Если параметр force равен false или не указан, то с помощью метода Delete будет нельзя удалить каталог с атрибутом "только для чтения" (read-only). Установка для force значения true позволит сразу удалять такие каталоги.При использовании метода Delete неважно, является ли заданный Метод Delete
Если параметр force равен false или не указан, то с помощью метода Delete будет нельзя удалить файл с атрибутом "только для чтения" (read-only). Установка для force значения true позволит сразу удалять такие файлы.
Замечание
Вместо метода Delete можно использовать метод DeleteFile Операторы отношения и логические операторы
Операторы отношения используются для сравнения значений двух переменных. Эти операторы, описанные в табл. П2.11, могут возвращать только логические значения true или false.Таблица П2.11. Операторы отношения
Оператор
Условие, при 45. new и delete всегда должны разрабатываться вместе
РезюмеКаждая перегрузка void* operator new(parms) в классе должна сопровождаться соответствующей перегрузкой оператора void operator delete(void* , parms), где parms - список типов дополнительных параметров (первый из которых всегда std::size_t). То же delete - Удаление объекта, элемента массива или переменной
delete(Оператор)Этот оператор используется для удаления из сценария объекта, свойства объекта, элемента массива или переменных.Синтаксис:delete identifier;Аргументы:Описание:Оператор delete уничтожает объект или переменную, имя Оператор DELETE
Запрос DELETE используется для удаления целых строк таблицы. SQL не дает возможности одному оператору DELETE удалять строки более чем из одной таблицы. Запрос DELETE, который изменяет только одну текущую строку курсора, называется позиционированным удалением. 15.8. Операторы new и delete
По умолчанию выделение объекта класса из хипа и освобождение занятой им памяти выполняются с помощью глобальных операторов new() и delete(), определенных в стандартной библиотеке C++. (Мы рассматривали эти операторы в разделе 8.4.) Но класс может реализовать 15.8.1. Операторы new и delete
Оператор new(), определенный в предыдущем подразделе, вызывается только при выделении памяти для единичного объекта. Так, в данной инструкции вызывается new() класса Screen:// вызывается Screen::operator new()Screen *ps = new Screen(24, 80);тогда как ниже вызывается Привет! Ниже речь пойдет об известных всем операторах new
и delete
, точнее о том, о чем не пишут в книгах (по крайней мере в книгах для начинающих). Итак, начнем с того, что обычно пишут в книгах для начинающих, когда описывают new
(текст взят «с потолка», но вцелом соответствует правде): На что хочется обратить внимание: Но не будем надеяться на книги для начинающих, обратимся к Стандарту, а именно к разделу 5.3.4 и к 18.6.1, в которых собственно и раскрывается (точнее приоткрывается) тема данной статьи. Тут мы уже видим, что в первом случае new
именуется как expression
, а во втором он объявлен как operator.
И это действительно 2 разные сущности! new-expression
- это оператор языка, такой же как if
, while
и т.д. (хотя if,
while
и т.д. все же именуются как statement
, но отбросим лирику) Т.е. встречая его в листинге компилятор генерирует определенный код, соответствующий этому оператору. Так же new
- это одно из key-words
языка С++, что еще раз подтверждает его общность с if
"ами, for"
ами и т.п. А operator new()
в свою очередь - это просто одноименная функция языка С++, поведение которой можно переопределить. ВАЖНО
- operator new()
НЕ
вызывает конструктор(ы) для объекта(ов), под который(ые) выделяется память. Он просто выделяет память нужного размера и все. Его отличие от сишных функций в том, что он может бросить исключение и его можно переопределить, а так же сделать оператором для отдельно взятого класса, тем самым переопределить его только для этого класса (остальное вспомните сами:)). Для полноты картины рассмотрим следующий пример: #include После исполнения данного кода, как и ожидалось, будет напечатано «Foo()». Разберемся почему, для этого понадобится заглянуть в ассемблер, который я немного прокомментировал для удобства. Приведенный код подтверждает все, написанное выше, а именно: Итог: надеюсь, эта статья помогла вам понять разницу между new-expression
и operator new()
или даже узнать, что она (эта разница) вообще существует, если кто-то не знал. P.S. оператор delete
и operator delete()
имеют аналогичное различие, поэтому в начале статьи я сказал, что не буду его описывать. Думаю, теперь вы поняли, почему его описание не имеет смысла и сможете самостоятельно проверить справедливость написанного выше для delete
. Update:
С++ поддерживает три основных типа выделения
(распределения
) памяти
, с двумя из которых мы уже знакомы:
Статическое выделение памяти
выполняется для и переменных. Память выделяется один раз, при запуске программы, и сохраняется на протяжении работы всей программы.
Автоматическое выделение памяти
выполняется для и . Память выделяется при входе в блок, в котором находятся эти переменные, и освобождается при выходе из него.
является темой этой статьи. Как статическое, так и автоматическое распределение памяти имеют две общие черты:
Размер переменной/массива должен быть известен во время компиляции.
Выделение и освобождение памяти происходит автоматически (когда переменная создается или уничтожается). В большинстве случаев с этим всё ОК. Однако когда дело доходит до работы с внешним вводом, то эти ограничения могут привести к проблемам. Например, при использовании для хранения имени мы не знаем наперед насколько длинным оно будет, пока пользователь его не введет. Или когда нам нужно записать количество записей с диска в переменную, но мы не знаем заранее, сколько этих записей есть. Или мы можем создать игру с непостоянным количеством монстров (во время игры одни монстры умирают, другие рождаются), пытаясь, таким образом, убить игрока. Если нам нужно объявить размер всех переменных во время компиляции, то самое лучшее, что мы можем сделать – это попытаться угадать их максимальный размер, надеясь, что этого будет достаточно: char name; // будем надеяться, что пользователь введет имя менее 30 символов!
Record record; // будем надеяться, что количество записей будет не больше 400!
Monster monster; // 30 монстров максимум
Polygon rendering; // этому 3d rendering лучше состоять из менее чем 40,000 полигонов! Это плохое решение, по крайней мере, по трем причинам: Во-первых, теряется память, если переменные фактически не используются или используются, но не на полную. Например, если мы выделим 30 символов для каждого имени, но имена в среднем будут занимать по 15 символов, то потребление памяти получится в два раза больше, чем нужно на самом деле. Или рассмотрим массив rendering: если он использует только 20 000 полигонов, то память с 20 000 полигонами фактически тратится впустую (т.е. не используется)! Во-вторых, память для большинства обычных переменных (включая фиксированные массивы) выделяется из специального резервуара памяти — стека
. Объем памяти стека в программе, как правило, невелик – в Visual Studio он по умолчанию равен 1МБ. Если вы превысите это число, то произойдет переполнение стека
, и операционная система автоматически завершит выполнение вашей программы. В Visual Studio это можно проверить, запустив следующую программу: int main()
{
int array; // выделяем 1 миллион целочисленных значений
} Лимит в 1МБ памяти может быть проблематичным для многих программ, особенно где используется графика. В-третьих, и самое главное, это может привести к искусственным ограничениям и/или переполнению массива. Что произойдет, если пользователь попытается прочесть 500 записей с диска, но мы выделили память максимум для 400? Либо мы выведем пользователю ошибку, что максимальное количество записей — 400, либо (в худшем случае) выполнится переполнение массива и затем что-то очень нехорошее. К счастью, эти проблемы легко устраняются с помощью динамического выделения памяти. Динамическое выделение памяти
— это способ запроса памяти из операционной системы запущенными программами при необходимости. Эта память не выделяется из ограниченной памяти стека программы, а из гораздо большего хранилища, управляемого операционной системой — heap
(кучи
)
.
На современных компьютерах размер кучи может составлять гигабайты памяти. Для динамического выделения памяти для одной переменной используется оператор new
: new int; // динамически выделяем целочисленную переменную и сразу же отбрасываем результат (так как нигде его не сохраняем) В примере выше мы запрашиваем выделение памяти для целочисленной переменной из операционной системы. Оператор new возвращает , содержащий адрес выделенной памяти. Для доступа к выделенной памяти создается указатель: int *ptr = new int; // динамически выделяем целочисленную переменную и присваиваем её адрес ptr, чтобы потом иметь возможность доступа к ней Затем мы можем разыменовать указатель для получения значения: *ptr = 8; // присваиваем значение 8 только что выделенной памяти Вот один из случаев, когда указатели полезны. Без указателя с адресом на только что выделенную память, у нас бы не было способа получить доступ к ней. На вашем компьютере имеется память (возможно, большая ее часть), которая доступна для использования приложениями. При запуске приложения ваша операционная система загружает это приложение в некоторую часть этой памяти. И эта память, используемая вашим приложением, разделена на несколько частей, каждая из которых выполняет определенную задачу. Одна часть содержит ваш код, другая используется для выполнения обычных операций (отслеживание вызываемых функций, создание и уничтожение глобальных и локальных переменных и т. д.). Мы поговорим об этом позже. Тем не менее, большая часть доступной памяти просто находится там, ожидая запросов на выделение от программ. Когда вы динамически выделяете память, вы просите операционную систему зарезервировать часть этой памяти для использования вашей программой. Если ОС может выполнить этот запрос, то возвращается адрес этой памяти обратно, в ваше приложение. С этого момента и в дальнейшем ваше приложение может использовать эту память, как только пожелает. Когда вы уже выполнили всё, что было необходимо, с этой памятью, то её нужно вернуть обратно в операционную систему, для распределения между другими запросами. В отличие от статического или автоматического выделения памяти, сама программа отвечает за запрос и обратный возврат динамически выделенной памяти. Когда вы динамически выделяете переменную, то вы также можете её инициализировать посредством или uniform инициализации (в С++11): int *ptr1 = new int (7); // используем прямую инициализацию
int *ptr2 = new int { 8 }; // используем uniform инициализацию Когда уже всё, что нужно было, выполнено с динамически выделенной переменной – нужно явно указать С++ освободить эту память. Для отдельных переменных это выполняется с помощью оператора delete
: // предположим, что ptr ранее уже был выделен с помощью оператора new
delete ptr; // возвращаем память, на которую указывал ptr, обратно в операционную систему
ptr = 0; // делаем ptr нулевым указателем (используйте nullptr вместо 0 в C++11) Оператор delete на самом деле ничего не удаляет. Он просто возвращает память, которая была выделена ранее, обратно в операционную систему. Затем операционная система может переназначить эту память другому приложению (или этому же снова). Хотя может показаться, что мы удаляем переменную
, но это не так! Переменная-указатель по-прежнему имеет ту же область видимости, что и раньше, и ей можно присвоить новое значение, как и любой другой переменной. Обратите внимание, удаление указателя, не указывающего на динамически выделенную память, может привести к проблемам. C++ не дает никаких гарантий относительно того, что произойдет с содержимым освобожденной памяти, или со значением удаляемого указателя. В большинстве случаев память, возвращаемая операционной системе, будет содержать те же значения, которые были у нее до освобождения
, а указатель так и останется указывать на память, только уже освобожденную (удаленную). Указатель, указывающий на освобожденную память, называется висячим указателем
. Разыменование или удаление висячего указателя приведет к неожиданным результатам. Рассмотрим следующую программу: #include #include int
main
()
int
*
ptr
=
new
int
;
// динамически выделяем целочисленную переменную
*
ptr
=
8
;
// помещаем значение в выделенную ячейку памяти
delete
ptr
;
// возвращаем память обратно в операционную систему. ptr теперь уже висячий указатель
std
::
cout
<<
*
ptr
;
// разыменование висячого указателя приведет к неожиданным результатам
delete
ptr
;
// попытка освободить память снова приведет к неожиданным результатам также
return
0
;
В программе выше значение 8, которое ранее было присвоено выделенной памяти, после освобождения может и далее находиться там, а может и нет. Также возможно, что освобожденная память уже могла быть выделена другому приложению (или для собственного использования операционной системы), и попытка доступа к ней приведет к тому, что операционная система автоматически прекратит выполнение вашей программы. Процесс освобождения памяти может также привести к созданию нескольких
висячих указателей. Рассмотрим следующий пример: #include #include int
main
()
int
*
ptr
=
new
int
;
// динамически выделяем целочисленную переменную
int
*
otherPtr
=
ptr
;
// otherPtr теперь указывает на ту же самую выделенную память, что и ptr
delete
ptr
;
// возвращаем память обратно в операционную систему. ptr и otherPtr теперь висячие указатели
ptr
=
0
;
// ptr теперь уже nullptr
// однако otherPtr по-прежнему является висячим указателем!
return
0
;
Во-первых, старайтесь избегать ситуаций, когда несколько указателей указывают на одну и ту же часть выделенной памяти. Если это невозможно, то проясните, какой указатель из всех «владеет» памятью (и отвечает за ее удаление), а какие указатели просто получают доступ к ней. Во-вторых, когда вы удаляете указатель, и если он не выходит из сразу же после удаления, то его нужно сделать нулевым, т.е. задать значение 0 (или в С++11). Под «выходом из области видимости сразу же после удаления» имеется в виду, что вы удаляете указатель в самом конце блока, в котором он объявлен. Правило: Присваивайте удаленным указателям значение 0 (или nullptr в C++11), если они не выходят из области видимости сразу же после удаления.
При запросе памяти из операционной системы в редких случаях она может быть не доступной (т.е. её может и не быть в наличии). По умолчанию, если new не сработал, память не выделилась, то генерируется исключение bad_alloc
. Если это исключение будет неправильно обрабатываться (а именно так и будет, поскольку мы еще не рассмотрели исключения и их обработку), то программа просто прекратит своё выполнение (произойдет сбой) с необработанной ошибкой исключения. Во многих случаях процесс генерации исключения оператором new (как и сбой программы) нежелателен, поэтому есть альтернативная форма new, которая возвращает нулевой указатель, если память не может быть выделена. Нужно просто добавить константу std::nothrow между ключевым словом new и типом выделения данных: int *value = new (std::nothrow) int; // указатель value станет нулевым, если динамическое выделение целочисленной переменной не выполнится В примере выше, если new не возвратит указатель с динамически выделенной памятью, то возвратится нулевой указатель. Разыменовывать его также не рекомендуется, так как это приведет к неожиданным результатам (скорее всего, к сбою в программе). Поэтому, наилучшей практикой является проверка всех запросов на выделение памяти, для обеспечения того, что эти запросы выполняться успешно и память будет выделена. int *value = new (std::nothrow) int; // запрос на выделение динамической памяти для целочисленного значения
if (!value) // обрабатываем случай, когда new возвращает null (т.е. память не выделяется)
{
// обработка этого случая
std::cout << "Could not allocate memory";
} Поскольку не выделение памяти оператором new происходит крайне редко, то обычно программисты забывают выполнять эту проверку! Нулевые указатели (указатели со значением 0 или nullptr) особенно полезны в процессе выделения динамической памяти. Их наличие как бы говорит: «этому указателю не выделено никакой памяти». А это в свою очередь можно использовать для выполнения условного выделения памяти: // если ptr-у до сих пор не выделено памяти, выделяем её
if (!ptr)
ptr = new int; Удаление нулевого указателя ни на что не влияет. Таким образом, в следующем нет необходимости: if (ptr)
delete ptr; if
(ptr
)
delete
ptr
;
Вместо этого вы можете просто написать: delete
ptr
;
Если ptr не является нулевым, то динамически выделенная переменная будет удалена. Если значением указателя является нуль, то ничего не произойдет. Динамически выделенная память не имеет области видимости. То есть она остается выделенной до тех пор, пока не будет явно освобождена или пока ваша программа не завершится (и операционная система очистит все буфера памяти самостоятельно). Однако указатели, используемые для хранения динамически выделенных адресов памяти, следуют правилам области видимости нормальных переменных. Это несоответствие может вызвать интересное поведение. Рассмотрим следующую функцию: void doSomething()
{
int *ptr = new int;
}
На написание данной статьи меня побудило часто встречаемое заблуждение по поводу new
и delete
, которое я постоянно вижу на форумах и даже(!!!) в некоторых книгах.
Все ли мы знаем, что такое на самом деле new
и delete
? Или только думаем, что знаем?
Эта статья поможет вам разобраться с этим (ну, а те, кто знают, могут покритиковать:))
Note
: ниже пойдет речь исключительно об операторе new, для других форм оператора new и для всех форм оператора delete все ниженаписанное также является правдой и применимо по аналогии.
Оператор new
выделяет память больше или равную требуемому размеру и, в отличие от функций языка С, вызывает конструктор(ы) для объекта(ов), под которые память выделена… вы можете перегрузить (где-то пишут реализовать) оператор new
под свои нужды.
И для примера показывают примитивную перегрузку (реализацию) оператора new, прототип которого выглядит так
void* operator new (std::size_t size) throw (std::bad_alloc);
1. Нигде не разделяют new
key-word
языка С++ и оператор new
, везде о них говорят как об одной сущности.
2. Везде пишут, что new
вызывает конструктор(ы) для объекта(ов).
И первое и второе является распространенным заблуждением.5.3.4
The new-expression attempts to create an object of the type-id (8.1) or new-type-id to which it is applied. /*дальше нам не интересно*/
18.6.1
void* operator new(std::size_t size) throw(std::bad_alloc);
Effects: The allocation function called by a new-expression (5.3.4) to allocate size bytes of
storage suitably aligned to represent any object of that size /*дальше нам не интересно*/
Попробуем разобраться почему так, для этого нам понадобятся ассемблерные листинги, полученные после компиляции кода, использующего new.
Ну, а теперь обо все по порядку.
А вот new-expression
как раз и вызывает конструктор(ы) объекта(ов). Хотя правильней сказать, что он тоже ничего не вызывает, просто, встречая его, компилятор генерирует код вызова конструктора(ов).
(код получен компилятором cl, используемым в MSVS 2012, хотя в основном я использую gcc, но это к делу не относится)
/Foo *bar = new Foo;
push 1 ; размер в байтах для объекта Foo
call operator new (02013D4h) ; вызываем operator new
pop ecx
mov dword ptr ,eax ; записываем указатель, вернувшийся из new, в bar
and dword ptr ,0
cmp dword ptr ,0 ; проверяем не 0 ли записался в bar
je main+69h (0204990h) ; если 0, то уходим отсюда (возможно вообще из main или в какой-то обработчик, в данном случае неважно)
mov ecx,dword ptr ; кладем указатель на выделенную память в ecx (MSVS всегда передает this в ecx(rcx))
call Foo::Foo (02011DBh) ; и вызываем конструктор; дальше не интересно
Для тех, кто ничего не понял, вот (почти) аналог того, что получилось на сиподобном псевдокоде (т.е. не надо пробовать это компилировать:))
Foo *bar = operator new (1); // где 1 - требуемый размер
bar->Foo(); // вызываем конструктор
1. оператор (языка) new
и operator new()
- это НЕ одно и тоже.
2. operator new()
НЕ вызывает конструктор(ы)
3. вызов конструктора(ов) генерирует компилятор, встречая в коде key-word «new»
Хабражитель с ником khim
в личной переписке предложил следующий код, который хорошо демонстрирует суть написанного выше.
#include
Этот код выведет следующее
Test::operator new(1)
Test::Test()
Test::operator new(100)
что и следовало ожидать.Динамическое выделение переменных
Как работает динамическое выделение памяти?
Инициализация динамически выделенных переменных
Удаление переменных
Что означает «удаление памяти»?
Висячие указатели
Работа оператора new
Нулевые указатели и динамическое выделение памяти
Утечка памяти