Alexey.Gurevich: Новая страница: «== Виды памяти == Память, которую использует программа делится на три вида: 1. Статическая п…»

2011-03-27T19:29:14Z

Новая страница: «== Виды памяти == Память, которую использует программа делится на три вида: 1. Статическая п…»

Новая страница

== Виды памяти ==

Память, которую использует программа делится на три вида:

1. Статическая память (static memory)
* хранит глобальные переменные и константы;
* размер определяется при компиляции.
2. Стек (stack)
* хранит локальные переменные, аргументы функций и промежуточные значения вычислений;
* размер определяется при запуске программы (обычно выделяется 4 Мб).
3. Куча (heap)
* динамически распределяемая память;
* ОС выделяет память по частям (по мере необходимости).

Динамически распределяемую память следует использовать в случае если мы заранее (на момент написания программы) не знаем сколько памяти нам понадобится (например, размер массива зависит от того, что введет пользователь во время работы программы) и при работе с большими объемами данных (например, массив из 1 000 000 элементов типа <code>int</code> не поместится на стеке).

== Работа с динамической памятью в С ==

Для работы с динамической памятью в языке С используются следующие функции: <code>malloc, calloc, free, realloc</code>.
Рассмотрим их подробнее.
<source lang="cpp">
void * malloc(size_t size);
</source>
В качестве входного параметра функция принимает размер памяти, которую требуется выделить. Возвращаемым значением является указатель на выделенный в куче участок памяти.
Для выделения памяти под 1 000 000 элементов типа <code>int</code> необходимо выполнить следующий код:
<source lang="cpp">
int * p = malloc(1000000 * sizeof(int));
</source>
В языке С++ потребуется небольшая модификация данной кода (из-за того, что в С++ нет неявного приведения указателей):
<source lang="cpp">
int * p = (int *) malloc(1000000 * sizeof(int));
</source>
Если ОС не смогла выделить память (например, памяти не хватило), то <code>malloc</code> возвращает 0.

После окончания работы с выделенной динамически памятью нужно освободить ее. Для этой цели используется функция <code>free</code>, которая возвращает память под управление ОС.
<source lang="cpp">
void free(void * ptr);
</source>
В качестве входного параметра в <code>free</code> нужно передать указатель, значение которого получено из функции <code>malloc</code>. Вызов <code>free</code> на указателях полученных не из <code>malloc</code> (например, <code>free(p+10)</code>) приведет к неопределенному поведению. Это связанно с тем, что при выделении памяти при помощи <code>malloc</code> в ячейки перед той, на которую указывает возвращаемый функцией указатель операционная система записывает служебную информацию (см. рис.). При вызове <code>free(p+10)</code> информация находящаяся перед ячейкой <code>(p+10)</code> будет трактоваться как служебная.

[[Файл:pointer_in_heap.png|400px]]

<source lang="cpp">
void * calloc(size_t nmemb, size_t size);
</source>
Функция работает аналогично <code>malloc</code>, но отличается синтаксисом (вместо размера выделяемой памяти нужно задать количество элементов и размер одного элемента) и тем, что выделенная память будет обнулена. Например, после выполнения
<source lang="cpp">
int * q = (int *) calloc(1000000, sizeof(int))
</source>
<code>q</code> будет указывать на начало массива из миллиона элементов типа <code>int</code> проинициализированных нулями.
<source lang="cpp">
void * realloc(void * ptr, size_t size);
</source>
Функция изменяет размер выделенной памяти (на которую указывает <code>ptr</code>, полученный из вызова <code>malloc</code>, <code>calloc</code> или <code>realloc</code>). Если размер указанный в параметре <code>size</code> больше, чем тот, который был выделен под указатель <code>ptr</code>, то проверяется, есть ли возможность выделить недостающие ячейки памяти подряд с уже выделенными. Если места недостаточно, то выделяется новый участок памяти размером <code>size</code> и данные по указателю <code>ptr</code> копируются в начало нового участка.

=== Какие бывают ошибки ===
1. Потеря памяти
<source lang="cpp">
int * p = (int *) malloc(100);
p = (int *) malloc(200); // потерян указатель на первые 100 <code>int</code>'ов, которые теперь нельзя отдать обратно ОС
</source>
2. Повторное освобождение выделенной памяти
<source lang="cpp">
free(p);
…
free(p); // неопределенное поведение
</source>

Правильно:
<source lang="cpp">
free(p);
p = 0;
…
free(p); // отработает без ошибок
</source>

== Работа с динамической памятью в С++ ==

В С++ есть свой механизм выделения и освобождения памяти — это функции <code>new</code> и <code>delete</code>.

Пример использования <code>new</code>:
<source lang="cpp">
int * p = new int[1000000]; // выделение памяти под 1000000 int`ов
</source>
Т.е. при использовании функции <code>new</code> не нужно приводить указатель и не нужно использовать <code>sizeof()</code>.
Освобождение выделенной при помощи <code>new</code> памяти осуществляется посредством следующего вызова:
<source lang="cpp">
delete [] p;
</source>
Если требуется выделить память под один элемент, то можно использовать
<source lang="cpp">
int * q = new int;
</source>
или
<source lang="cpp">
int * q = new int(10); // выделенный int проинциализируется значением 10
</source>
в этом случае удаление будет выглядеть следующим образом:
<source lang="cpp">
delete q;
</source>
'''Замечание:'''

Выделять динамически небольшие кусочки памяти (например, под один элемент простого типа данных) не целесообразно по двум причинам:
# При динамическом выделении памяти в ней помимо значения указанного типа будет храниться служебная информация ОС и С/С++. Таким образом потребуется гораздо больше памяти, чем при хранении необходимых данных на стеке.
# Если в памяти хранить большое количество маленьких кусочков, то она будет сильно фрагментирована и большой массив данных может не поместиться.

=== Многомерные массивы ===
<code>new</code> позволяет выделять только одномерные массивы, поэтому для работы с многомерными массивами необходимо воспринимать их как массив указателей на другие массивы.
Для примера рассмотрим задачу выделения динамической памяти под массив чисел размера <code>n</code> на <code>m</code>.

'''1ый способ'''

На первом шаге выделяется указатель на массив указателей, а на втором шаге, в цикле каждому указателю из массива выделяется массив чисел в памяти:
<source lang="cpp">
int ** a = new int*[n];
for (int i = 0; i != n; ++i)
a[i] = new int[m];
</source>
Однако, этот способ плох тем, что в нём требуется n+1 выделение памяти, а это достаточно дорогая по времени операция.

'''2ой способ'''

На первом шаге выделение массива указателей и массива чисел размером n на m. На втором шаге каждому указателю из массива ставится в соответствие строка в массиве чисел.
<source lang="cpp">
int ** a = new int*[n];
a[0] = new int[n*m];
for (int i = 1; i != n; ++i)
a[i] = a[0] + i*m;
</source>
В данном случае требуется всего 2 выделения памяти.
Для освобождения памяти потребуется выполнить:

'''1ый способ:'''
<source lang="cpp">
for (int i = 0; i != n; ++i)
delete [] a[i];
delete [] a;
</source>
'''2ой способ:'''
<source lang="cpp">
delete [] a[0];
delete [] a;
</source>
Таким образом, второй способ опять же требует гораздо меньше вызовов функции <code>delete []</code>, чем первый.

Динамическое распределение памяти - История изменений

Alexey.Gurevich: Новая страница: «== Виды памяти == Память, которую использует программа делится на три вида: 1. Статическая п…»