Динамическое выделение памяти в C с использованием функций malloc(), calloc()

Прежде чем вы изучите выделение динамической памяти C, давайте разберемся:

Как работает управление памятью в C?

Когда вы объявляете переменную, используя базовый тип данных, компилятор C автоматически выделяет пространство памяти для переменной в пуле памяти, называемом стеком. .

Например, переменная с плавающей запятой обычно занимает 4 байта (в зависимости от платформы) при ее объявлении. Мы можем проверить эту информацию, используя sizeof оператор, как показано в примере ниже

#include <stdio.h>
int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

Вывод будет таким:

 The size of float is 4 bytes

Также массив заданного размера размещается в смежных блоках памяти, каждый блок имеет размер одного элемента:

#include <stdio.h>
int main() { float arr[10];
printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}

Результат:

 The size of the float array with 10 element is 40

Как известно, при объявлении базового типа данных или массива память управляется автоматически. Однако существует процесс выделения памяти в C, который позволит вам реализовать программу, в которой размер массива не определен до тех пор, пока вы не запустите свою программу (время выполнения). Этот процесс называется «Динамическое выделение памяти». .”

В этом уроке вы узнаете-

Как работает управление памятью в C?
Динамическое выделение памяти в C
функция malloc() в C
функция free() в C
функция calloc() в C
calloc() и malloc():ключевые отличия
функция realloc() в C
Динамические массивы

Динамическое выделение памяти в C

Динамическое выделение памяти это ручное выделение и освобождение памяти в соответствии с вашими потребностями программирования. Динамическая память управляется и обслуживается с помощью указателей, указывающих на вновь выделенное пространство памяти в области, которую мы называем кучей.

Теперь вы можете без проблем создавать и уничтожать массив элементов динамически во время выполнения. Подводя итог, можно сказать, что автоматическое управление памятью использует стек, а динамическое выделение памяти C использует кучу.

В библиотеке есть функции, отвечающие за динамическое управление памятью.

Функция Цель маллок() Выделяет память запрошенного размера и возвращает указатель на первый байт
выделенного пространства.calloc() Выделяет место для элементов массива. Инициализирует элементы нулем и возвращает указатель на память.realloc() Он используется для изменения размера ранее выделенного пространства памяти.Free() Освобождает или очищает ранее выделенное пространство памяти.

Давайте обсудим вышеперечисленные функции и их применение

функция malloc() в C

Функция C malloc() отвечает за выделение памяти. Это функция, которая используется для динамического выделения блока памяти. Он резервирует пространство памяти указанного размера и возвращает нулевой указатель, указывающий на ячейку памяти. Возвращаемый указатель обычно имеет тип void. Это означает, что мы можем присвоить функцию C malloc() любому указателю.

Синтаксис функции malloc():

ptr = (cast_type *) malloc (byte_size);

Здесь

ptr — это указатель cast_type.
Функция malloc() языка C возвращает указатель на выделенную память размером byte_size.

Пример функции malloc():

Example: ptr = (int *) malloc (50)

При успешном выполнении этого оператора резервируется 50 байт памяти. Адрес первого байта зарезервированного пространства присваивается указателю ptr типа int.

Рассмотрим другой пример:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Вывод:

Value of the 6th integer is 480

Обратите внимание, что sizeof(*ptr) использовался вместо sizeof(int) чтобы сделать код более надежным, когда позже объявление *ptr будет приведено к другому типу данных.
Распределение может завершиться ошибкой, если памяти недостаточно. В этом случае он возвращает указатель NULL. Таким образом, вы должны включить код для проверки указателя NULL.
Имейте в виду, что выделенная память непрерывна и может рассматриваться как массив. Мы можем использовать арифметику указателя для доступа к элементам массива, а не скобки [ ]. Мы советуем использовать + для ссылки на элементы массива, потому что использование приращения ++ или +=изменяет адрес, сохраненный указателем.

Функция malloc() также может использоваться с символьным типом данных, а также со сложными типами данных, такими как структуры.

функция free() в C

Память для переменных автоматически освобождается во время компиляции. При динамическом выделении памяти вы должны явно освобождать память. Если этого не сделать, вы можете столкнуться с ошибкой нехватки памяти.

Бесплатный() Функция вызывается для освобождения/освобождения памяти в C. Освобождая память в вашей программе, вы делаете больше доступной для использования позже.

Например:

#include <stdio.h>
int main() {
int* ptr = malloc(10 * sizeof(*ptr));
if (ptr != NULL){
  *(ptr + 2) = 50;
  printf("Value of the 2nd integer is %d",*(ptr + 2));
}
free(ptr);
}

Вывод

 Value of the 2nd integer is 50

функция calloc() в C

Функция C calloc() означает непрерывное выделение. Эта функция используется для выделения нескольких блоков памяти. Это функция динамического выделения памяти, которая используется для выделения памяти сложным структурам данных, таким как массивы и структуры.

Функция malloc() используется для выделения одного блока памяти, в то время как calloc() в C используется для выделения нескольких блоков памяти. Каждый блок, выделенный функцией calloc(), имеет одинаковый размер.

Синтаксис функции calloc():

ptr = (cast_type *) calloc (n, size);

Приведенный выше оператор используется для выделения n блоков памяти одинакового размера.
После выделения памяти все байты обнуляются.
Возвращается указатель, который в данный момент находится в первом байте выделенного пространства памяти.

Всякий раз, когда возникает ошибка выделения памяти, например нехватка памяти, возвращается нулевой указатель.

Пример calloc():

Программа ниже вычисляет сумму арифметической последовательности.

#include <stdio.h>
    int main() {
        int i, * ptr, sum = 0;
        ptr = calloc(10, sizeof(int));
        if (ptr == NULL) {
            printf("Error! memory not allocated.");
            exit(0);
        }
        printf("Building and calculating the sequence sum of the first 10 terms \ n ");
        for (i = 0; i < 10; ++i) { * (ptr + i) = i;
            sum += * (ptr + i);
        }
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }

Результат:

Building and calculating the sequence sum of the first 10 terms
Sum = 45

calloc() и malloc():ключевые отличия

Ниже приводится ключевое различие между malloc() и calloc() в C:

Функция calloc() обычно более удобна и эффективна, чем функция malloc(). Хотя обе функции используются для выделения памяти, calloc() может выделять несколько блоков одновременно. Вам не нужно каждый раз запрашивать блок памяти. Функция calloc() используется в сложных структурах данных, которые требуют большего объема памяти.

Блок памяти, выделенный calloc() в C, всегда инициализируется нулем, в то время как в функции malloc() в C он всегда содержит мусорное значение.

функция realloc() в C

Использование C realloc() функция, вы можете добавить больше памяти к уже выделенной памяти. Он расширяет текущий блок, оставляя исходное содержимое без изменений. realloc() в C означает перераспределение памяти.

realloc() также можно использовать для уменьшения размера ранее выделенной памяти.

Синтаксис функции realloc():

ptr = realloc (ptr,newsize);

Приведенный выше оператор выделяет новое пространство памяти с указанным размером в переменной newsize. После выполнения функции указатель будет возвращен на первый байт блока памяти. Новый размер может быть больше или меньше предыдущего объема памяти. Мы не можем быть уверены, что новый выделенный блок будет указывать на то же место, что и предыдущий блок памяти. Эта функция скопирует все предыдущие данные в новый регион. Это гарантирует, что данные останутся в безопасности.

Пример функции realloc():

#include <stdio.h>
int main () {
   char *ptr;
   ptr = (char *) malloc(10);
   strcpy(ptr, "Programming");
   printf(" %s,  Address = %u\n", ptr, ptr);

   ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size
   strcat(ptr, " In 'C'");
   printf(" %s,  Address = %u\n", ptr, ptr);
   free(ptr);
   return 0;
}

Всякий раз, когда realloc() в C приводит к неудачной операции, она возвращает нулевой указатель, а предыдущие данные также освобождаются.

Динамические массивы в C

Динамический массив в C позволяет увеличивать количество элементов по мере необходимости. C Динамический массив широко используется в алгоритмах информатики.

В следующей программе мы создали и изменили размер динамического массива в C

#include <stdio.h>
    int main() {
        int * arr_dynamic = NULL;
        int elements = 2, i;
        arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks
        for (i = 0; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        elements = 4;
        arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements
        printf("After realloc\n");
        for (i = 2; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        free(arr_dynamic);
    }

Результат программы C Dynamic array на экране:

 
arr_dynamic[0]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_dynamic[3]=3

Обзор

Мы можем динамически управлять памятью, создавая блоки памяти в куче по мере необходимости.
В динамическом распределении памяти C память выделяется во время выполнения.
Динамическое выделение памяти позволяет манипулировать строками и массивами, размер которых является гибким и может быть изменен в любое время в вашей программе.
Это требуется, когда вы не представляете, сколько памяти будет занимать конкретная структура.
Malloc() в C – это функция динамического выделения памяти, которая обозначает выделение памяти, когда блоки памяти определенного размера инициализируются значением мусора
Calloc() в языке C — это функция непрерывного выделения памяти, которая одновременно выделяет несколько блоков памяти, инициализированных значением 0.
Realloc() в C используется для перераспределения памяти в соответствии с указанным размером.
Функция Free() используется для очистки динамически выделенной памяти.

Побитовые операторы в C:AND, OR, XOR, Shift и дополнение Приведение типов в C:преобразование типов, неявное, явное с примером

Язык C