Очень часто возникают задачи обработки массивов данных, размерность которых заранее неизвестна. В этом случае возможно использование одного из двух подходов:
Для использования функций динамического выделения памяти необходимо описать указатель , представляющий собой начальный адрес хранения элементов массива.
int
*p; // указатель на тип int
Начальный адрес статического массива определяется компилятором в момент его объявления и не может быть изменен.
Для динамического массива начальный адрес присваивается объявленному указателю на массив в процессе выполнения программы.
Функции динамического выделения памяти находят в оперативной памяти непрерывный участок требуемой длины и возвращают начальный адрес этого участка.
Функции динамического распределения памяти:
void
* malloc(РазмерМассиваВБайтах);
void
* calloc(ЧислоЭлементов, РазмерЭлементаВБайтах);
Для использования функций динамического распределения памяти необходимо подключение библиотеки
#include
Поскольку обе представленные функции в качестве возвращаемого значения имеют указатель на пустой тип void , требуется явное приведение типа возвращаемого значения.
Для определения размера массива в байтах, используемого в качестве аргумента функции malloc()
требуется количество элементов умножить на размер одного элемента. Поскольку элементами массива могут быть как данные простых типов, так и составных типов (например, структуры), для точного определения размера элемента в общем случае рекомендуется использование функции
int
sizeof
(тип);
Память, динамически выделенная с использованием функций calloc(), malloc()
, может быть освобождена с использованием функции
free(указатель);
«Правилом хорошего тона» в программировании является освобождение динамически выделенной памяти в случае отсутствия ее дальнейшего использования. Однако если динамически выделенная память не освобождается явным образом, она будет освобождена по завершении выполнения программы.
Форма обращения к элементам массива с помощью указателей имеет следующий вид:
int
a, *p; // описываем статический массив и указатель
int
b;
p = a; // присваиваем указателю начальный адрес массива
... // ввод элементов массива
b = *p; // b = a;
b = *(p+i) // b = a[i];
Пример на Си
: Организация динамического одномерного массива и ввод его элементов.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include
#include
#include
int
main()
{
int
*a; // указатель на массив
int
i, n;
system("chcp 1251"
);
system("cls"
);
printf("Введите размер массива: "
);
scanf("%d"
, &n);
// Выделение памяти
a = (int
*)malloc(n * sizeof
(int
));
// Ввод элементов массива
for
(i = 0; i
printf("a[%d] = "
, i);
scanf("%d"
, &a[i]);
}
// Вывод элементов массива
for
(i = 0; i
free(a);
getchar(); getchar();
return
0;
}
Пусть требуется разместить в динамической памяти матрицу, содержащую n строк и m столбцов. Двумерная матрица будет располагаться в оперативной памяти в форме ленты, состоящей из элементов строк. При этом индекс любого элемента двумерной матрицы можно получить по формуле
index = i*m+j;
где i - номер текущей строки; j - номер текущего столбца.
Рассмотрим матрицу 3x4 (см. рис.)
Индекс выделенного элемента определится как
index = 1*4+2=6
Объем памяти, требуемый для размещения двумерного массива, определится как
n·m·(размер элемента)
Однако поскольку при таком объявлении компилятору явно не указывается количество элементов в строке и столбце двумерного массива, традиционное обращение к элементу путем указания индекса строки и индекса столбца является некорректным:
a[i][j] - некорректно.
Правильное обращение к элементу с использованием указателя будет выглядеть как
*(p+i*m+j)
,
где
Пример на Си
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#define
_CRT_SECURE_NO_WARNINGS
#include
#include
#include
int
main()
{
int
*a; // указатель на массив
int
i, j, n, m;
system("chcp 1251"
);
system("cls"
);
printf("Введите количество строк: "
);
scanf("%d"
, &n);
printf();
scanf("%d"
, &m);
// Выделение памяти
a = (int
*)malloc(n*m * sizeof
(int
));
// Ввод элементов массива
for
(i = 0; i
{
for
(j = 0; j
{
scanf("%d"
, (a + i*m + j));
}
}
// Вывод элементов массива
for
(i = 0; i
{
for
(j = 0; j
{
printf("%5d "
, *(a + i*m + j));
}
printf("\n"
);
}
free(a);
getchar(); getchar();
return
0;
}
Результат выполнения
Возможен также другой способ динамического выделения памяти под двумерный массив - с использованием массива указателей. Для этого необходимо:
Графически такой способ выделения памяти можно представить следующим образом.
При таком способе выделения памяти компилятору явно указано количество строк и количество столбцов в массиве.
Пример на Си
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#define
_CRT_SECURE_NO_WARNINGS
#include
#include
#include
int
main()
{
int
**a; // указатель на указатель на строку элементов
int
i, j, n, m;
system("chcp 1251"
);
system("cls"
);
printf("Введите количество строк: "
);
scanf("%d"
, &n);
printf("Введите количество столбцов: "
);
scanf("%d"
, &m);
// Выделение памяти под указатели на строки
// Ввод элементов массива
for
(i = 0; i
{
// Выделение памяти под хранение строк
a[i] = (int
*)malloc(m * sizeof
(int
));
for
(j = 0; j
{
printf("a[%d][%d] = "
, i, j);
scanf("%d"
, &a[i][j]);
}
}
// Вывод элементов массива
for
(i = 0; i < n; i++) // цикл по строкам
{
for
(j = 0; j < m; j++) // цикл по столбцам
{
printf("%5d "
, a[i][j]); // 5 знакомест под элемент массива
}
printf("\n"
);
}
// Очистка памяти
for
(i = 0; i < n; i++) // цикл по строкам
free(a[i]); // освобождение памяти под строку
free(a);
getchar(); getchar();
return
0;
}
Результат выполнения программы аналогичен предыдущему случаю.
С помощью динамического выделения памяти под указатели строк можно размещать свободные массивы. Свободным называется двухмерный массив (матрица), размер строк которого может быть различным. Преимущество использования свободного массива заключается в том, что не требуется отводить память компьютера с запасом для размещения строки максимально возможной длины. Фактически свободный массив представляет собой одномерный массив указателей на одномерные массивы данных.
Для размещения в оперативной памяти матрицы со строками разной длины необходимо ввести дополнительный массив m , в котором будут храниться размеры строк.
Пример на Си
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#define
_CRT_SECURE_NO_WARNINGS
#include
#include
int
main()
{
int
**a;
int
i, j, n, *m;
system("chcp 1251"
);
system("cls"
);
printf("Введите количество строк: "
);
scanf("%d"
, &n);
a = (int
**)malloc(n * sizeof
(int
*));
m = (int
*)malloc(n * sizeof
(int
)); // массив кол-ва элеменов в строках массива a
// Ввод элементов массива
for
(i = 0; i
printf("Введите количество столбцов строки %d: "
, i);
scanf("%d"
, &m[i]);
a[i] = (int
*)malloc(m[i] * sizeof
(int
));
for
(j = 0; j
scanf("%d"
, &a[i][j]);
}
}
// Вывод элементов массива
for
(i = 0; i
for
(j = 0; j
printf("%3d "
, a[i][j]);
}
printf("\n"
);
}
// Освобождение памяти
for
(i = 0; i < n; i++)
{
free(a[i]);
}
free(a);
free(m);
getchar(); getchar();
return
0;
}
Если размер выделяемой памяти нельзя задать заранее, например при вводе последовательности значений до определенной команды, то для увеличения размера массива при вводе следующего значения необходимо выполнить следующие действия:
Все перечисленные выше действия (кроме последнего) выполняет функция
void
* realloc (void
* ptr, size_t size);
Размер блока памяти, на который ссылается параметр ptr
изменяется на size
байтов. Блок памяти может уменьшаться или увеличиваться в размере. Содержимое блока памяти сохраняется даже если новый блок имеет меньший размер, чем старый. Но отбрасываются те данные, которые выходят за рамки нового блока. Если новый блок памяти больше старого, то содержимое вновь выделенной памяти будет неопределенным.
if
(i>2) i -= 2;
printf("\n"
);
a = (int
*)realloc(a, i * sizeof
(int
)); // уменьшение размера массива на 2
for
(int
j = 0; j < i; j++)
printf("%d "
, a[j]);
getchar(); getchar();
return
0;
}
Существует два типа статических переменных:
extern int maxind;
это описание сообщает о наличии такой переменной, но не создает эту переменную!int maxind = 1000;
это описание создает переменную maxind и присваивает ей начальное значение 1000 . Заметим, что стандарт языка не требует обязательного присвоения начальных значений глобальным переменным, но, тем не менее, это лучше делать всегда, иначе в переменной будет содержаться непредсказуемое значение (мусор, как говорят программисты). Инициализация всех глобальных переменных при их определении - это правило хорошего стиля.static int gcd(int x, int y); // Прототип ф-ции. . . static int gcd(int x, int y) { // Реализация. . . }
Совет: используйте модификатор static в заголовке функции, если известно, что функция будет вызываться лишь внутри одного файла. Слово static должно присутствовать как в описании прототипа функции, так и в заголовке функции при ее реализации.Локальные, или стековые, переменные - это переменные, описанные внутри функции . Память для таких переменных выделяется в аппаратном стеке, см. раздел 2.3.2. Память выделяется в момент входа в функцию или блок и освобождается в момент выхода из функции или блока. При этом захват и освобождение памяти происходят практически мгновенно, т.к. компьютер только изменяет регистр, содержащий адрес вершины стека.
Локальные переменные можно использовать при рекурсии, поскольку при повторном входе в функцию в стеке создается новый набор локальных переменных, а предыдущий набор не разрушается. По этой же причине локальные переменные безопасны при использовании нитей в параллельном программировании (см. раздел 2.6.2). Программисты называют такое свойство функции реентерабельностью , от англ. re-enter able - возможность повторного входа. Это очень важное качество с точки зрения надежности и безопасности программы! Программа, работающая со статическими переменными, этим свойством не обладает, поэтому для защиты статических переменных приходится использовать механизмы синхронизации (см. 2.6.2), а логика программы резко усложняется. Всегда следует избегать использования глобальных и статических переменных, если можно обойтись локальными.
Недостатки локальных переменных являются продолжением их достоинств. Локальные переменные создаются при входе в функцию и исчезают после выхода из нее, поэтому их нельзя использовать в качестве данных, разделяемых между несколькими функциями. К тому же, размер аппаратного стека не бесконечен, стек может в один прекрасный момент переполниться (например, при глубокой рекурсии), что приведет к катастрофическому завершению программы. Поэтому локальные переменные не должны иметь большого размера. В частности, нельзя использовать большие массивы в качестве локальных переменных.
Помимо статической и стековой памяти, существует еще практически неограниченный ресурс памяти, которая называется динамическая , или куча (heap ). Программа может захватывать участки динамической памяти нужного размера. После использования ранее захваченный участок динамической памяти следует освободить.
Под динамическую память отводится пространство виртуальной памяти процесса между статической памятью и стеком. (Механизм виртуальной памяти был рассмотрен в разделе 2.6.) Обычно стек располагается в старших адресах виртуальной памяти и растет в сторону уменьшения адресов (см. раздел 2.3). Программа и константные данные размещаются в младших адресах, выше располагаются статические переменные. Пространство выше статических переменных и ниже стека занимает динамическая память:
| адрес | содержимое памяти |
|---|---|
|
код программы и данные, защищенные от изменения |
|
| ... |
статические переменные программы |
| динамическая память | |
|
max. адрес (2 32 -4) |
стек |
Структура динамической памяти автоматически поддерживается исполняющей системой языка Си или C++ . Динамическая память состоит из захваченных и свободных сегментов, каждому из которых предшествует описатель сегмента. При выполнении запроса на захват памяти исполняющая система производит поиск свободного сегмента достаточного размера и захватывает в нем отрезок требуемой длины. При освобождении сегмента памяти он помечается как свободный, при необходимости несколько подряд идущих свободных сегментов объединяются.
В языке Си для захвата и освобождения динамической памяти применяются стандартные функции malloc и free , описания их прототипов содержатся в стандартном заголовочном файле " stdlib.h ". (Имя malloc является сокращением от memory allocate - "захват памяти".) Прототипы этих функций выглядят следующим образом:
void *malloc(size_t n); // Захватить участок памяти // размером в n байт void free(void *p); // Освободить участок // памяти с адресом p
Здесь n - это размер захватываемого участка в байтах, size_t - имя одного из целочисленных типов, определяющих максимальный размер захватываемого участка. Тип size_t задается в стандартном заголовочном файле " stdlib.h " с помощью оператора typedef (см. c. 117). Это обеспечивает независимость текста Си-программы от используемой архитектуры. В 32-разрядной архитектуре тип size_t определяется как беззнаковое целое число:
typedef unsigned int size_t;
Функция malloc возвращает адрес захваченного участка памяти или ноль в случае неудачи (когда нет свободного участка достаточно большого размера). Функция free освобождает участок памяти с заданным адресом. Для задания адреса используется указатель общего типа void* . После вызова функции malloc его необходимо привести к указателю на конкретный тип, используя операцию приведения типа, см. раздел 3.4.11. Например, в следующем примере захватывается участок динамической памяти размером в 4000 байтов, его адрес присваивается указателю на массив из 1000 целых чисел:
int *a; // Указатель на массив целых чисел. . . a = (int *) malloc(1000 * sizeof(int));
Выражение в аргументе функции malloc равно 4000 , поскольку размер целого числа sizeof(int) равен четырем байтам. Для преобразования указателя используется операция приведения типа (int *) от указателя обобщенного типа к указателю на целое число.
Рассмотрим пример, использующий захват динамической памяти. Требуется ввести целое цисло n и напечатать n первых простых чисел. (Простое число - это число, у которого нет нетривиальных делителей.) Используем следующий алгоритм: последовательно проверяем все нечетные числа, начиная с тройки (двойку рассматриваем отдельно). Делим очередное число на все простые числа, найденные на предыдущих шагах алгоритма и не превосходящие квадратного корня из проверяемого числа. Если оно не делится ни на одно из этих простых чисел, то само является простым; оно печатается и добавляется в массив найденных простых.
Поскольку требуемое количество простых чисел n до начала работы программы неизвестно, невозможно создать массив для их хранения в статической памяти. Выход состоит в том, чтобы захватывать пространство под массив в динамической памяти уже после ввода числа n . Вот полный текст программы:
#include
Пример работы данной программы:
Введите число простых: 50 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229
В языке C++ для захвата и освобождения динамической памяти используются операторы new и delete . Они являются частью языка C++ , в отличие от функций malloc и free , входящих в библиотеку стандартных функций Си.
Пусть T - некоторый тип языка Си или C++ , p - указатель на объект типа T . Тогда для захвата памяти размером в один элемент типа T используется оператор new :
T *p; p = new T;
Например, для захвата восьми байтов под вещественное число типа double используется фрагмент
double *p; p = new double;
При использовании new , в отличие от malloc , не нужно приводить указатель от типа void* к нужному типу: оператор new возвращает указатель на тип, записанный после слова new . Сравните два эквивалентных фрагмента на Си и C++ .
Для работы с массивами информации, программы должны выделять память для этих массивов. Для выделения памяти под массивы переменных используются соответствующие операторы, функции и т.п.. В языке программирования C++ выделяют следующие способы выделения памяти:
1. Статическое (фиксированное ) выделение памяти. В этом случае память выделяется только один раз во время компиляции. Размер выделенной памяти есть фиксированным и неизменным до конца выполнения программы. Примером такого выделения может служить объявление массива из 10 целых чисел:
int M; // память для массива выделяется один раз, размер памяти фиксированный2. Динамическое выделение памяти. В этом случае используется комбинация операторов new и delete . Оператор new выделяет память для переменной (массива) в специальной области памяти, которая называется «куча» (heap). Оператор delete освобождает выделенную память. Каждому оператору new должен соответствовать свой оператор delete .
Динамическое выделение памяти по сравнению со статическим выделением памяти дает следующие преимущества:
Преимущества статического способа выделения памяти:
В зависимости от поставленной задачи, программист должен уметь правильно определить, какой способ выделения памяти подходит для той или другой переменной (массива).
Общая форма выделения памяти для одиночной переменной оператором new имеет следующий вид:
ptrName = new type;Если память для переменной выделена оператором new, то после завершения использования переменной, эту память нужно освободить оператором delete . В языке C++ это есть обязательным условием. Если не освободить память, то память останется выделенной (занятой), но использовать ее не сможет ни одна программа. В данном случае произойдет «утечка памяти» (memory leak).
В языках программирования Java, C# освобождать память после выделения не нужно. Этим занимается «сборщик мусора» (garbage collector ).
Общая форма оператора delete для одиночной переменной:
delete ptrName;где ptrName – имя указателя, для которого была раньше выделена память оператором new . После выполнения оператора delete указатель ptrName указывает на произвольный участок памяти, который не является зарезервированным (выделенным).
В примерах демонстрируется использование операторов new и delete . Примеры имеют упрощенный вид.
Пример 1. Указатель на тип int . Простейший пример
// выделение памяти оператором new int * p; // указатель на int p = new int ; // выделить память для указателя *p = 25; // записать значения в память // использование памяти, выделенной для указателя int d; d = *p; // d = 25 // освободить память, выделенную для указателя - обязательно delete p;Пример 2. Указатель на тип double
// выделение памяти для указателя на double double * pd = NULL ; pd = new double ; // выделить память if (pd!=NULL ) { *pd = 10.89; // записать значения double d = *pd; // d = 10.89 - использование в программе // освободить память delete pd; }«Утечка памяти » – это когда память для переменной выделяется оператором new , а по окончании работы программы она не освобождается оператором delete . В этом случае память в системе остается занятой, хотя потребности в ее использовании уже нет, поскольку программа, которая ее использовала, уже давно завершила свою работу.
«Утечка памяти» есть типичной ошибкой программиста. Если «утечка памяти» повторяется многократно, то возможная ситуация, когда будет «занята» вся доступная память в компьютере. Это приведет к непредсказуемым последствиям работы операционной системы.
При использовании оператора new возможна ситуация, когда память не выделится. Память может не выделиться в следующих ситуациях:
В этом случае генерируется исключительная ситуация bad_alloc . Программа может перехватить эту ситуацию и соответствующим образом обработать ее.
Пример. В примере учитывается ситуация, когда память может не выделиться оператором new . В таком случае осуществляется попытка выделить память. Если попытка удачная, то работа программы продолжается. Если попытка завершилась неудачей, то происходит выход из функции с кодом -1.
int main() { // объявить массив указателей на float float * ptrArray; try { // попробовать выделить память для 10 элементов типа float ptrArray = new float ; } catch (bad_alloc ba) { cout << << endl; cout << ba.what() << endl; return -1; // выход из функции } // если все в порядке, то использовать массив for (int i = 0; i < 10; i++) ptrArray[i] = i * i + 3; int d = ptrArray; cout << d << endl; delete ptrArray; // освободить память, выделенную под массив return 0; }Оператор выделения памяти new для одиночной переменной допускает одновременную инициализацию значением этой переменной.
В общем, выделение памяти для переменной с одновременной инициализацией имеет вид
ptrName = new type(value )Пример. Выделение памяти для переменных с одновременной инициализацией. Ниже приводится функция main() для консольного приложения. Продемонстрировано выделение памяти с одновременной инициализацией. Также учитывается ситуация, когда попытка выделить память завершается неудачей (критическая ситуация bad_alloc ).
#include "stdafx.h" #includeИтак. третий тип, самый интересный в этой теме для нас – динамический тип памяти.
Как мы работали с массивами раньше? 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 , но выделенная память выравнивается по границе страницы.
Динамическое выделение памяти
Основные проблемы применения
Нулевой указатель
Нулевой указатель − это указатель, хранящий специальное значение, используемое для того, чтобы показать, что данная переменная-указатель не ссылается (не указывает) ни на какой объект. В различных языках программирования представлен различными константами.
·В языках C# и Java: null
·В языках Си и C++: 0 или макрос NULL. Кроме того, в стандарте C++11 для обозначения нулевого указателя предложено новое ключевое слово nullptr
·В языках Паскаль и Ruby: nil
·В языке Компонентный Паскаль:NIL
·В языке Python: None
Указателями сложно управлять. Достаточно легко записать в указатель неправильное значение, что может вызвать трудно воспроизводимую ошибку. Например, вы случайно поменяли адрес указателя в памяти, или неправильно выделили под информацию память и тут вас может ожидать сюрприз: другая очень важная переменная, которая используется только внутри программы будет перезаписана. В таком случае вам будет сложно воспроизвести баг. Нелегко будет и понять, где именно находится ошибка. И не всегда тривиально будет её устранить (иногда придётся переписать существенную часть программы).
Для решения части проблем есть методы предохранения и страховки:
Изучив указатели в языке Си, мы открыли для себя возможности динамического выделения памяти. Что это значит? Это значит то, что при динамическом выделении памяти, память резервируется не на этапе компиляции а на этапе выполнения программы. И это дает нам возможность выделять память более эффективно, в основном это касается массивов. С динамическим выделением память, нам нет необходимости заранее задавать размер массива, тем более, что не всегда известно, какой размер должен быть у массива. Далее рассмотрим каким же образом можно выделять память.
Функция malloc() определена в заголовочном файле stdlib.h, она используется для инициализации указателей необходимым объемом памяти. Память выделяется из сектора оперативной памяти доступного для любых программ, выполняемых на данной машине. Аргументом функции malloc() является количество байт памяти, которую необходимо выделить, возвращает функция - указатель на выделенный блок в памяти. Функция malloc() работает также как и любая другая функция, ничего нового.
Так как различные типы данных имеют разные требования к памяти, мы как-то должны научиться получить размер в байтах для данных разного типа. Например, нам нужен участок памяти под массив значений типа int - это один размер памяти, а если нам нужно выделить память под массив того же размера, но уже типа char - это другой размер. Поэтому нужно как-то вычислять размер памяти. Это может быть сделано с помощью операции sizeof(), которая принимает выражение и возвращает его размер. Например, sizeof(int) вернет количество байтов, необходимых для хранения значения типа int. Рассмотрим пример:
Яндекс.Директ
| #include |
В этом примере, встроке 3 указателю ptrVar присваивается адрес на участок памяти, размер которого соответствует типу данных int. Автоматически, этот участок памяти становится недоступным для других программ. А это значит, что после того, как выделенная память станет ненужной, её нужно явно высвободить. Если же память не будет явно высвобождена, то по завершению работы программы, память так и не освободится для операционной системы, это называется утечкой памяти. Также можно определять размер выделяемой памяти, которую нужно выделить передавая пустой указатель, вот пример:
Как видите, в такой записи есть одна очень сильная сторона, мы не должны вызывать функцию malloc() с использованиемsizeof(float). Вместо этого мы передали в malloc() указатель на тип float, в таком случае, размер выделяемой памяти автоматически определится сам!
Особенно это пригодится, если выделять память потребуется далеко от определения указателя:
| float *ptrVar; /* . . . сто строк кода */ . . . ptrVar = malloc(sizeof(*ptrVar)); |
Если бы вы использовали конструкцию выделения памяти с операцией sizeof(), то вам бы пришлось находить в коде определение указателя, смотреть его тип данных и уже потом вы бы смогли правильно выделить память.
