Dynamická alokace paměti v C pomocí funkcí malloc(), calloc().

Než se naučíte přidělování dynamické paměti C, pochopme:

Jak funguje správa paměti v C?

Když deklarujete proměnnou pomocí základního datového typu, kompilátor C automaticky alokuje paměťový prostor pro proměnnou ve fondu paměti zvaném stoh.

Například proměnná float zabírá při deklaraci obvykle 4 bajty (podle platformy). Tyto informace můžeme ověřit pomocí velikost operátor, jak je znázorněno na níže uvedeném příkladu

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

Výstup bude:

 The size of float is 4 bytes

Také pole se zadanou velikostí je alokováno v souvislých blocích paměti, každý blok má velikost pro jeden prvek:

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

Výsledek je:

 The size of the float array with 10 element is 40

Jak jsme se doposud dozvěděli, při deklaraci základního datového typu nebo pole je paměť automaticky spravována. Existuje však proces pro alokaci paměti v C, který vám umožní implementovat program, ve kterém není velikost pole určena, dokud nespustíte svůj program (runtime). Tento proces se nazývá „Dynamická alokace paměti. "

Nyní můžete bez problémů dynamicky vytvářet a ničit pole prvků za běhu. Abych to shrnul, automatická správa paměti používá zásobník a dynamická alokace paměti C používá haldu.

The knihovna má funkce zodpovědné za dynamickou správu paměti.

funkce	Účel
malloc ()	Přidělí paměť požadované velikosti a vrátí ukazatel na první bajt přidělený prostor.
calloc()	Přiděluje prostor pro prvky pole. Inicializuje prvky na nulu a vrátí ukazatel do paměti.
realloc()	Používá se k úpravě velikosti dříve přiděleného paměťového prostoru.
Volný, uvolnit()	Uvolní nebo vyprázdní dříve přidělený paměťový prostor.

Pojďme si probrat výše uvedené funkce s jejich aplikací

Syntaxe funkce malloc():

ptr = (cast_type *) malloc (byte_size);

Zde,

• ptr je ukazatel cast_type.
• Funkce C malloc() vrací ukazatel na přidělenou paměť velikosti byte_size.

Příklad malloc():

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

Po úspěšném provedení tohoto příkazu je rezervován paměťový prostor o velikosti 50 bajtů. Adresa prvního bajtu rezervovaného prostoru je přiřazena ukazateli ptr typu int.

Zvažte další příklad:

#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));
    }
}

Výstup:

Value of the 6th integer is 480

1. Všimněte si to sizeof(*ptr) byl použit místo sizeof(int) aby byl kód robustnější, když bude deklarace *ptr později přetypována na jiný datový typ.
2. Alokace může selhat, pokud paměť není dostatečná. V tomto případě vrátí ukazatel NULL. Měli byste tedy zahrnout kód pro kontrolu ukazatele NULL.
3. Mějte na paměti, že přidělená paměť je souvislá a lze s ní zacházet jako s polem. Pro přístup k prvkům pole můžeme použít aritmetiku ukazatele namísto použití závorek [ ]. Doporučujeme používat + k odkazování na prvky pole, protože použití inkrementace ++ nebo += změní adresu uloženou v ukazatel.

Funkci Malloc() lze také použít se znakovým datovým typem a také s komplexními datovými typy, jako jsou struktury.

Například:

#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);
}

Výstup:

 Value of the 2nd integer is 50

Syntaxe funkce calloc():

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

• Výše uvedený příkaz se používá k alokaci n paměťových bloků stejné velikosti.
• Po přidělení paměťového prostoru jsou všechny bajty inicializovány na nulu.
• Je vrácen ukazatel, který je aktuálně na prvním bajtu přiděleného paměťového prostoru.

Kdykoli dojde k chybě při přidělování místa v paměti, jako je nedostatek paměti, vrátí se ukazatel null.

Příklad calloc():

Níže uvedený program vypočítá součet aritmetické posloupnosti.

#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;
    }

Výsledek:

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

calloc() vs. malloc(): Klíčové rozdíly

Následuje klíčový rozdíl mezi malloc() versus calloc() v C:

Funkce calloc() je obecně vhodnější a efektivnější než funkce malloc(). Zatímco obě funkce se používají k alokaci paměťového prostoru, calloc() může alokovat více bloků najednou. Nemusíte pokaždé žádat o blok paměti. Funkce calloc() se používá ve složitých datových strukturách, které vyžadují větší paměťový prostor.

Paměťový blok přidělený calloc() v C je vždy inicializován na nulu, zatímco ve funkci malloc() v C vždy obsahuje nesmyslnou hodnotu.

Syntaxe funkce realloc():

ptr = realloc (ptr,newsize);

Výše uvedený příkaz alokuje nový paměťový prostor se zadanou velikostí v proměnné newsize. Po provedení funkce se ukazatel vrátí na první bajt paměťového bloku. Nová velikost může být větší nebo menší než předchozí paměť. Nemůžeme si být jisti, že pokud nově přidělený blok bude ukazovat na stejné místo jako předchozí paměťový blok. Tato funkce zkopíruje všechna předchozí data v nové oblasti. Zajišťuje, že data zůstanou v bezpečí.

Příklad 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;
}

Kdykoli způsobí realloc() v C neúspěšnou operaci, vrátí ukazatel null a předchozí data se také uvolní.

#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);
    }

Výsledek programu C Dynamic array na obrazovce:

 
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

Shrnutí

• Paměť můžeme dynamicky spravovat vytvářením paměťových bloků podle potřeby v haldě
• V dynamické alokaci paměti C je paměť alokována za běhu.
• Dynamická alokace paměti umožňuje manipulovat s řetězci a poli, jejichž velikost je flexibilní a lze ji kdykoli změnit ve vašem programu.
• Je vyžadován, když nemáte ponětí, kolik paměti konkrétní struktura zabere.
• Malloc() v C je dynamická funkce alokace paměti, která znamená alokaci paměti, která blokuje paměť se specifickou velikostí inicializovanou na hodnotu nesmyslu.
• Calloc() v C je souvislá funkce alokace paměti, která alokuje více paměťových bloků v čase inicializovaném na 0
• Realloc() v C se používá k přerozdělení paměti podle zadané velikosti.
• Funkce Free() se používá k vymazání dynamicky alokované paměti.