4.7. Динамическое распределение памяти
Для динамического распределения памяти применяются функции malloc() и free(). Их прототипы находятся в файле <stdlib.h>.
Прототип функции malloc():
void *malloc(unsigned s);
Функция возвращает указатель типа void на блок выделенной памяти длиной s байт. Если необходимого количества памяти нет в наличии – возвращает NULL.
Например:
char *p;
p = (char *) malloc(1000); // выделяет 1000 байт
Функция free() освобождает память, то есть память возвращается системе и в дальнейшем её можно выделить снова. Для высвобождения памяти, динамически выделенной ранее, используется функция free(). Её прототип:
void free(void *p);
То есть, чтобы освободить память, выделенную в предыдущем примере, нужно написать
free(p);
При динамическом распределении памяти для массивов следует описать указатель соответствующего типа и присвоить ему значение при помощи функции calloc. Вот прототип этой функции:
void *calloc(unsigned n, unsigned m);
Функция принимает два аргумента: число элементов n и размер каждого элемента m, инициализирует выделенный блок памяти нулями и возвращает указатель на его начало Если по каким-либо причинам (например, в случае нехватки физической памяти) память не может быть выделена, возвращается NULL.
Одномерный массив a[10] из элементов типа float можно создать следующим образом
float *a;
a = (float *) calloc(10,sizeof(float));
Для динамического создания двумерного массива вначале нужно распределить память для массива указателей на одномерные массивы, а затем распределять память для одномерных массивов. Пусть, например, требуется создать массив a[m][n]. Это можно сделать при помощи следующего фрагмента программы:
#include <stdlib.h>
void main()
{
double **a;
int n,m,i;
scanf("%d %d",&m,&n);
a = (double **) calloc(m,sizeof(double *));
for (i = 0; i < m; i++)
a[i] = (double *) calloc(n, sizeof (double));
}
Функция realloc изменяет размер объекта, выделенного в результате предыдущего вызова malloc, calloc или realloc. Содержимое первоначального объекта сохраняется при условии, что размер вновь выделяемой памяти больше, чем первоначальный. В противном случае содержимое остается неизменным лишь в пределах размера нового объекта. Прототип функции realloc выглядит следующим образом:
void *realloc(void *ptr, unsigned size);
Функция realloc принимает два аргумета: указатель на первоначальный объект (ptr) и новый размер объекта (size). Если ptr равен NULL, realloc работает аналогично malloc. Если size равен 0, а ptr не NULL, память, выделенная для объекта, освобождается. В противном случае, если ptr не NULL и размер больше нуля, realloc пытается выделить для объекта новый блок памяти. Функция realloc возвращает либо указатель на вновь выделенную память, либо NULL.
4.8. Массивы указателей
Массивы могут состоять из указателей. Обычный случай такого массива – это массив строк. Элементом такого массива является строка. В качестве примера рассмотрим массив name, который может быть использован для хранения имен.
char *name[4] = {“Nata”,”Lena”,”Masha”,”Katya”};
Выражение name[4] в объявлении означает массив из четырех элементов. Элементами данного массива будут являться указатели на тип char. Каждый указатель инициализируется адресом строки, указанной в фигурных скобках.
Каждое из значений переменной-указателя (“Nata”,”Lena” и т.д.) хранится в памяти как строка символов с конечным нулевым символом.
В name[0] содержится адрес “Nata”.
Для хранения тех же данных мы могли использовать двумерный массив. При таком подходе все строки должны быть одинаковой длины, равной размеру самой длинной строки символов. Это привело бы к неоправданному расходу памяти в случае, когда большинство сохраняемых строк короче, чем самая длинная строка. Также преимущество массива указателей состоит в том, что можно работать не с самими строками, а с их адресами, что дает выигрыш во времени.
Следующие объявления переменных
int a[] = {10,11,12,13,14,}; // массив целых чисел
int *p[] = {a, a+1, a+2, a+2, a+3, a+4}; // массив указателей
// на целые числа
int **pp = p; //указатель на указатель
порождают программные объекты, представленные на схеме рис.4.5.
Рис.4.5. Схема размещения переменных при объявлении
При выполнении операции pp-p получим нулевое значение, так как ссылки pp и p равны и указывают на начальный элемент массива указателей, связанного с указателем p (на элемент p[0]).
После выполнения операции pp+=2 схема изменится и примет вид, изображенный на рис.4.6.
Рис.4.6. Схема размещения переменных после выполнения операции pp+=2
Результатом выполнения вычитания pp-p будет 2, так как значение pp есть адрес третьего элемента массива p. Ссылка *pp-a тоже дает значение 2, так как обращение *pp есть адрес третьего элемента массива a, а обращение a есть адрес начального элемента массива a. При обращении с помощью ссылки **pp получим 12 - это значение третьего элемента массива a. Ссылка *pp++ даст значение четвертого элемента массива p т.е. адрес четвертого элемента массива a.
Если считать, что pp=p, то обращение *++pp это значение второго элемента массива a (т.е. значение 11), операция ++*pp изменит содержимое указателя p[0], таким образом, что он станет равным значению адреса элемента a[1].
Сложные обращения раскрываются изнутри. Например, обращение *(++(*pp)) можно разбить на следующие действия: *pp дает значение начального элемента массива p[0], далее это значение инкременируется ++(*p), в результате чего указатель p[0] станет равен значению адреса элемента a[1], и последнее действие это выборка значения по полученному адресу, т.е. значение 11.
Объявление переменных
int a[3][3] = { { 11,12,13 },
{ 21,22,23 },
{ 31,32,33 } };
int *pa[3] = { a, a[1], a[2] };
int *p = a[0];
порождает в программе объекты, представленные на схеме рис.4.7.
Рис.4.7. Схема размещения указателей на двумерный массив
Согласно этой схеме доступ к элементу a[0][0] можно получить по указателям a, path, pa при помощи следующих ссылок: a[0][0], *a, **a[0], *p, **pa, *p[0].