хранит глобальные переменные и константы;
размер определяется при компиляции.
Стек (stack)
хранит локальные переменные, аргументы функций и промежуточные значения вычислений;
размер определяется при запуске программы (обычно выделяется 4 Мб).
Куча (heap)
динамически распределяемая память;
ОС выделяет память по частям (по мере необходимости).
Динамически распределяемую память следует использовать в случае если мы заранее (на момент написания программы) не знаем сколько памяти нам понадобится (например, размер массива зависит от того, что введет пользователь во время работы программы) и при работе с большими объемами данных.
Динамическая память, называемая также "кучей", выделяется явно по запросу программы из ресурсов операционной системы и контролируется указателем. Она не инициализируется автоматически и должна быть явно освобождена. В отличие от статической и автоматической памяти динамическая память практически не ограничена (ограничена лишь размером оперативной памяти) и может меняться в процессе работы программы
Работа с динамической памятью в с
Для работы с динамической памятью в языке С используются следующие функции: malloc, calloc, free, realloc . Рассмотрим их подробнее.
Выделение (захват памяти) : void *malloc(size_t size);
В качестве входного параметра функция принимает размер памяти, которую требуется выделить. Возвращаемым значением является указатель на выделенный в куче участок памяти. Если ОС не смогла выделить память (например, памяти не хватило), то malloc возвращает 0.
После окончания работы с выделенной динамически памятью нужно освободить ее. Для этой цели используется функция free, которая возвращает память под управление ОС: void free(void *ptr);
Еслидинамическая памятьне освобождена до окончания программы, то она освобождается автоматически при завершении программы. Тем не менее, явное освобождение ставшей ненужной памяти является признаком хорошего стиля программирования.
Пример: // выделения памяти под 1 000 элементов типа int
int * p = (int *) malloc(1000*sizeof(int));
if (p==NULL) cout<< "\n память не выделена";
free (p); // возврат памяти в кучу
2. Выделение (захват памяти) : void *calloc(size_t nmemb, size_t size);
Функция работает аналогично malloc, но отличается синтаксисом (вместо размера выделяемой памяти нужно задать количество элементов и размер одного элемента) и тем, что выделенная память будет обнулена. Например, после выполнения int * p = (int *) calloc(1000, sizeof(int)) p будет указывать на начало массива типа int из 1000 элементов, инициализированных нулями.
3. Изменение размера памяти:void *realloc(void *ptr, size_t size);
Функция изменяет размер выделенной памяти (на которую указывает ptr, полученный из вызова malloc, calloc или realloc ). Если размер, указанный в параметре size больше, чем тот, который был выделен под указатель ptr, то проверяется, есть ли возможность выделить недостающие ячейки памяти подряд с уже выделенными. Если места недостаточно, то выделяется новый участок памяти размером size и данные по указателю ptr копируются в начало нового участка.
В процессе выполнения программы участок динамической памяти доступен везде, где доступен указатель, адресующий этот участок. Таким образом, возможны следующие три варианта работы с динамической памятью, выделяемой в некотором блоке (например, в теле неглавной функции).
Указатель (на участок динамической памяти) определен как локальный объект автоматической памяти. В этом случае выделенная память будет недоступна при выходе за пределы блока локализации указателя, и ее нужно освободить перед выходом из блока.
{ int* p= (int *) calloc(n, sizeof(int))
free (p); // освобождение дин. памяти
Указатель определен как локальный объект статической памяти. Динамическая память, выделенная однократно в блоке, доступна через указатель при каждом повторном входе в блок. Память нужно освободить только по окончании ее использования.
{static int* p = (int *) calloc(n, sizeof(int));
p= (int *) calloc(n, sizeof(int));
f(50); //выделение дин. памяти с последующим освобождением
f1(100); //выделение дин. памяти (первое обращение)
f1(100); //работа с дин. памятью
f1 (0); // освобождение дин. памяти
Указатель является глобальным объектом по отношению к блоку. Динамическая память доступна во всех блоках, где "виден" указатель. Память нужно освободить только по окончании ее использования
int* pG; //рабочий указатель для дин. памяти (глобальная переменная)
void init (int size)
for (i=0; i< size; i++) //цикл ввода чисел
{ printf("x[%d]=",i);
scanf("%d", &pG[i]);
int sum (int size)
for (i=0; i< size; i++) //цикл суммирования
// выделение памяти
pG= (int *) calloc(n, sizeof(int));
//работа с дин.памятью
printf(\ns=%d\n”,sum(n));
free (pG); pG=NULL; // освобождение памяти
Работа с динамической памятью в С++
В С++ есть свой механизм выделения и освобождения памяти - это функции new и delete. Пример использования new : int * p = new int; // выделение памяти под 1000 эл-тов Т.е. при использовании функции new не нужно приводить указатель и не нужно использовать sizeof(). Освобождение выделенной при помощи new памяти осуществляется посредством следующего вызова: delete p; Если требуется выделить память под один элемент, то можно использовать int * q = new int; или int * q = new int(10); // выделенный int проинициализируется значением 10 в этом случае удаление будет выглядеть следующим образом: delete q;
Итак. третий тип, самый интересный в этой теме для нас – динамический тип памяти.
Как мы работали с массивами раньше? int a Как мы работаем сейчас? Выделяем столько, сколько нужно:
#include < stdio.h> #include < stdlib.h> int main () { size_t size; // Создаём указатель на int // – по сути, пустой массив. int *list; scanf (" %lu " , &size); // Выделяем память для size элементов размером int // и наш "пустой массив" теперь ссылается на эту память. list = (int *)malloc (size * sizeof (int )); for (int i = 0 ; i < size; ++i) { scanf (" %d " < size; ++i) { printf (" %d " , *(list + i)); } // Не забываем за собой прибраться! free (list); } // *
Void * malloc(size_t size);
Но в общем и целом это функция, выделяет size байт неинициализированной памяти (не нули, а мусор).
Если выделение прошло успешно, то возвращается указатель на самый первый байт выделенной памяти.
Если неуспешно – NULL. Также errno будет равен ENOMEM (эту замечательную переменную мы рассмотрим позднее). То есть правильнее было написать:
#include < stdio.h> #include < stdlib.h> int main () { size_t size; int *list; scanf (" %lu " , &size); list = (int *)malloc (size * sizeof (int )); if (list == NULL ) { goto error; } for (int i = 0 ; i < size; ++i) { scanf (" %d " , list + i); } for (int i = 0 ; i < size; ++i) { printf (" %d " , *(list + i)); } free (list); return 0 ; error: return 1 ; } // *
Очищать NULL указатель не нужно
#include < stdlib.h> int main () { free (NULL ); }
– в том же clang всё пройдёт нормально (сделает ничто), но в более экзотических случаях вполне может крэшнуть программу.
Рядом с malloc и free в мане можно увидеть ещё:
void * calloc (size_t count, size_t size);
Равно как и malloc выделит память под count объектов размером по size байт. Выделяемая память инициализируется нулями.
void * realloc (void *ptr, size_t size);
Перевыделяет (если может) память, на которую указывает ptr , в размере size байт. Если не хватает места для увеличения выделенной памяти, на которое указывает ptr , realloc создает новое выделение (аллокацию), копирует старые данные, на которые указывает ptr , освобождает старое выделение и возвращает указатель на выделенную память.
Если ptr равен NULL , realloc идентичен вызову malloc .
Если size равен нулю, а ptr не NULL , выделяется кусок памяти минимального размера, а исходная освобождается.
void * reallocf (void *ptr, size_t size);
Придумка из FreeBSD API. Как и realloc , но если не сможет перевыделить, очищает принятый указатель.
void * valloc (size_t size);
Как и malloc , но выделенная память выравнивается по границе страницы.
Второй способ, которым С++ может хранить информацию, заключается в использовании системы динамического распределения. При этом способе память распределяется для информации из свободной области памяти по мере необходимости. Область свободной памяти находится между кодом программы с ее постоянной областью памяти и стеком ( рис. 24.1). Динамическое размещение удобно, когда неизвестно, сколько элементов данных будет обрабатываться.
Рис.
24.1.
По мере использования программой стековая область увеличивается вниз, то есть программа сама определяет объем стековой памяти. Например, программа с большим числом рекурсивных функций займет больше стековой памяти, чем программа , не имеющая рекурсивных функций , так как локальные переменные и возвращаемые адреса хранятся в стеках. Память под саму программу и глобальные переменные выделяется на все время выполнения программы и является постоянной для конкретной среды.
Память , выделяемая в процессе выполнения программы, называется динамической. После выделения динамической памяти она сохраняется до ее явного освобождения, что может быть выполнено только с помощью специальной операции или библиотечной функции.
Если динамическая память не освобождена до окончания программы, то она освобождается автоматически при завершении программы. Тем не менее, явное освобождение ставшей ненужной памяти является признаком хорошего стиля программирования.
В процессе выполнения программы участок динамической памяти доступен везде, где доступен указатель , адресующий этот участок. Таким образом, возможны следующие три варианта работы с динамической памятью , выделяемой в некотором блоке (например, в теле неглавной функции).
- Указатель (на участок динамической памяти) определен как локальный объект автоматической памяти. В этом случае выделенная память будет недоступна при выходе за пределы блока локализации указателя, и ее нужно освободить перед выходом из блока.
- Указатель определен как локальный объект статической памяти. Динамическая память, выделенная однократно в блоке, доступна через указатель при каждом повторном входе в блок. Память нужно освободить только по окончании ее использования.
- Указатель является глобальным объектом по отношению к блоку. Динамическая память доступна во всех блоках, где "виден" указатель. Память нужно освободить только по окончании ее использования.
Все переменные, объявленные в программе размещаются в одной непрерывной области памяти, которую называют сегментом данных . Такие переменные не меняют своего размера в ходе выполнения программы и называются статическими . Размера сегмента данных может быть недостаточно для размещения больших объемов информации. Выходом из этой ситуации является использование динамической памяти. Динамическая память – это память , выделяемая программе для ее работы за вычетом сегмента данных, стека, в котором размещаются локальные переменные подпрограмм и собственно тела программы.
Для работы с динамической памятью используют указатели. С их помощью осуществляется доступ к участкам динамической памяти, которые называются динамическими переменными . Для хранения динамических переменных выделяется специальная область памяти, называемая " кучей ".
Динамические переменные создаются с помощью специальных функций и операций. Они существуют либо до конца работы программы, либо до тех пор, пока не будет освобождена выделенная под них память с помощью специальных функций или операций. То есть время жизни динамических переменных – от точки создания до конца программы или до явного освобождения памяти .
В С++ используется два способа работы с динамической памятью:
- использование операций new и delete ;
- использование семейства функций mallос (calloc ) (унаследовано из С).
Работа с динамической памятью с помощью операций new и delete
В языке программирования С++ для динамического распределения памяти существуют операции new и delete . Эти операции используются для выделения и освобождения блоков памяти . Область памяти, в которой размещаются эти блоки, называется свободной памятью .
Операция new позволяет выделить и сделать доступным свободный участок в основной памяти, размеры которого соответствуют типу данных, определяемому именем типа.
Синтаксис :
new ИмяТипа;
new ИмяТипа [Инициализатор];
В выделенный участок заносится значение , определяемое инициализатором , который не является обязательным элементом. В случае успешного выполнения new возвращает адрес начала выделенного участка памяти. Если участок нужных размеров не может быть выделен (нет памяти), то операция new возвращает нулевое значение адреса (NULL ).
Синтаксис применения операции :
Указатель = new ИмяТипа [Инициализатор];
Операция new float выделяет участок памяти размером 4 байта. Операция new int(15) выделяет участок памяти 4 байта и инициализирует этот участок целым значением 15. Синтаксис использования операций new и delete предполагает применение указателей. Предварительно каждый указатель должен быть объявлен:
тип *ИмяУказателя;
Например:
float *pi; //Объявление переменной pi pi=new float; //Выделение памяти для переменной pi * pi = 2.25; //Присваивание значения
В качестве типа можно использовать, например, стандартные типы int, long, float, double, char .
Оператор new чаще всего используется для размещения в памяти данных определенных пользователем типов, например, структур:
struct Node { char *Name; int Value; Node *Next }; Node *PNode; //объявляется указатель PNode = new Node; //выделяется память PNode->Name = "Ata"; //присваиваются значения PNode->Value = 1; PNode->Next = NULL;
В качестве имени типа в операции new может быть использован массив :
new ТипМассива
При выделении динамической памяти для массива его размеры должны быть полностью определены. Например:
ptr = new int ;//10 элементов типа int или 40 байт ptr = new int ;//неверно, т.к. не определен размер
Такая операция позволяет выделить в динамической памяти участок для размещения массива соответствующего типа, но не позволяет его инициализировать. В результате выполнения операция new возвратит указатель , значением которого служит адрес первого элемента массива. Например:
int *n = new int;
Операция new выполняет выделение достаточного для размещения величины типа int участка динамической памяти и записывает адрес начала этого участка в переменную n . Память под саму переменную n (размера, достаточного для размещения указателя) выделяется на этапе компиляции.
Мы открыли для себя возможности динамического выделения памяти. Что это значит? Это значит то, что при динамическом выделении памяти, память резервируется не на этапе компиляции а на этапе выполнения программы. И это дает нам возможность выделять память более эффективно, в основном это касается массивов. С динамическим выделением память, нам нет необходимости заранее задавать размер массива, тем более, что не всегда известно, какой размер должен быть у массива. Далее рассмотрим каким же образом можно выделять память.
Выделение памяти в Си (функция malloc)
Функция malloc() определена в заголовочном файле stdlib.h , она используется для инициализации указателей необходимым объемом памяти. Память выделяется из сектора оперативной памяти доступного для любых программ, выполняемых на данной машине. Аргументом является количество байт памяти, которую необходимо выделить, возвращает функция — указатель на выделенный блок в памяти. Функция malloc() работает также как и любая другая функция, ничего нового.
Так как различные типы данных имеют разные требования к памяти, мы как-то должны научиться получить размер в байтах для данных разного типа. Например, нам нужен участок памяти под массив значений типа int — это один размер памяти, а если нам нужно выделить память под массив того же размера, но уже типа char — это другой размер. Поэтому нужно как-то вычислять размер памяти. Это может быть сделано с помощью операции sizeof() , которая принимает выражение и возвращает его размер. Например, sizeof(int) вернет количество байтов, необходимых для хранения значения типа int . Рассмотрим пример:
#include
В этом примере, в строке 3 указателю ptrVar присваивается адрес на участок памяти, размер которого соответствует типу данных int . Автоматически, этот участок памяти становится недоступным для других программ. А это значит, что после того, как выделенная память станет ненужной, её нужно явно высвободить. Если же память не будет явно высвобождена, то по завершению работы программы, память так и не освободится для операционной системы, это называется утечкой памяти. Также можно определять размер выделяемой памяти, которую нужно выделить передавая пустой указатель, вот пример:
Int *ptrVar = malloc(sizeof(*ptrVar));
Что здесь происходит? Операция sizeof(*ptrVar) оценит размер участка памяти, на который ссылается указатель. Так как ptrVar является указателем на участок памяти типа int , то sizeof() вернет размер целого числа. То есть, по сути, по первой части определения указателя, вычисляется размер для второй части. Так зачем же это нам надо? Это может понадобиться, если вдруг необходимо поменять определение указателя, int , например, на float и тогда, нам не нужно менять тип данных в двух частях определения указателя. Достаточно будет того, что мы поменяем первую часть:
Float *ptrVar = malloc(sizeof(*ptrVar));
Как видите, в такой записи есть одна очень сильная сторона, мы не должны вызывать функцию malloc() с использованием sizeof(float) . Вместо этого мы передали в malloc() указатель на тип float , в таком случае, размер выделяемой памяти автоматически определится сам!
Особенно это пригодится, если выделять память потребуется далеко от определения указателя:
Float *ptrVar; /* . . . сто строк кода */ . . . ptrVar = malloc(sizeof(*ptrVar));
Если бы вы использовали конструкцию выделения памяти с операцией sizeof() , то вам бы пришлось находить в коде определение указателя, смотреть его тип данных и уже потом вы бы смогли правильно выделить память.
Высвобождение выделенной памяти
Высвобождение памяти выполняется с помощью функции free() . Вот пример:
Free(ptrVar);
После освобождения памяти, хорошей практикой является сброс указателя в нуль, то есть присвоить *ptrVar = 0 . Если указателю присвоить 0, указатель становится нулевым, другими словами, он уже никуда не указывает. Всегда после высвобождения памяти, присваивайте указателю 0, в противном случае, даже после высвобождения памяти, указатель все равно на неё указывает, а значит вы случайно можете нанести вред другим программам, которые, возможно будут использовать эту память, но вы даже ничего об этом не узнаете и будете думать, что программа работает корректно.
P.S.: Всем, кто увлекается видеомонтажом может быть интересен этот редактор видео Windows 7 . Видеоредактор называется Movavi, может кто-то уже с ним знаком или даже работал с ним. С помощью этой программы на русском языке, вы легко можете добавить видео с камеры, улучшить качество и наложить красивые видео эффекты.
Последнее обновление: 28.05.2017
При создании массива с фиксированными размерами под него выделяется определенная память. Например, пусть у нас будет массив с пятью элементами:
Double numbers = {1.0, 2.0, 3.0, 4.0, 5.0};
Для такого массива выделяется память 5 * 8 (размер типа double) = 40 байт. Таким образом, мы точно знаем, сколько в массиве элементов и сколько он занимает памяти. Однако это не всегда удобно. Иногда бывает необходимо, чтобы количество элементов и соответственно размер выделяемой памяти для массива определялись динамически в зависимости от некоторых условий. Например, пользователь сам может вводить размер массива. И в этом случае для создания массива мы можем использовать динамическое выделение памяти.
Для управления динамическим выделением памяти используется ряд функций, которые определены в заголовочном файле stdlib.h :
malloc() . Имеет прототип
Void *malloc(unsigned s);
Выделяет память длиной в s байт и возвращает указатель на начало выделенной памяти. В случае неудачного выполнения возвращает NULL
calloc() . Имеет прототип
Void *calloc(unsigned n, unsigned m);
Выделяет память для n элементов по m байт каждый и возвращает указатель на начало выделенной памяти. В случае неудачного выполнения возвращает NULL
realloc() . Имеет прототип
Void *realloc(void *bl, unsigned ns);
Изменяет размер ранее выделенного блока памяти, на начало которого указывает указатель bl, до размера в ns байт. Если указатель bl имеет значение NULL , то есть память не выделялась, то действие функции аналогично действию malloc
free() . Имеет прототип
Void *free(void *bl);
Освобождает ранее выделенный блок памяти, на начало которого указывает указатель bl.
Если мы не используем эту функцию, то динамическая память все равно освободится автоматически при завершении работы программы. Однако все же хорошей практикой является вызов функции free() , который позволяет как можно раньше освободить память.
Рассмотрим применение функций на простой задаче. Длина массива неизвестна и вводится во время выполнения программы пользователем, и также значения всех элементов вводятся пользователем:
#include Консольный вывод программы: Size of array=5
block=23
block=-4
block=0
block=17
block=81
23 -4 0 17 81 Здесь для управления памятью для массива определен указатель block типа int
. Количество элементов массива заранее неизвестно,
оно представлено переменной n. Вначале пользователь вводит количество элементов, которое попадает в переменную n. После этого необходимо выделить память для данного количества
элементов. Для выделения памяти здесь мы могли бы воспользоваться любой из трех вышеописанных функций: malloc, calloc, realloc.
Но конкретно в данной ситуации воспользуемся функцией malloc
: Block = malloc(n * sizeof(int));
Прежде всего надо отметить, что все три выше упомянутые функции для универсальности возвращаемого значения в качестве результата возвращают указатель типа
void *
. Но в нашем случае создается массив типа int, для управления которым используется указатель типа int *
,
поэтому выполняется неявное приведение результата функции malloc к типу int *
. В саму функцию malloc передается количество байтов для выделяемого блока. Это количество подсчитать довольно просто: достаточно умножить количество элементов на размер одного элемента
n * sizeof(int) . После выполнения всех действий память освобождается с помощью функции free()
: Free(block);
Важно, что после выполнения этой функции мы уже не сможем использовать массив, например, вывести его значения на консоль: Free(block);
for(int i=0;i И если мы попытаемся это сделать, то получим неопределенные значения. Вместо функции malloc аналогичным образом мы могли бы использовать функцию calloc()
, которая принимает количество элементов и размер одного элемента: Block = calloc(n, sizeof(int));
Либо также можно было бы использовать функцию realloc()
: Int *block = NULL;
block = realloc (block, n * sizeof(int));
При использовании realloc желательно (в некоторых средах, например, в Visual Studio, обязательно) инициализировать указатель хотя бы значением NULL. Но в целом все три вызова в данном случае имели бы аналогичное действие: Block = malloc(n * sizeof(int));
block = calloc(n, sizeof(int));
block = realloc (block, n * sizeof(int));
Теперь рассмотрим более сложную задачу - динамическое выделение памяти для двухмерного массива:
#include Переменная table представляет указатель на массив указателей типа int*
. Каждый указатель table[i] в этом массиве представляет указатель на подмассив элементов типа int
, то есть отдельные строки таблицы.
А переменная table фактически представляет указатель на массив указателей на строки таблицы. Для хранения количества элементов в каждом подмассиве определяется указатель rows типа int
. Фактически он хранит количество столбцов для каждой строки таблицы. Сначала вводится количество строк в переменную rowscount . Количество строк - это количество указателей в массиве, на который указывает указатель table .
И кроме того, количество строк - это количество элементов в динамическом массиве, на который указывает указатель rows . Поэтому вначале необходимо для всех этих массивов
выделить память: Table = calloc(rowscount, sizeof(int*));
rows = malloc(sizeof(int)*rowscount);
Далее в цикле осуществляется ввод количества столбцов для каждый строки. Введенное значение попадает в массив rows. И в соответствии с введенным значением для каждой строки выделяется необходимый размер памяти: Scanf("%d", &rows[i]);
table[i] = calloc(rows[i], sizeof(int));
Затем производится ввод элементов для каждой строки. В конце работы программы при выводе происходит освобождение памяти. В программе память выделяется для строк таблицы, поэтому эту память надо освободить: Free(table[i]);
И кроме того, освобождается память, выделенная для указателей table и rows: Free(table);
free(rows);
Консольный вывод программы: Rows count=2
Columns count for 1=3
table=1
table=2
table=3
Columns count for 2=2
table=4
table=5
1 2 3
4 5
