int i, *pi = &i;
i=2;
*pi=2;

char c, *pc = &c;
putchar(c);
putchar(*pc);

A pointer egy változó címét (helyét) tárolja a memóriában. Egy adott változóra ez a cím a & operátorral képezhető, és a pointerben eltárolható. Így a pointer gyakorlatilag az adott változóra hivatkozik, rajta keresztül elérjük a változót, aminek a címét képeztük. Ha a pointert dereferáljuk a * operátorral, akkor a változót kapjuk meg, amelynek értéke írható és olvasható is a pointeren „keresztül”. Vagyis a dereferált pointer is lehet balérték.

A pointer típusához hozzátartozik a mutatott változó típusa is, pl. egészre mutató pointer típusa int*, karakterre mutató pointer típusa pedig char*. Erre két dolog miatt van szükség:

• Egyrészt így válik értelmessé a dereferálás, hiszen az csak akkor értelmes művelet, ha tudjuk, hogy milyen típusú adatot hivatkozunk a memóriában. A helye önmagában ehhez kevés.
• Tömbök esetén a típus ismerete ad lehetőséget a pointer aritmetikára: kiszámítható, hogy a következő elem hol van. Annyi bájttal van arrébb a tömb kezdetéhez képest, ahány bájtos egy elem.

Ezért működnek úgy a tömbök, hogy egyforma típusokat lehet csak tárolni bennük. Nem lehet egy tömbben összevissza mindenféle, int, double, struct Pont stb. típusú adat, hiszen ezek eltérő méretűek, és nem lehetne könnyen kiszámolni, hogy melyik elem hol található a memóriában.

void pluszegy(int *hova) {
  *hova += 1;
}

int x=2;

pluszegy(&x);

int tomb[4], *pi;

pi=tomb;   // &tomb[0]

pi[2]=4;   // *(pi+2)=4

tomb[1]=2; // *(tomb+1)

A tömb elemei helyének kiszámítására azért van lehetőség, mert tudjuk, hogy azok egymás mellett helyezkednek el a memóriában. A fordító e célból pontosan így helyezi el őket a memóriában.

Akkor is ez történik, amikor az indexelő operátort használjuk; akár pointeren, akár egy tömbön magán. Kiszámolódik az adott elem címe, utána pedig az így keletkező pointer dereferálódik. C-ben így működik a tömbök paraméterként átadása is, ahogyan az a következő forráskódokon látható.

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

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

Akár változót adunk át cím szerint, akár egy tömböt a függvénynek, mindkét esetben egy pointer adódik át. Önálló változó esetén ezt a pointert a * operátorral dereferáljuk a függvényben, és így elérjük a változót. Tömbök esetén elvileg egy címszámítás és egy dereferencia kell (*(tomb+i)), de ezt külön kiírni felesleges, hiszen erre való az indexelő operátor.

Az itt bemutatott működés kellemetlen tulajdonsága az, hogy akár tömböt adunk át, akár önálló változóra mutató pointert, mindkét esetben a paraméter típusa mutató. Ezért ha látunk egy ilyen függvénydeklarációt:

void fuggveny(int*);

akkor ránézésre nem tudjuk megmondani, hogy ez a függvény egy darab integert vár cím szerint, vagy egy tömböt. Tömb esetén ezért a definiálatlan méretű tömbparamétert szokták használni néha:

void fuggveny(int[]);

De ez tökéletesen ugyanazt jelenti a fordító számára, mint az előbbi. Vagyis ilyenkor is egy pointer adódik csak át, és ilyenkor sem másolódik le a tömb, hanem az eredetit látjuk! Ezért ez a forma meg ilyen szempontból lehet kicsit megtévesztő.

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

Például egy kereső függvénytől nem várjuk, hogy megváltozzon a hívás során a tömb értéke, és ha ilyet hibázunk, arra a fordító sem figyelmeztet. 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.

A const kulcsszóval tudjuk jelezni egy adatnál, hogy azt nem szabad megváltoztatni.

void kiir(int const *tomb, int meret);

int tomb[100] = { … … … };
kiir(tomb, 100);          // int* → int const*

struct Rajz { … … … };
void rajzol(Rajz const *r);

Rajz r;
rajzol(&r);               // Rajz * → Rajz const *

int const * – ez azt jelenti, hogy ez a mutató konstans integerekre mutat. Vagyis hogy meg lehet hivatkozni a mutatott értékeket (a tömb elemeit), és ki is lehet olvasni azokat, de változtatni nem lehet rajtuk. Vagyis pl. egy értékadást nem fog engedni a fordító, hanem fordítási hibával visszadobja a programot.

Az ilyen mutatókat kétféleképpen szokták írni: int const * és const int *. Mind a kettő ugyanazt jelenti: a pointer által mutatott integereket konstansnak tekintjük. Az utóbbi időben elterjedtebb az int const forma, mert az logikusabb, ha mindig azután írjuk, hogy const, ami konstans. (Pl. int * const azt jelenti, hogy az integereket lehet változtatni, de a pointert nem lehet máshova állítani: *p=2 szabad, p++ viszont nem. Erről a második félévben lesz szó részletesebben.)

A függvényhívás helyén a tömb kezdőcíme elvileg int * típusú. Ezt a fordító automatikusan konvertálja int const *-gá; ilyenkor persze igazából semmi nem történik, ez csak egy jelzés, hogy a függvényen belül már tilos a változtatás. Egy adott típusról ugyanolyan típusú konstanssá automatikus a konverzió. A másik irányba viszont értelemszerűen tiltott: ha egy konstans pointer sima pointerré alakulhatna vissza automatikusan, akkor az egésznek semmi értelme nem lenne.

A konstansoknak egyébként kiváló „öndokumentáló” szerepük is van. Ha olvassuk a kódot, és látjuk valamiről, hogy konstans, akkor hamarabb megértjük a program működését – hiszen egyből látjuk, mi a konstans, és mi a változó.

int x, y;

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

int const KepMag=480;
int const KepSzel=KepMag/3*4;
int const piros=133, zold=224, kek=89;

int x, y;

for (y=0; y<KepMag; ++y)
  for (x=0; x<KepSzel; ++x)
    putpixel(x, y,
        piros, zold, kek);

Ha a programunkat egy másik felbontásra szeretnénk átállítani, elegendő mindössze a két konstans értékét felülírni és a következő fordításnál már minden algoritmus az új értékekkel fog dolgozni.

Ha a konstansok helyett számokat használtunk volna, akkor minden előfordulásnál felül kéne írni őket. Ez fáradságos munka, és hibalehetőségeket is rejt magában: elég egy helyen elfelejteni az átírást, és egy nehezen megtalálható hibát vittünk a programba.

A konstansok „furcsa állatok”. Ezek tulajdonképp konstans változók: az oxymoron mindkét fontos tulajdonságukat kifejezi. Konstansok, mert a létrehozás után már nem lehet őket megváltoztatni. Változók, ugyanúgy van helyük a memóriában, értéket kaptak a létrehozásuk pillanatában – és nem lehet velük tömb méretét megadni! Az utóbbi ok miatt konstans egészeket gyakran az enum kulcsszóval hozunk létre, bár az eredendően nem erre való.

Ha elfelejtjük megtenni, a programunk folyton növekszik, és előbb-utóbb le kell állítani…

• Ez vagy a felhasználónak kellemetlen,
• Vagy nekünk, ha ezt az operációs rendszer kénytelen megtenni.

Gondoljunk bele, a dolog néha kényelmetlen, ugyanakkor nagyon hasznos tud lenni. Ha egy adott memóriaterületre csak egy bizonyos ideig van szükség, akkor lefoglalhatjuk csak akkor, amikor először kell, és felszabadítatjuk, amikor már nem kell. Így a programunk kevesebb memóriát foglal.

Másrészt pedig nem kell pazarlóan felülbecsülnünk a méretet, és nem kell attól sem félni, hogy alulbecsüljük azt a program tervezése során. Amikor már tudjuk, mennyi memória kell, csak akkor foglalunk. Például két sztring összefűzve: megnézzük a két összefűzendő sztring hosszát, és az alapján tudjuk, hogy az összefűzött számára mennyit kell foglalnunk. Vagy megnyitunk egy fájlt, megnézzük, milyen hosszú, lefoglalunk annyi memóriát, és beolvassuk az egészet.

#include <stdlib.h>

double *tomb; // ptr a majdan lefoglalt területre
int i, n;

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

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

tomb[3]=12; /* tesszük a dolgunkat */    // ez egy tömb!

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

A lefoglalt területre egy void* mutatót kapunk. Ez azért mutat void, vagyis ismeretlen típusra, mivel a malloc() nem tudja, milyen típusúak a lefoglalt területen tárolt adataink. (Nem is tudhatja, hiszen a malloc() a nyelvbe van beépítve, vagyis nem lehet felkészítve az összes általunk létrehozott típusra, pl. a saját magunk által definiált felépítésű struktúrákra.) Ezt a void* típusú pointert átalakítjuk a saját típusunkra mutató pointerré (type cast), pl. jelen esetben double* típusúvá, és így tároljuk el a változónkban.

Mivel a malloc() semmit nem tud a lefoglalt területünkről, a méretét nekünk kell kiszámolni, és bájtokban megadni. Itt egy tömböt foglalunk, ezért a legegyszerűbben ezt egy szorzással tehetjük meg. A sizeof operátor, ahogy a fájlkezelésnél is szerepelt, egy adott típus méretét bájtban megadja; pl. sizeof(double) az annyi lesz, ahány bájtos egy double szám. Ha ezt megszorozzuk a tömb elemszámával, akkor éppen a kérdéses méretet kapjuk. A lefoglalt terület inicializálatlan, vagyis memóriaszemetet tartalmaz.

Innentől kezdve a pointeren keresztül el tudjuk érni a memóriaterületet. Kényelmes itt nagyon, hogy a pointereken is használható az indexelő operátor, hiszen a használat közben nem is kell foglalkozni vele, hogy a tömb statikusan vagy dinamikusan lett lefoglalva; ugyanúgy működik az indexelő operátor, ugyanúgy átadható függvénynek (hiszen a tömbös függvények eddig is pointert vártak) és így tovább. Túlindexelni természetesen továbbra sem szabad.

Ha végeztünk, és már nincsen szükség az adatokra, akkor visszaadjuk a lefoglalt területet. Ehhez átadjuk a free() utasításnak azt a pointert, amit a malloc()-tól kaptunk (ezzel azonosítja, hogy melyik területről van szó). Elvileg ugyan a free() egy void* típusú pointert vár, de ilyenkor a típus konverzióját nem kell elvégezni, mert a valami*→void* konverzió automatikus. Miután felszabadítottuk a memóriaterületet, már nem szabad hivatkozni azt! Hiszen azt egy másik malloc() hívás másra használhatja, vagy bármi más történhet vele. Ha így teszünk, az nagyon súlyos hiba!

A C nyelv újabb, de nem minden fordító által elfogadhatóan támogatott verziójában, a C99-ben lehetőség van arra, hogy malloc() hívás nélkül hozzunk létre olyan tömböt, amelynek mérete futási időben derül ki. Ilyen tömb természetesen csak függvény lokális változója lehet, és bár a mérete nem fix, de az élettartama igen, hiszen a függvényből visszatérve meg fog szűnni.Vagyis a fentit C99-ben akár így is írhatjuk (természetesen a free() hívást is elhagyva):

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

A változóval megadott méretű tömböket a különböző programozási nyelvek vagy támogatják, vagy nem. A Pascal és a C89 nem támogatja, a C99 és a C++ pedig igen. Algoritmusok tervezésekor figyelembe kell vennünk, hogy egy meg nem adott méretű tömböt esetleg dinamikus memóriakezeléssel tudunk csak majd megvalósítani a választott programozási nyelven. Figyelembe kell vennünk azt is, hogy a verem mérete általában jóval kisebb, mint a dinamikusan, malloc()-kal foglalható memória mérete. Így ezt csak kisebb tömbökre használhatjuk.

char *s;
s=osszefuz("alma", "fa");
...

/* 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;
    char *res;
    
    mennyi = strlen(s1)+strlen(s2)+1;
    res = (char*) malloc(mennyi*sizeof(char));
    if (res == NULL)    /* ha nem sikerült a malloc() */
        return NULL;

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

Látható, hogy így meg tudjuk oldani az élettartam problémáját is. A függvényből visszatérve ugyanis az új sztringet tároló memóriaterület nem szabadul fel automatikusan, hanem a hívó döntheti el, hogy mikor nincsen már a továbbiakban szüksége arra. Vissza ez a függvény nem a sztringet adja, hanem csak egy pointert a lefoglalt memóriaterületre. A lokális char* res változó ugyan megszűnik, de azt a visszaadáskor lemásoljuk! (Csak a pointert! Nem az egész tömböt!)

Amikor visszatérünk, a létrehozott tömb így nem szűnik meg! A pointer ugyan igen, de azt visszaadjuk, és a hívónak azt el kell tárolnia magának.

/* 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);

char *s;
s=osszefuz("alma", "fa");
printf("Ezt írtad be: %s\n", s);
free(s); // !

Fontos figyelni arra, hogy fel is szabadítsuk a memóriaterületet, ha már nincsen rá szükség. Mivel az osszefuz() függvény ezt nem teheti meg (hiszen épp az a feladata, hogy foglalja le a sztringet, és ne szabadítsa fel), ez csakis a hívó feladata és felelőssége lehet.

Emiatt a visszakapott pointert el kell menteni egy változóba, hiszen ha elfelejtjük, akkor semmi mód nem lesz már arra, hogy felszabadítsuk azt a memóriaterületet. Természetesen az s=osszefuz(………) értékadás ilyenkor nem sztring másolás, hanem csak egy pointer értékadás. Hiszen s típusa pointer, a visszaadott érték is pointer, és ezt másoljuk az értékadással.

Hogy biztosítsuk a program tervezése során, hogy a területet végül fel is fogja valaki szabadítani, annak egy szemléletes módja az, ha valakihez hozzárendeljük a felelősséget. Például a int* fuggveny(void) függvény dokumentációjában leírjuk azt, hogy a visszaadott pointer egy olyan memóriaterületre mutat, ahol az eredmény van; és hogy azt később a hívó dolga lesz felszabadítani, ha már nincsen rá szüksége. Ezzel azt jelöljük ki, hogy ki annak az erőforrásnak a tulajdonosa.

Maga a malloc()–free() függvénypáros is ilyen! A malloc() lefoglal egy területet, és az a program tulajdonába kerül. Felelőssé válik is ezáltal azért, hogy később a free() függvényt meghívja.

^* A legutóbbiak nem voltak mindig így. A C szabvány 1990-es verziója (C90) előtt gyakran volt az, hogy régebbi fordítók által generált programok lefagytak egy free(NULL) hívás hatására. Ma azonban már a szabvány előírja, hogy kezeljék ezt az esetet. Ennek ellenére előfordul manapság is az, hogy ez problémát jelent egyes fordítók és C könyvtárak esetén.

Azt nem írja elő, hogy a nulla méretű terület foglalásakor mi kell történjen. Vagy kapunk egy nem NULL pointert, amelyet azonban dereferálni nem szabad (hiszen ott nulla méretű adat van), vagy egy NULL pointert (akkor meg azért nem). A szabvány ezt a fordítókra bízza. Ellenben ha a pointer nem NULL, akkor fel is kell szabadítanunk azt (a nulla méretétől függetlenül), úgyhogy emiatt kényelmes az, hogy a free() elvileg hívható NULL paraméterrel is.

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

DinTomb dt;

dintomb_foglal(&dt, 100); // foglal

dt.adat[34]=19;           // használ
dintomb_kiir(&dt);

dintomb_felszabadit(&dt); // felszabadít

Amikor létrehozzuk a dt nevű struktúrát, akkor a tömbnek természetesen nem lesz memória lefoglalva, mert a struktúrában csak egy pointer és egy integer van. Ezért a foglaláshoz írunk egy függvényt: ennek feladata a memóriaterület lefoglalása, és az adatok beírása a struktúrába. (Mivel módosítja a struktúrát, ezért arra mutató pointert kell átvegyen.)

Ezután már használhatjuk a tömböt. A struktúra előnye itt is látszik: egy ilyen tömböt egyetlen paraméterrel át tudunk adni. Nem kell megadnunk a pointert és a méretet is, hanem elég csak a struktúrát megmutatni, hiszen abban benne van minden információ.

int dintomb_foglal(DinTomb *dt, int meret) {
    dt->adat=(double*) malloc(meret*sizeof(double));
    if (dt->adat==NULL)
        return 0;       // nem sikerült
    dt->meret=meret;
    return 1;           // sikerült
}

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

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

Persze, hogy ott jön létre, ahol definiáljuk. A fordító csak követi azt, amit beírtunk. Mivel az egyes helyeken megadott változók élettartama eltérő, ezért a definíció az élettartamot is meghatározza!

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 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.

int x=7;
char sz[15]="szöveg";
char *p;

int main() {
   p=sz;
   printf("Helló világ");
   
   return 0;
}

A globális változók a program futása alatt mindvégig léteznek.

Globális változónak számítanak a memóriakezelés szempontjából a függvények static kulcsszóval jelzett változói is. Azok is a globális memóriaterületen helyezkednek el, és léteznek akkor is, miután visszatérünk a függvényből.

void fv() {
   char sz[10]="HELLÓ";
   char *p="helló"; // !
}

int main() {
   int x=7;
   fv();
}

Hoppá! A char* p pointer által mutatott sztring a globális memóriaterületre került. Miért? Azért, mert a fordító csinálja, amit mondtunk. A p nevű lokális változó típusa char*, azaz a vermen létrehozott egy pointert. A sztring konstansok globális memóriaterületre kerülnek, ezért az a kisbetűs „helló” sztring oda került. Ezzel szemben az sz változó típusa char[15], vagyis egy karaktertömb. Mivel így definiáltuk, az egész nagybetűs „HELLÓ” a verembe került. A p pointernél azt mondtuk, hogy legyen egy pointer, ami arra a sztringre mutat. Az sz[] tömbnél pedig azt, hogy legyen egy tömb, aminek a tartalma az.

Emiatt egyébként a két tömb mérete eltérő! A névtelen tömb, amelyik a globális területen van (attól még, hogy van egy pointer, amelyik mutat rá, névtelen!), egy hat karakterből álló tömb, hiszen öt plusz egy lezáró nulla. Az sz[] tömb ezzel szemben tíz karakterből áll, mert akkorának definiáltuk.

A veremben a fehér színű terület tartozik a main() függvényhez, a szürke színű pedig az fv() függvényhez. Ha az fv() függvény visszatér, a szürke színű rész változói eltűnnek. Így a veremben lévő adatok mennyisége folyamatosan változik a függvényhívások és visszatérések során. Az „örökké” létező globális változókkal szemben ezek csak addig léteznek, amíg a függvény belsejében vagyunk. Ugyanazon függvény újbóli meghívása esetén újra létrejönnek, újra inicializálódnak (ha van megadva kezdeti érték) – tulajdonképpen azok már másik változók.

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

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

Ezért nézzük a sztring méretét az strlen() függvénnyel! A sizeof a tömb vagy a pointer méretét adja.

Az utolsó sorban a pointer mérete látszik – ez géptípusonként más.

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

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

int *ptr=fv();

Ezt sem biztos, hogy észrevesszük tesztelésnél. Az adott memóriaterületen később még lehet, hogy ott lesz az érték, amire számítunk, és akkor látszólag a program helyes. Némely fordítók szerencsére néha felfedezik ezt a hibát. Pl. a gcc kimenete a fenti példára:

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

Ugyanezért hibás a következő beolvas() függvény is. A tömb a veremben van, és megszűnik, ha visszatérünk a függvényből, hiába olvastunk be akármit a billentyűzetről:

char *beolvas(void)
{
   char s[200];
   fgets(s, 200, stdin);
   return s; // hibás!!!
}

Ezek nagyon súlyos programozási hibák.

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 21 00 00 00 00   hexdump!....

Összetett deklarációt alkotunk akkor is, amikor sztringek tömbjét hozzuk létre. Ha egy sztring 12 bájtból áll: char sztring[12], akkor a sztringek tömbje valami olyasmi kell legyen, amit ha megindexelünk, akkor egy 12 bájtos karaktertömböt kapunk: char sztringek[3][12]. Természetesen az első indexeléssel a sztringet választjuk ki ebből, egy második indexelés adná a karaktert; ezért a deklarációban az első méret a sztringek száma, a második pedig a sztringek mérete.

A típust lépésenként is megadhatjuk a typedef kulcsszó használatával:

typedef char Sztring[12];
typedef Sztring SztringTomb[3];

SztringTomb sztringek;

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

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, 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); // fv(double**, int, int)

/* felszabadítás */
for (y=0; y<magassag; ++y)       // ahány malloc, annyi free
   free(szamok[y]);
free(szamok);                    // ezt legutoljára

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); // fv(double**, int, int)

/* felszabadítás */
free(szamok[0]);                 // ahány malloc, annyi free
free(szamok);