Dinamikus memóriakezelés

Mutatók létrehozása, cím képzése, indirekció

void novel(int *pi) {
    *pi += 1;
}

int main(void) {
    int i = 2;
    novel(&i);
}

Tömb elejére (vagy belsejébe) mutató pointerek

int tomb[4], *pi;

pi = tomb; // &tomb[0]

pi[2] = 4;

tomb[1] = 2;

void tomb_kiir(int *tomb, int meret) {
    for (int i = 0; i < meret; ++i)
        printf("%d ", tomb[i]);
}

int tomb[10];
tomb_kiir(tomb, 10);

void fuggveny(int *t);

void fuggveny(int t[]);

/* a világ utolsó C bugja */
while (true) {
   status = GetRadarInfo();
   if (status = true)
      LaunchMissiles();
}

Nem változtatjuk a cím szerint átadott változót?

void kiir(int const *tomb, int meret) {  // int const
    ...
}

int tomb[100] = { ... };
kiir(tomb, 100);

Nem akarjuk lemásolni a nagy struktúrát, de változtatni se szeretnénk?

Előfordulhat, hogy egy nagy struktúrát cím szerint adunk át egy függvénynek – nem azért, hogy meg tudjuk változtatni, hanem csak mert nem szeretnénk feleslegesen lemásolni, mert az nagyon lassítaná a programunkat.

struct Rajz { ... };
void megjelenit(Rajz const *r) {  // Rajz const
    ...
}

Rajz r;
megjelenit(&r);

Itt hasonló a helyzet, mint az előző esetben. Ha a függvény belsejében esetleg r->szelesseg = 3;-at írnánk, vagy hasonlót, akkor a fordító jelezni fogja a hibát: a megjelenit() függvény azt ígérte, nem fogja a rajzot megváltoztatni, ennek ellenére módosítani próbálja.

A karbantarthatóság egyik alapfeltétele: az olvashatóság.

for (y = 0; y < 480; ++y)
    for (x = 0; x < 640; ++x)
        putpixel(x, y, 133, 224, 89);

int const magas = 480;
int const szeles = 640;
Szin const zold = { 133, 224, 89 };

for (y = 0; y < magas; ++y)
    for (x = 0; x < szeles; ++x)
        putpixel(x, y, zold);

Dinamikus memóriakezelés

int tomb[1000], n;
printf("Hány szám? ");
scanf("%d", &n);
for (int i = 0; i < n; ++i)
    tomb[i] = ...

Ha felülbecsüljük a tömb méretét, túl sok memóriát használ a programunk feleslegesen. Ha alulbecsüljük, akkor pedig egyszerűen nem fog működni: túlindexelés lesz benne.

char *beolvas(void) {
    char s[200];
    scanf("%s", s);
    return s;
}

Az élettartam problémája: például egy globális változó akkor is létezik, ha éppen nincs rá szükség, és ilyenkor feleslegesen foglalja a memóriát. A lokális változó meg megszűnik, ezért ott nem tudunk eredményt létrehozni a hívó számára – hacsak nem másoljuk le. A fenti beolvas() függvény kifejezetten hibás: a függvényből visszatérve megszűnik az s[] tömb, ezért az arra mutató pointer érvénytelenné válik (dangling pointer).

3. A hatalmas tömb, amit szeretnénk, nem fér a verembe.

A lokális változókat tároló, verem nevű memóriaterület általában viszonylag kicsi szokott lenni. Nem jó ötlet ezért túl nagy tömböket használni lokális változóként, mert azt a memóriaterületet fogjuk elhasználni, amire szükségünk van a függvényhívások kivitelezéséhez!

Mi dönthetjük el:

• Mennyi memóriát foglalunk
• Mikor foglalunk memóriát, és mikor szabadítjuk fel

A „dinamikus memóriakezelés” azt jelenti, hogy egyes memóriaterületek foglalását és felszabadítását mi vezéreljük a programból. A „dinamikus” szó az időre utal.

Mindennek van ára...

A fentiekért cserébe a saját felelősségünk

• a foglalás, és
• a felszabadítás is.

A malloc() és free() függvénypárost biztosítja a C nyelv a dinamikus memóriakezelés megvalósítására.

void *malloc(size_t méret)

Lefoglal egy bájtban megadott méretű memóriaterületet (malloc: memory allocation).

• Visszaad egy címet a lefoglalt területre.
• A terület mérete méret bájt, és inicializálatlan (memóriaszemét).
• Azért void*, mert nem ismeri a típusunkat.
• Ha nem sikerül, akkor NULL pointert ad.

void free(void *ptr)

Felszabadít egy memóriaterületet, amit a malloc() foglalt.

• A malloc() által adott címet kell neki adni.

Feladat: írjunk programot, amiben a felhasználó bárhány számot tud adni; ezeket mind tároljuk el!

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

int n;
printf("Hány számot? ");
scanf("%d", &n);

double *tomb;
tomb = (double*) malloc(n * sizeof(double)); // foglalás
if (tomb == NULL) {
    printf("Nem sikerült memóriát foglalni!\n");
    return false;                        // pl. hibajelzésként
}

tomb[3] = 12; /* tesszük a dolgunkat */  // tömbre mutat!

free(tomb);                              // felszabadítás

double *tomb = (double*) malloc(n * sizeof(double));

printf("Hány számot? ");
scanf("%d", &n);
double tomb[n];
...

Feladat: írjunk függvényt, amely összefűz két, paraméterként kapott sztringet! A függvény visszatérési értéke legyen az összefűzött sztring!

Ebben dinamikus memóriakezelést kell használnunk. Nem csak azért, mert nem tudjuk előre, hogy mekkora lesz a tömb, hanem azért is, mert a függvényből visszatérve a lefoglalt tömbnek meg kell maradnia. Az semmiképpen nem lehet a függvény lokális változója!

/* visszatér egy sztringgel, ami s1 és s2 összefűzve.
 * a hívónak fel kell szabadítania a kapott sztringet! */
char *osszefuz(char const *s1, char const *s2) {
    int mennyi = strlen(s1) + strlen(s2) + 1;
    
    char *res = (char*) malloc(mennyi * sizeof(char));  // !
    if (res == NULL)
        return NULL;

    strcpy(res, s1);
    strcat(res, s2);
    return res;
}

char *str;
str = osszefuz("alma", "fa");
printf("%s", str);
free(str);    // !

A lefoglalt memóriaterületet fel kell szabadítani.

Ahány malloc() hívás, annyi free() hívás kell történjen.

A malloc() által adott pointer szemünk fénye!

Ha elveszítjük, nem tudjuk majd azt a területet visszaadni.

Allokálatlan memóriaterület nem használható!

A pointer megléte nem jelenti azt, hogy a „mögötte” lévő memóriaterület is létezik!

char *szoveg;
szoveg[2] = 'x';

Itt a pointer még memóriaszemét, nincs tömb!

free(szoveg);
szoveg[2] = 'x';

Ha felszabadítottuk, akkor már nincs.

Hogyan lehet lekérdezni, hogy hány elemű tömböt foglaltunk?

Sehogyan, nekünk kell tudni.

Hogyan lehet ellenőrizni, adott terület le van-e foglalva?

Sehogyan, nekünk kell tudni.

Ezek nagyon fontosak. Különösen nem szabad egy dinamikus tömbön a sizeof operátort használni – hiszen az nem a tömb méretét, hanem a pointer méretét fogja megadni!

Lehet nulla méretű területet foglalni?

Lehet, de fel is kell szabadítani.

Szabad free(NULL) hívást csinálni?

Szabad.

Miért lényeges az előző kettő? Leginkább azért, mert ez sok helyen egyszerűsíti a programunkat. Ha olyan feladatunk van, ahol a beolvasott adatokkal nyújtjuk a tömböt, akkor a sor elején, amikor még nem érkezett adat, a nulla elemű tömböt nem kell speciális esetként kezelni. A malloc(n * sizeof(Valami)) kifejezésben az n értéke lehet 0, nem fog tőle hibásan működni a programunk.

Hasonló a free(NULL) esete is. Nem kell if (p != NULL)-t írni egy free(p) hívás elé, ha olyan a programunk felépítése, hogy néha le van foglalva a memóriaterület, néha nincs. Ez az ellenőrzés be van építve a free() függvénybe, és NULL pointerre nem csinál semmit.

Tartsuk nyilván, mekkora a lefoglalt terület!

A méret és a pointer összetartozó adat – rakjuk struktúrába! Hiszen éppen erre való a struktúra: tartsuk egy helyen, ami összetartozik.

typedef struct DinTomb {
    double *adat;
    int meret;
} DinTomb;

DinTomb dt;

dintomb_foglal(&dt, 100); // inicializálás

dt.adat[34] = 19;         // használat
dintomb_kiir(&dt);
dintomb_atmeretez(&dt, 200);

dintomb_felszabadit(&dt); // felszabadítás

bool dintomb_foglal(DinTomb *dt, int meret) {
    dt->meret = meret;
    dt->adat = (double*) malloc(meret * sizeof(double));
    return dt->adat != NULL;    // sikerült?
}

void dintomb_kiir(DinTomb const *dt) {
    for (int i = 0; i < dt->meret; ++i)
        printf("%f ", dt->adat[i]);
    printf("\n");
}

void dintomb_felszabadit(DinTomb *dt) {
    free(dt->adat);
}

A kiíró függvény ugyan nem kellene pointerével átvegye a struktúrát (mert úgysem akarja megváltoztatni), de egyszerűbb így megoldani. Nem kell majd fejben tartani, hogy melyik függvény várja értékként és melyik címként a paramétert, hanem mindegyik címként, így mindegyiknél ki kell írni az & operátort. Ez azoknak kényelmes, akik használják a függvényt. A pointer viszont ebben az esetben konstans adatra mutat: ezzel jelezzük azt, hogy a függvény, bár cím szerint veszi át a struktúrát, megváltoztatni nem szeretné azt.

Az alábbi függvény átméretezi a dinamikus tömböt. Ha a tömb zsugorodik, a végén lévő adatok elvesznek. Ha nyúlik, akkor a végén memóriaszemét lesz – a használó feladata, hogy oda érvényes adatot tegyen.

bool dintomb_atmeretez(DinTomb *dt, int ujmeret) {
    double *ujadat = (double*) malloc(ujmeret * sizeof(double));
    if (ujadat == NULL)
        return false;
    int min = ujmeret < dt->meret ? ujmeret : dt->meret;
    for (int i = 0; i < min; ++i)
        ujadat[i] = dt->adat[i];
    free(dt->adat);
    dt->adat = ujadat;      // !
    dt->meret = ujmeret;
    return true;
}

void *calloc(size_t darabszám, size_t egyelem)

Lefoglal egy tömböt és kitölti 0 bájtokkal.

• Első paraméter: a tömb elemszáma, második: egy elem mérete
• Pl. int *tomb = (int*) calloc(100, sizeof(int));
• Vigyázat! Ez nem biztos, hogy a csupa 0 bájt jó nekünk! Pl. lehet, a NULL pointert nem csupa 0 bitsorozat jelöli. A calloc() ezért csak számokhoz (int, char...) jó.

void *realloc(void *ptr, size_t méret)

Újrafoglalja, átméretezi a ptr által mutatott dinamikus tömböt.

• A meglévő adatokat másolja
• Ha nagyobb lett, a többi memóriaszemét. Ha kisebb, a vége elveszik
• Vigyázat! Lassú lehet!

Vigyázni kell a realloc() függvénnyel, mert lassú lehet. A megnagyobbított tömb lehet, hogy nem fér el az adott memóriaterületen (mert utána is van lefoglalva egy másik változó), és ilyenkor a realloc() kénytelen az egész tömböt egy teljesen másik helyre átmásolni. Ne írjunk olyan programokat, amelyek gyakran méreteznek át tömböket!

A memóriakezelés áttekintése

Egy változó definíciójának helyétől függ, hogy hol jön létre.

A definíció módja alatt főként a definíció helyét értjük. Ha egy függvény belsejében azt mondjuk, hogy int x, az mást jelent (lokális változót), mintha függvényen kívül írjuk ugyanazt az int x-et (globális változót). Ez egyben a változó élettartamát is meghatározza.

Ezeket a helyeket tárolási osztályoknak nevezzük (storage class):

• Globális változók memóriaterülete (data segment),
• Lokális változók memóriaterülete (stack segment),
• Dinamikusan foglalt memóriaterület (heap, free store).

A három memóriaterület mérete változik is. A globális adatterületen mindig ugyanannyi adat van. A veremben lévő adatok mennyisége függvényhívásokkor nő, visszatéréskor pedig csökken. (Így aztán pl. a main() változói mindig ott vannak a „legalján”.) A kupac mérete is változik, a lefoglalt-felszabadított területek nagyságától függően.

Természetesen a fentiek nem azt jelentik, hogy a számítógépben valójában is többféle memória van. Csak annyit, hogy ugyanannak a memóriának egyes részeit máshogyan kezeljük, és más célból teszünk oda változókat. A pointerek viszont bármelyik memóriaterület változóira tudnak mutatni.

A függvények statikus változói megőrzik értéküket a hívások között.

A globális változókhoz hasonlóan „örökéletűek” a függvények static kulcsszóval jelzett változói is: megmaradnak a program futásának végéig, és megőrzik értéküket. Léteznek azután is, miután visszatérünk a függvényből. (A static kulcsszót a változó definíciója elé tesszük, a tárolási osztályt jelöli meg. A neve ilyenkor: storage class specifier.) Példa:

#include <stdio.h>

int hanyszor_hivodott(void) {
    static int hanyszor = 0;    // !
    
    hanyszor += 1;
    return hanyszor;
}

int main(void) {
    printf("%d\n", hanyszor_hivodott());    /* 1 */
    printf("%d\n", hanyszor_hivodott());    /* 2 */
    printf("%d\n", hanyszor_hivodott());    /* 3 */

    return 0;
}

Röviden: a függvények statikus változói láthatóságban úgy viselkednek, mint a lokális változók (csak a függvényben látszanak), élettartamukban viszont úgy, mint a globális változók („örökéletűek”).

#include <stdio.h>
#include <string.h>

int main(void) {
    char str[] = "Szia, ez itt egy proba. Futtass le!";
    char *pch;

    printf("Az eredeti szoveg: %s\n",str);

    pch = strtok(str, " ,.!");
    while (pch != NULL) {
        printf("%s\n", pch);
        pch = strtok(NULL, " ,.!");
    }

    return 0;
}

Innen foglalódik le az a memóriaterület, amit a malloc()-tól kapunk.

int main(void) {
   int *t;
   char *p;

   t = (int*) malloc(100*sizeof(int));
   t[0] = 3;
   t[1] = 6;

   p = (char*) malloc(20*sizeof(char));
   strcpy(p, "helló");

   ...

Figyeljük meg, hogy a fenti kódban az int *t és a char *p lokális változói a függvénynek. Tehát ezek a veremben fognak létrejönni. Egészen addig nem is mutatnak semmilyen memóriaterületre (pontosabban: véletlenszerű helyre mutatnak, mert inicializálatlanok), amíg nem adunk nekik értéket. Ez az értékadás mindkét esetben a malloc() hívása után történik meg; a foglalást a malloc() végzi, a pointer megjegyzéséért pedig az értékadások felelnek.

int sztring_hossz(char *s) {
    /* ... */
}

printf("%d", sztring_hossz("hello"));

Érvénytelen pointerek (dangling pointer): olyan pointerek, amelyek már megszűnt változóra mutatnak.

Mutató felszabadított memóriaterületre:

int *p = (int*) malloc(100*sizeof(int));
p[2] = 12;
free(p);
printf("%d", p[2]); // hibás!!!

A felszabadítás után a p érvénytelen pointerré válik. Ilyenek lesznek a programjainkban sokszor, nincsen velük baj; az a baj, ha rajtuk keresztül a már megszűnt változót megpróbáljuk elérni. Könnyen előfordulhat, hogy teszteléskor nem vesszük észre a hibát, mert ha az a memóriaterület még nem íródott felül, akkor kiolvasva azt az adatot kapjuk, amit látni szeretnénk.

Mutató lokális változóra:

int *fv(void) {
   int i = 7;
   return &i; // hibás!!!
}

int *ptr = fv();

proba.c:4:4: warning: function returns address of local variable

char *beolvas(void) {
   char s[200];
   scanf("%s", s);
   return s; // hibás!!!
}

Ha dinamikusan foglaljuk, a függvényből visszatérés után is lefoglalva marad, így átadhatjuk a hívónak:

int *beolvas_sokszam(int n) {
    int *uj;
    uj = (int*) malloc(n * sizeof(int));
    ...
    return uj;
}

int main(void) {
    int *s;
 
    s = beolvas_sokszam(5);
    ...
    free(s); // !

Így lehet egyszerűen megoldani az előző dián említett problémát. Az a célunk, hogy ne tűnjön el a tömb, ezért átvesszük a memória kezelését a fordítótól. (Saját felelősségre! Mert a felszabadítás is a mi dolgunk.)

char *hello(void) {
    return "hello";
}
printf("%s", hello());

Helyes. A sztring globális memóriaterületen van, a függvényből visszatérés után is létezni fog. Szabad hivatkozni arra a memóriaterületre!

int *hello(void) {
    static int tomb[5] = { 9, 4, 5, 6, 1 };
    return tomb;
}
printf("%d", *hello());

Helyes. A static kulcsszóval megjelölt lokális változó megmarad a függvényből visszatérés után, vagyis az élettartama szempontjából majdnem úgy viselkedik, mintha globális változó lenne. Erről még lesz szó később; memóriakezelés szempontjából a lényeg itt az, hogy mivel megmarad a változó, a visszaadott pointer nem dangling pointer lesz.

int *hello(void) {
    int *tomb = (int*) malloc(10*sizeof(int));
    tomb[0] = 12;
    return tomb;
}
printf("%d", *hello());

Helytelen! Bár megmarad, és szabad hivatkozni, de felszabadítani ki fogja?! Ha nincs elmentve az a pointer, ami hivatkozik a memóriaterületre, akkor nem tudjuk odaadni a free()-nek, és semmi módja nincsen a felszabadításnak! Sőt a függvény minden meghívásakor újabb memóriaterület lesz lefoglalva. Előbb-utóbb a programunk sok száz megabájt memóriát fog magánál tartani!

Több dimenziós tömbök

Több dimenziós tömb

int tomb[3][4]; // magas, széles

tomb[1][2] = 9; // y, x

széles*magas darab integer!

A fordító leképezi egydimenziós tömbre, amiben az elemek sorfolytonosan helyezkednek el. Így akárhány dimenziós lehet. A tömb mérete szélesség*magasság integernyi. Leképezés: tomb1d[y*szélesség+x].

Egy sor a tömbből

int osszeg(int *tomb, int meret);

int tomb[3][4] = {{…}, {…}, {…}};    // 3 sor, 4 oszlop

printf("%d", osszeg(tomb[1], 4));    // 1. sor: 1D tömb, 4 elemű

A 2D tömb egyik sora: az egy 1D tömb!

A C a változók, függvények és függvényparaméterek deklarációjakor ugyanazokat a precedenciaszabályokat érvényesíti, amelyeket a programkód elemzésekor is használ. Ebből az következik, hogy a deklarációnál pont ugyanúgy kell megadnunk a tömböket, pointereket, mint ahogyan azokat használjuk. Ezért kell egy tömböt int t[10] alakban megadni: mivel ha a tömb neve mögé tesszük az indexelő operátort, akkor kapjuk meg a benne lévő egész számot; és ezért kell a pointert int *p alakban megadni, mivel a pointer neve elé tett * operátorral tudjuk dereferálni azt, kapva az egész számot.

Nézzünk példákat, hogyan lehet összetett deklarációkat alkotni! Első példa legyen a kétdimenziós tömb, azaz tömbök tömbje.

Ez tehát egy mátrix, azaz kétdimenziós tömb, amely összesen 3×4 = 12 elemet tartalmaz. A kapott deklarációt értelmezni is tudjuk: a valami egy olyan dolog, aminek a kétszeri indexelése egy int-hez vezet. Az első indexelés egy 3 elemű tömbön történik, 0...2 indexek lehetségesek. A második pedig az így kiválasztott soron, amelyik egy 4 elemű tömb.

A második táblázat int *valami[4] deklarációja azt jelenti, hogy a valami nevű változót *valami[i] formában használva egy int típushoz jutunk (ahol i valamilyen index). Mivel az indexelő operátor [] precedenciája magasabb, mint az indirekció * operátoráé, ez azt jelenti, hogy az indexelés vonatkozik a változóra, a * pedig már az indexelés után kapott dologra. Vagyis ha a valami-t megindexeljük, akkor kapunk egy dereferálható értéket (egy pointert), amit dereferálva végül egy egész számhoz jutunk. A valami nevű változó tehát egy tömb, ami int* mutatókat tartalmaz: pointerekből álló tömb.

A zárójelezéssel tudjuk a precedenciaszabályok „ellenében” módosítani azt, hogy mely operátorok mely operandusokra vonatkoznak. Az újabb deklaráció azt jelenti, hogy ezt a valami-t úgy kell használni, hogy előbb dereferáljuk, utána pedig indexeljük, és így kapunk majd egész számot. Szóval ez a valami egy pointer kell legyen egy olyan helyre a memóriában, ahol indexelhető dolgok (tömbök) vannak, amiket indexelve egészeket kapunk. Ez egy pointer egy négy elemű tömbre, vagy esetleg négy elemű tömbökre (első négy elemű tömb, második négy elemű tömb és így tovább.)

Összetett deklarációk létrehozásához és értelmezéséhez jól használható a cdecl nevű program, amely elérhető online verzióban is a https://cdecl.org/ helyen.

Több dimenziós tömböt úgy tudunk átadni függvénynek, ha rámutatunk egy pointerrel az első sorára. A pointer típusának azonban tartalmaznia kell azt az információt, hogy milyen szélesek a sorok. Különben nem lehetne a sor kiválasztásánál tudni azt, hogy az egyes sorok hol kezdődnek a memóriában. Ezért a paraméter egy tömbre mutató pointer kell legyen, pl. int (*tomb)[4], ha a szélesség 4 elemnyi.

int osszeg_2d(int (*tomb)[4], int magassag) {
   int sum = 0;
   for (int y = 0; y < magassag; ++y)
      for (int x = 0; x < 4; ++x)       // fix
         sum += tomb[y][x];
   return sum;
}

int osszeg_2d(int  tomb[][4], int magassag);
int osszeg_2d(int (*tomb)[4], int magassag); // mindkettő jó

Fontos: így a tömb nem lehet akármilyen széles! A pointer aritmetika működése miatt (és a fentebb bemutatott sorfolytonos leképezés miatt) a fordítónak mindenképpen ismernie kell a szélességet. Akármelyik formában adjuk át a tömböt, a verembe a függvény számára mindig csak egy pointer kerül! Még akkor is, ha a fejlécbe int tomb[3][4]-et írunk, tehát mindkét dimenziót kiírjuk. (Annak az esetnek az a furcsasága, hogy a 3-mal a fordító nem is foglalkozik. Annyira nem, hogy akármilyen magas, 4 elem széles int tömbbel hívható az a függvény!)

A fentiek miatt a következő fejléc hibás. De ez amúgy sem meglepő; definiálatlan méretű tömb nem létezhet:

int hibas(int tomb[][], int szeles, int magas);

Sztringet tömbjét kétféleképpen is létrehozhatunk. Az egyik, hogy tömbök tömbjét hozzuk létre. A másik pedig, hogy pointerek tömbjével dolgozunk, amelyben a pointerek sztringekre mutatnak.

char sztringek[3][12] = {
   "hello vilag",
   "almafa",
   "hexdump"
};

0000  68 65 6c 6c 6f 20 76 69 6c 61 67 00   hello vilag.
000c  61 6c 6d 61 66 61 00 00 00 00 00 00   almafa......
0018  68 65 78 64 75 6d 70 00 00 00 00 00   hexdump.....

char *sztringek[3] = {
   "hello vilag",
   "almafa",
   "hexdump!"
};

0000  22 00 00 3c   "..<
0004  2e 00 00 3c   ...<
0008  35 00 00 3c   5..<

Itt egy olyan típust alkottunk, aminek a használata nagyon hasonló az előzőéhez; megindexelve egy pointert kapunk, ami akár egy sztringre, nullával lezárt karaktertömbre is mutathat. Ebben az esetben azonban nem egy kétdimenziós tömbről van szó, amely a memóriában sorfolytonosan helyezkedik el, hanem egy olyan tömbről, amely pointereket tartalmaz. Ha megnézzük, mit találunk a memóriában a sztringek változó helyén, akkor ott a szövegeket nem fogjuk megtalálni, csak három darab pointert! A sztringek ilyenkor globális területre kerülnek.

Nézzük meg, hogyan lehet két dimenziós, dinamikus tömböket létrehozni, amelyeknek a szélessége és a magassága is tetszőlegesen megválasztható! Ugyanezek a gondolatmenetek általánosíthatóak bármennyi dimenzióra.

0. módszer: 1D leképezés

Mi magunk végezzük el a leképezést. Ezzel egyszerűen kikerüljük a problémát. Megold mindent, de sajnos nehézkes használni. (Mindenhol a szorzós képletet kell beírni az indexbe.)

double *szamok;

szamok = (double*) malloc(szelesseg*magassag * sizeof(double));

szamok[y * szelesseg+x] = 3.14;    // szamok[y][x] helyett :(

fv(szamok, szelesseg, magassag);   // fv(double*, int, int)

free(szamok);

1. módszer: soronkénti foglalás

Minden sort külön foglalunk le. Az egyes sorokhoz tartozó pointereket egy pointertömbbe tesszük, amelyet szintén dinamikusan foglalunk (hogy a magasság is tetszőleges legyen). Ha így teszünk, a lefoglalt tömböt a megszokott módon használhatjuk, két egymás utáni indexeléssel, pl. szamok[2][3]. Az első indexelés a pointerek tömbjéből (a rajzon a függőleges) kiválaszt egy pointer, a második indexelés pedig már az ezáltal mutatott tömbön történik (a rajzon valamelyik vízszintes).

Természetesen a pointerek tömbjét kell előbb foglalni, utána a sorokat; mert az előbbibe tesszük be a sorok pointereit. A felszabadításnál ugyanez visszafelé történik: amíg a sorokat szabadítjuk fel, addig szükségünk van a pointerekre, ezért a pointerek tömbje lesz az, amit legutoljára szabadítunk fel. A módszer hátránya az, hogy sok malloc() hívás kell hozzá, ami lassabb, mintha csak egy vagy kettő lenne.

double **szamok;

/* foglalás */
szamok = (double**) malloc(magassag * sizeof(double*));
for (y = 0; y < magassag; ++y)
   szamok[y] = (double*) malloc(szelesseg * sizeof(double));

/* használat */
szamok[y][x] = 3.14;
fv(szamok, szelesseg, magassag);

/* felszabadítás */
for (y = 0; y < magassag; ++y)
   free(szamok[y]);
free(szamok);

2. módszer: leképezés és pointertömb

Az öszvér. Az egész tömböt (a „kilapított”, sorfolytonos leképezést) egy malloc() hívással foglaljuk, mint a nulladik módszernél. Ezen kívül fogunk egy másik tömböt, amely pointerekből áll, mint az első módszernél. Ezek a pointerek a kilapított tömb belsejébe mutatnak, mégpedig oda, ahol a két dimenziós tömb leképezett sorainak elejei vannak. Így ha megindexeljük a pointerekből álló tömböt (amely a középső a rajzon), egy pointert kapunk, amely a kilapított tömb belsejébe mutat; azt megindexelve megkapjuk a keresett elemet.

Ez a módszer gyorsabb foglalást eredményez, mint az előző, mert mindössze két darab malloc() hívásra van hozzá szükség. A foglalás első lépése a pointertömb foglalása, második lépése az elemek tömbjének foglalása, a harmadik lépése pedig a kilapított tömb belsejébe mutató pointerek kiszámítása egy ciklusban.

double **szamok;

/* foglalás */
szamok = (double**) malloc(magassag * sizeof(double*));
szamok[0] = (double*) malloc(szelesseg * magassag * sizeof(double));
for (y = 1; y < magassag; ++y)
   szamok[y] = szamok[0] + y * szelesseg;

/* használat */
szamok[y][x] = 3.14;
fv(szamok, szelesseg, magassag);

/* felszabadítás */
free(szamok[0]);
free(szamok);

Melyik megoldást érdemes választani?

Táblás játék: állandó a szélesség, így egyszerűbb, gyorsabb az egyben foglalt terület..

Sztringek tömbje: ha a hosszak nagyon eltérőek, jobb, ha egyesével foglaljuk a tömböket. Ennek előnye lesz az is, hogy az egyes tömbök külön-külön is újrafoglalhatóak.

A cím szerinti paraméterátadás működése:

void novel(VALAMI *ptr) { // növeli az átvett változót
   *ptr += 1;
}

A VALAMI típus akár egy mutató is lehet:

void novel(char **ptr) {
   *ptr += 1;
}

char *szoveg = "hello";
novel(&szoveg);
printf("%s", szoveg); // „ello”

Pointerre mutató pointer – a 2D dinamikus tömböknél már használtuk.

Írjunk függvényt, amely cím szerint átvett paraméterben adja vissza a lefoglalt 2D dinamikus tömbre mutató pointert!

double **tomb;

foglal(&tomb, 10, 20); // double** változó címe: double***

A tomb változó itt egy pointer. De attól még az csak egy sima változó, amelynek címe is van a memóriában. Ha a típusa double**, akkor a címének típusa double*** – és ez lesz az őt cím szerint átvevő függvény paraméterének típusa.

void foglal(double ***ptomb, int szeles, int magas) {
   double **uj;

   uj = (double**) malloc(magas * sizeof(double*));
   for (int y = 0; y < magas; ++y)
      uj[y] = (double*) malloc(szeles * sizeof(double));

   *ptomb = uj; // *ptomb → a double** típusú változó!
}

A ptomb változó egy pointer a fenti double** típusú változóra. Vagyis ha dereferáljuk: *ptomb, akkor hivatkozni tudunk arra, amelyiket megkaptunk cím szerint. Ide másoljuk be a foglalt pointertömb kezdőcímét, vagyis az uj pointer értékét.