C dynamic memory allocation

Üdvözlöm, Ön a C dynamic memory allocation szó jelentését keresi. A DICTIOUS-ban nem csak a C dynamic memory allocation szó összes szótári jelentését megtalálod, hanem megismerheted az etimológiáját, a jellemzőit és azt is, hogyan kell a C dynamic memory allocation szót egyes és többes számban mondani. Minden, amit a C dynamic memory allocation szóról tudni kell, itt található. A C dynamic memory allocation szó meghatározása segít abban, hogy pontosabban és helyesebben fogalmazz, amikor beszélsz vagy írsz. AC dynamic memory allocation és más szavak definíciójának ismerete gazdagítja a szókincsedet, és több és jobb nyelvi forráshoz juttat.

Angol

Főnév

C dynamic memory allocation (tsz. C dynamic memory allocations)

  1. (informatika) dinamikus memóriafoglalás C nyelven

A dinamikus memóriafoglalás lehetővé teszi, hogy egy program futási időben foglaljon le memóriát.

Miért hasznos?

  • Előre nem tudjuk, mekkora adatot kell tárolni.
  • Rugalmasságot ad → nem kell fix méretű tömböket, struktúrákat használnod.
  • Csak annyi memóriát foglalsz le, amennyire tényleg szükség van.

👉 C nyelvben a dinamikus memória heap területen kerül lefoglalásra.


Alapvető függvények

A C szabványos könyvtárban a stdlib.h tartalmazza a dinamikus memória-kezelő függvényeket:

Függvény Funkció
malloc() Memória lefoglalása
calloc() Lefoglal + nulláz
realloc() Átméretez korábban lefoglalt memóriát
free() Felszabadít lefoglalt memóriát


malloc()

  • Lefoglal egy adott számú byte-ot a heap-en.
  • Nem inicializálja a memóriát → tartalma véletlenszerű.

Szintaxis: 

void* malloc(size_t size);

Használat: 

#include <stdlib.h>

int* arr = (int*) malloc(10 * sizeof(int));
if (arr == NULL) {
    // Hiba történt
}
  • A malloc void pointert ad vissza → típuskényszerítés ((int*)) szükséges.
  • Mindig ellenőrizni kell, hogy malloc nem adott-e vissza NULL-t → ez azt jelenti, hogy nem sikerült a memóriafoglalás.


calloc()

  • Hasonló a malloc-hoz, de:
    • Lefoglalja a memóriát és nullázza azt.
    • Általában tömbök foglalására használják.

Szintaxis: 

void* calloc(size_t num_elements, size_t size_of_element);

Példa: 

int* arr = (int*) calloc(10, sizeof(int));
// Minden elem 0-ra inicializált

realloc()

  • Már lefoglalt memóriaterületet átrendez / átméretez.
  • Ha több hely kell → új helyre másolhatja az adatokat.

Szintaxis: 

void* realloc(void* ptr, size_t new_size);

Példa: 

int* arr = (int*) malloc(5 * sizeof(int));
arr = (int*) realloc(arr, 10 * sizeof(int));
// Most már 10 elemnyi hely van

⚠️ Ha realloc sikertelen → NULL-t ad vissza, az eredeti arr érvényes marad.


free()

  • Felszabadít dinamikusan lefoglalt memóriát.

Szintaxis: 

void free(void* ptr);

Példa: 

free(arr);  // fontos!
arr = NULL; // jó gyakorlat → dangling pointer elkerülése

Nagyon fontos: ha free() után a pointert nem állítod NULL-ra, akkor dangling pointer marad → hibás hozzáférés történhet.


Tipikus minta

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n;
    printf("How many numbers? ");
    scanf("%d", &n);

    int* arr = (int*) malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr = i * i;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr);
    }

    free(arr);  // felszabadítjuk a memóriát
    arr = NULL;

    return 0;
}

Összefoglaló

👉 Statikus memóriafoglalás → int arr; → fordítási időben ismert méret.

👉 Dinamikus memóriafoglalás → malloc, calloc, realloc → futási időben döntjük el a méretet.

👉 Dinamikus memória használata esetén:

  • Soha ne felejtsd el: free()!
  • Ellenőrizd mindig a malloc/calloc visszatérési értékét (NULL).
  • realloc-nál figyelj a hibakezelésre.
  • Ne használj már free()-zett pointert → dangling pointer.


Előnyök

✅ Maximális rugalmasság → futás közben is tudsz memóriát foglalni. ✅ Nagy adatszerkezetek létrehozhatók dinamikusan (pl. linkelt lista, bináris fa, stb.). ✅ Csak annyi memóriát használsz, amennyire szükséged van.


Hátrányok

❌ Bonyolultabb kezelés → kézzel kell felszabadítani. ❌ Hibalehetőség: memory leak, dangling pointer, double free. ❌ Lassabb → heap-hez képest lassabb a hozzáférés, mint a stack-hez.

További információk

Enciclo
Wikious
Sapientia
Scientia
Boobota
Anandapedia
Sagapedia
Wikithot