Dinamikus memória kezelés

Eddigi programjaink során csak statikus módon kezeltünk memóriát, de mint tudjuk, előre nem tudjuk megjósolni minden esetben, hogy mennyi memória kell majd egy művelet elvégzéséhez. Éppen ezért a C is kínál lehetőséget dinamikus memória allokációra. Azonban erre nyelvi eleme nincs, mint mondjuk C++ vag C# esetén a new operátor. Helyette a C ezt is függvényekkel valósítja meg.

A dinamikus memóriakezeléshez két fontos függvényünk van: A malloc, amivel memóriát allokálunk és a free, amivel pedig felszabadítunk. A malloc visszatérési értéke a lefoglalt memória mutatója void * pointerként. A void * mutató a C univerzális típusa, mivel ez bármi lehet. Ezért foglalás után mindig konvertálnunk kell a megfelelő típusra. A malloc eredménye lehet NULL, ha nem sikerült a memóriafoglalás.

Ha végeztünk a memória használatával, akkor a free függvényhívással nekünk kell magunknak felszabadítani a foglalt memóriát, mivel nincs szemétgyűjtő.

Az alábbi program a malloc és a free használatát mutatja be:

#include <stdio.h>
//malloc és free miatt
#include <stdlib.h>

int main()
{
    printf("2 hatvanyai program\r\n");
    size_t mennyit = 0;

    /*ellenőrzött bevitel*/
    do 
    {
        printf("Meddig szamoljunk [1-16]: ");
        scanf("%llu", &mennyit);
        if (mennyit < 1 || mennyit > 16)
            printf("Hibás bevitel. ");
    }
    while (mennyit > 16 || mennyit < 1);
    
    /*memóriafoglalás*/
    int *hatvanyok = (int*)malloc(mennyit * sizeof(int));
    if (hatvanyok == NULL)
    {
        /*ha nem volt sikeres, akkor kilépünk*/
        printf("Memoriafoglalas sikertelen\r\n");
        return 1;
    }
    
    int szam = 1;
    for (size_t i=0; i<mennyit; i++)
    {
        hatvanyok[i] = szam;
        szam *= 2;
    }

    for (size_t i = 0; i < mennyit; i++)
    {
        printf("hatvanyok[%lld] = %d\r\n", i, hatvanyok[i]);
    }

    /*foglalt memória felszabadítása*/
    free(hatvanyok);
    return 0;

}

A program egy lehetséges kimenete:

2 hatvanyai program
Meddig szamoljunk [1-16]: 4
hatvanyok[0] = 1
hatvanyok[1] = 2
hatvanyok[2] = 4
hatvanyok[3] = 8