Операторы new и delete
C++ поддерживает динамическое выделение и освобождение объектов с помощью new операторов и delete операторов. Эти операторы выделяют память для объектов из пула, называемого свободным хранилищем. Оператор new вызывает специальную функцию operator new , а delete оператор вызывает специальную функцию operator delete .
Функция new в стандартной библиотеке C++ поддерживает поведение, указанное в стандарте C++, которое вызывает std::bad_alloc исключение при сбое выделения памяти. Если вы по-прежнему хотите использовать неисключающую версию new , свяжите программу с nothrownew.obj . Однако при связывании со nothrownew.obj стандартной библиотекой C++ значение по умолчанию operator new больше не работает.
Список файлов библиотеки в библиотеке среды выполнения C и стандартной библиотеке C++ см. в разделе «Функции библиотеки CRT».
Оператор new
Компилятор преобразует оператор, например этот, в вызов функции operator new :
Если запрос равен нулю байтов хранилища, operator new возвращает указатель на отдельный объект. То есть повторяющиеся вызовы для operator new возврата разных указателей. Если для запроса на выделение недостаточно памяти, operator new возникает std::bad_alloc исключение. Или возвращается nullptr , если вы связали в поддержке, отличной от создания operator new .
Вы можете написать подпрограмму, которая пытается освободить память и повторить выделение. Для получения дополнительной информации см. _set_new_handler . Дополнительные сведения о схеме восстановления см. в разделе «Обработка нехватки памяти «.
Две области для operator new функций описаны в следующей таблице.
Область для operator new функций
| Оператор | Область |
|---|---|
| ::operator new | Глобальный |
| имя класса ::operator new | Класс |
Первый аргумент operator new должен иметь тип size_t , определенный в <stddef.h>, и возвращаемый тип всегда void* .
Глобальная operator new функция вызывается, когда new оператор используется для выделения объектов встроенных типов, объектов типа класса, не содержащих определяемых operator new пользователем функций, и массивов любого типа. new Если оператор используется для выделения объектов определенного типа operator new класса, вызывается этот класс operator new .
Функция, определенная operator new для класса, является статической функцией-членом (которая не может быть виртуальной), которая скрывает глобальную operator new функцию для объектов этого типа класса. Рассмотрим случай, когда new используется для выделения и задания памяти заданному значению:
Аргумент, указанный в скобках, new передается Blanks::operator new в качестве аргумента chInit . Однако глобальная operator new функция скрыта, что приводит к возникновению ошибки, например следующего:
Компилятор поддерживает массив new элементов и delete операторы в объявлении класса. Пример:
Обработка нехватки памяти
Тестирование на выделение памяти сбоем можно выполнить, как показано ниже.
Существует еще один способ обработки неудачных запросов на выделение памяти. Напишите пользовательскую подпрограмму восстановления для обработки такого сбоя, а затем зарегистрируйте функцию, вызвав _set_new_handler функцию времени выполнения.
Оператор delete
Память, которая динамически выделяется с помощью new оператора, можно освободить с помощью delete оператора. Оператор удаления вызывает функцию operator delete , которая освобождает память обратно в доступный пул. delete Использование оператора также приводит к вызову деструктора класса (если таковой существует).
Существуют глобальные и классовые operator delete функции. Для заданного класса можно определить только одну operator delete функцию. Если она определена, она скрывает глобальную operator delete функцию. Глобальная operator delete функция всегда вызывается для массивов любого типа.
Глобальная operator delete функция. Для глобальных operator delete и членных operator delete функций существуют две формы:
Для данного класса может присутствовать только одна из предыдущих двух форм. Первая форма принимает один аргумент типа void * , который содержит указатель на объект для освобождения. Вторая форма, освобождение размера, принимает два аргумента: первая — указатель на блок памяти для освобождения, а второй — количество байтов для освобождения. Тип возвращаемого значения обеих форм ( void operator delete не может возвращать значение).
Цель второй формы — ускорить поиск правильной категории размера удаляемого объекта. Эта информация часто не хранится рядом с самим выделением и, скорее всего, не качается. Вторая форма полезна, если operator delete функция из базового класса используется для удаления объекта производного класса.
Функция operator delete является статической, поэтому она не может быть виртуальной. Функция operator delete подчиняется управлению доступом, как описано в разделе «Член-контроль доступа».
В следующем примере показаны определяемые operator new пользователем функции и operator delete функции, предназначенные для записи выделения и освобождения памяти:
Приведенный выше код можно использовать для обнаружения утечки памяти, то есть памяти, выделенной в свободном хранилище, но никогда не освобождаемой. Для обнаружения утечек глобальные new и delete операторы переопределяются для подсчета выделения и освобождения памяти.
Компилятор поддерживает массив new элементов и delete операторы в объявлении класса. Пример:
Динамическое выделение памяти в C++
С++ использует новые методы работы с динамической памятью при помощи операторов new и delete :
- new — для выделения памяти;
- delete — для освобождения памяти.
Оператор new используется в следующих формах:
- new тип; — для переменных
- new тип[размер]; — для массивов
Память может быть распределена для одного объекта или для массива любого типа, в том числе типа, определенного пользователем. Результатом выполнения операции new будет указатель на отведенную память, или исключение std::bad_alloc в случае ошибки.
Память, отведенная в результате выполнения new , будет считаться распределенной до тех пор, пока не будет выполнена операция delete .
Освобождение памяти связано с тем, как выделялась память – для одного элемента или для нескольких. В соответствии с этим существует и две формы применения delete :
- delete указатель; — для одного элемента
- delete[] указатель; — для массивов
Например, для приведенного выше случая, освободить память необходимо следующим образом:
Освобождаться с помощью delete может только память, выделенная оператором new .
Пример Создание динамического массива
Результат выполнения 
Указатель dan – базовый адрес динамически распределяемого массива, число элементов которого равно size . Операцией delete освобождается память, распределенная при помощи new .
Пример неудачного выделения памяти (в случае очень большого требуемого объема):
Комментариев к записи: 30
#include <iostream>
#include <cstring>
char *resize( const char *str, unsigned size, unsigned new_size);
char *getline();
using namespace std;
int main()
<
char *s;
s= getline();
cout << s << endl;
>
// Принимает строку, размер этой строки, новый размер строки, возвращает указатель на новую строку.
char *resize( const char *str, unsigned size, unsigned new_size)
<
char *ns = new char [ sizeof ( char )*new_size];
for ( unsigned i=0;i<new_size&&i<size;i++)
<
ns[i]=str[i];
>
delete []str;
return ns;
>
// Получаем строку и увеличиваем ее понеобходимости.
char *getline() //
<
unsigned j=1; //размер массива
char *temp= new char [j]<'\0'>;
char c;
while (std::cin.get(c) && c != '\n' && c != std::cin.eof())
<
temp[j-1]=c;
temp=resize (temp,j,++j);
>
temp[j-1]='\0';
return temp;
>
#include <iostream>
#include <conio.h>
#define ESC 27
#define EOS '\n'
using namespace std;
typedef struct <
float **matrix;
unsigned int volume;
char name;
>matrix;
Как использовать динамическую память в c++?
Как работает динамическая память и какими операторами пользоваться для работы с ней в C++?
В С++ объекты создаются динамически при помощи new-выражений и разрушаются при помощи delete-выражений.
New-выражения и delete-выражения используют функции выделения динамической памяти operator new , operator new[] и функции освобождения operator delete , operator delete[] соответственно.
Реализация С++ предоставляет несколько глобальных функций выделения и освобождения. При этом они могут быть переопределены пользователем без нарушения ODR (но не более одного раза в программе).
Пользователь также может добавлять свои функции выделения и освобождения, в виде статических членов класса или свободных функций в глобальном пространстве имен. Такие пользовательские функции должны соблюдать семантику встроенных (не выделять уже выделенные адреса и т.п.).
Выражения new и delete для одного объекта
Функции operator new и operator delete только выделяют и освобождают память. Конструирование и разрушение объекта происходит в самом выражении new и delete . Для вызова конструктора используется new который не выделяет память — размещающий new .
Из кода выше видно, что new-выражение требует обе функции, operator new и operator delete .
Функции operator new и operator delete в стандартной библиотеке
Обычный new
Пользователь может установить свою функцию new_handler при помощи функции std::set_new_handler .
Не-бросающий исключений new
Размещающий new
Ничего не выделяет, возвращают аргумент ptr .
Позволяют вызвать конструктор объекта.
Размещающий operator delete также существует, и также ничего не делает. Нужен только потому что new-выражение требудет наличия operator delete .
Динамические массивы, new[] и delete[]
Функции operator new[] и operator delete[] служат для выделения памяти, и ничем не отличаются от функций для одного объекта. Стандартные реализации просто вызывают operator new :
Размер динамического массива сохраняется самим выражением new[] , примерно так:
Массивы созданные при помощи выражения new T[N] могут быть освобождены только через delete[] ,
и наоборот, объекты созданные new T() , должны быть быть освобождены delete .
Размещающий new[]
Он существует, но мы не знаем сколько байт будут резервироваться копилятором под размер объекта, поэтому не сдедует его использовать:
Динамическая память
Выделяется и освобождается — с помощью специальных инструкций (т. е. по инициативе разработчика). Это позволяет по ходу работы программы контролировать и корректировать объём используемой памяти и, следовательно, создавать программы способные обрабатывать большие объёмы данных, обходя ограниченность физической памяти машины. Выделяется во время работы программы. Все объекты, выделяемые динамически, размещаются в куче (heap). Если не освобождать динамическую память, то у вас memory leak. Динамическая память, как и любая память, будет освобождена по завершении программы (учтите это, ибо выше писалось только про освобождение разработчиком). Работа с динамической памятью
Выделяется память с помощью оператора new, а освобождается — с помощью оператора delete. В момент, когда динамическая память выделена, она должна быть связана с некоторым указателем, подходящего типа (при выделении указывается тип и количество необходимых ячеек данного типа).
Если не освобождать динамическую память, то она будет занята до завершения программы, что неприемлемо. При выделении одной динамической переменной (одной ячейки памяти), можно сразу инициализировать её значение:
Можно выделять сразу несколько ячеек динамической памяти, получая динамический массив. Для этого его размер указывается в квадратных скобках после типа. Чтобы удалить динамический массив и освободить память используется оператор delete[].
Cразу после создания динамический массив автоматически заполняется нулями (в отличии от обычного массива в статической или стековой памяти). Если в указатель, уже хранящий адрес какого-то фрагмента динамической памяти, записать новый адрес, то фрагмент динамической памяти будет потерян, т. е. он не будет освобождён, но к нему никак нельзя будет обратиться (например, чтобы освободить этот фрагмент).
Проблема становится особенно острой, когда в памяти теряются целые массивы (они занимают больше места, чем отдельные переменные).
На каждом шаге цикла создаётся динамический массив из 100 элементов. Всего таких массивов будет создано 10, но только от последнего из них память будет освобождена после выхода из цикла. 9 массивов продолжат занимать место в памяти до конца программы. 9 массивов * 100 элементов * 4 байта = 3600 байт потерянной памяти, которую никак нельзя использовать (ни в этой программе, не в других запущенных). Очень важно после использования динамической памяти не забывать освобождать её в нужный момент! Сайт-источник : http://itedu.ru/courses/cpp/cpp-dynamic-memory-allocation Примеры: С++: Представлена выше, выделена зеленым шрифтом.
Си: Стандартные функции динамического выделения памяти Функции динамического выделения памяти находят в оперативной памяти непрерывный участок требуемой длины и возвращают начальный адрес этого участка. Функции динамического распределения памяти:
Для использования функций динамического распределения памяти необходимо подключение библиотеки malloc.h:
Поскольку все представленные функции в качестве возвращаемого значения имеют указатель на пустой тип void, требуется явное приведение типа возвращаемого значения. Для определения размера массива в байтах, используемого в качестве аргумента функции malloc()требуется количество элементов умножить на размер одного элемента. Поскольку элементами массива могут быть как данные простых типов, так и составных типов (например, структуры), для точного определения размера элемента в общем случае рекомендуется использование функции int sizeof(тип); которая определяет количество байт, занимаемое элементом указанного типа. Память, динамически выделенная с использованием функций calloc(), malloc(), может быть освобождена с использованием функции free(указатель); «Правилом хорошего тона» в программировании является освобождение динамически выделенной памяти в случае отсутствия ее дальнейшего использования. Однако если динамически выделенная память не освобождается явным образом, она будет освобождена по завершении выполнения программы. Функция realloc выполняет перераспределение блоков памяти. Размер блока памяти, на который ссылается параметр ptrmem изменяется на size байтов. Блок памяти может уменьшаться или увеличиваться в размере. Эта функция может перемещать блок памяти на новое место, в этом случае функция возвращает указатель на новое место в памяти. Содержание блока памяти сохраняется даже если новый блок имеет меньший размер, чем старый. Отбрасываются только те данные, которые не вместились в новый блок. Если новое значение size больше старого, то содержимое вновь выделенной памяти будет неопределенным. В случае, если ptrmem равен NULL, функция ведет себя именно так, как функция malloc, т. е. выделяет память и возвращает указатель на этот участок памяти. В случае, если size равен 0, ранее выделенная память будет освобождена, как если бы была вызвана функция free, и возвращается нулевой указатель.
Примеры: Выделение памяти при помощи malloc:
Выделение при помощи calloc:
Выделение памяти при помощи realloc:
Небольшие заметки по поводу памяти в плюсах (на основе опыта, исправляйте ошибки и дополняйте меня): если у нас недостаточно памяти, valloc, calloc и realloc возвращают NULL. Поэтому проверки на null поинетры нужны. В плюсах new либо вернёт значение, либо кинет исключение; если вы пытаетесь использовать память, которая вам не принадлежит, то это undefined behavior. Может быть, вас убъёт ось за то, что лезете не в свой кусок памяти. Может, упадёте с segmentation fault, или попортите данные своего же приложения и будете долго и муторно искать ошибку не там, а может быть, у вас девушка забеременеет. Или всё будет работать. То, что malloc выглядит функцией для инициализации одной переменной, а calloc – для массива – это херня. Все три (включая realloc) выделяют последовательный кусок памяти, так что хоть malloc(n * sizeof(int)), хоть calloc(n, sizeof(int)) – одна херня. в память только для чтения нельзя писать, например:
NULL поинтеру нельзя присвавать какое либо значение, это segmentation fault. Например: