A tömböket gyakran ideiglenes tárolónak használjuk, és elég gyakori az is,
hogy bár fordítási időben nem, de futási időben előre ismerjük a létrehozandó
tömb méretét. A C99 megengedi azt, hogy a veremben létrehozott tömböknél futási
időben kiértékelődő kifejezéssel adjuk meg a tömb méretét. Az ilyen tömböket a
szabvány VLA-nak nevezi (variable length array). (Vigyázat: bár a lenti
kódrészletet a legtöbb C++ fordító megérti és lefordítja, a C++ szabvány semelyik
változata szerint sem elfogadott! A C++-ban ilyen célra egy
std::vector<int>-et kell használni.)
int n;
printf("Hány szám lesz?\n");
scanf("%d", &n); /* garantáltan futási időben :) */
int arr[n];Az ehhez hasonló kódrészletek támogatása szinte elvárásunk lehet azután, hogy
a C99-ben megengedték a változódefiníciók és az utasítások keverését (mixed
declarations and code), vagyis hogy elengedték azt a megkötést, hogy az
utasításblokkok tetején kell megadni a változókat. Az eszköz használatát senkinek
nem kell bemutatni, mert tudjuk, ahol választhatunk a dinamikus (kézi) és az
automatikus memóriakezelés között, ott mindig az utóbbit célszerű választani. Az
így létrehozott tömbök egyébként teljesen ugyanúgy viselkednek, mint a
konstanssal megadott méretű társaik; még a sizeof operátor is
működik rajtuk. Azért sokat ne várjuk, az ilyen tömbök nem méreteződnek át
mágikusan: minden VLA akkora marad megszűntéig, amekkora a létrehozása
pillanatában volt.
for (int i = 0; i != 10; ++i) {
int arr[rand() % 10 + 10];
printf("Most %d eleme lett.\n", (int) (sizeof(arr)/sizeof(arr[0])));
}A VLA-k mögött azonban több van, mint elsőre gondolnánk. Egy programozási nyelvnél nem „csak úgy” megy, hogy behozunk egy újfajta nyelvi elemet egy probléma megoldására és kész: gyakran helyette inkább olyan lehetőségeket kell a nyelvbe építeni, amiből már következik, hogy az áhított kódrészlet leírható.
Gondoljunk például a printf()-re. A Pascal writeln() eljárása tetszőlegesen sok
paramétert kaphat, mindegyiket kiírja a kimenetre. A C printf()-je ugyanerre képes. Azonban a Pascal writeln()
eljárása egy különleges, egyedi nyelvi elem; a programozó nem tud olyan saját függvényeket írni, amelyek akárhány
paramétert kaphatnak. C-ben a printf() nem nyelvi elem, hanem egy szokványos függvény. Helyette a ...-tal
jelölt, változó hosszúságú paraméterlista a nyelvi elem. Így C-ben tetszőlegesen írhatunk saját függvényeket is, amelyek bárhány
paramétert kaphatnak.
Lássuk, miről van szó! A C89-ben semmilyen körülmények között nem lehetett leírni olyan kódot, amelyben egy típus mérete
nem fordítási idejű konstans. Vagyis nem csak az int arr[n]; változódefiníció volt hibás, hanem helytelen
volt a triviálisnak tűnő sizeof(int[n]) kifejezés is. A C99-ben pedig ezen változtattak. Az új verzió azt engedi
meg, hogy egy lokális változó, tömb típus elemszámát egy kifejezés adja meg. Mivel egy ilyen típusnak a méretét már ki is tudja
számolni, ezért megengedi azt is, hogy a veremben ilyen típusú változót hozzunk létre. Emiatt szabad leírnunk az alábbi sorokat:
int n;
scanf("%d", &n);
int *my_heap_arr = (int*) malloc(sizeof(int[n]));
int my_stack_arr[n];A dolog onnantól válik izgalmassá, ha nem csak egy, hanem több dimenziós tömbökkel is dolgozunk. Ugyanis ezek összes dimenzióját megadhatjuk kifejezéssel. Ami önmagában megint triviálisnak hangzik, de a fordítónak meg kell oldania azt, hogy akárhány változó méretű dimenzió szerint lehessen indexelni. Ehhez pedig az kellett, hogy olyan pointert is lehessen létrehozni, amelynek típusa kifejezések értékeitől függ. Mert ha egy 20×10-es tömb egyes soraira mutató pointer „10 elemű tömbökre mutató pointer” típusú, akkor egy m×n-es tömb soraira mutató pointer „n elemű tömbökre mutató pointer” kell legyen:
int arr1[20][10];
int (*parr1)[10];
parr1 = arr1;int arr2[m][n];
int (*parr2)[n];
parr2 = arr2;A méretinformációra mindenképpen szükség van a pointer típusában, mert egy cím számításakor (pointer aritmetika), azaz pl. a
parr1+1 kifejezés kiértékelésekor tudnia kell a fordítónak, hány bájtot kell ugrani a memóriában. A parr1+1
kifejezésnél sizeof(int[10])-et, mivel *parr1 típusa int[10]; a parr2+1 esetén
pedig sizeof(int[n])-t, mivel *parr2 típusa int[n].
Egy VLA-ra mutató pointer azért hasznos, mert így egy ilyen tömböt át tudunk adni függvénynek is paraméterként. Ehhez csak egy megfelelő függvénydefiníció kell, amelynél a függvény fejlécében jelezzük azt, hogyan függ a paraméterektől a pointer típusa. Az egyedüli korlátozás, hogy a méretet megadó paramétert előbb kell szerepeltetni, mint a pointert. Mire a pointer deklarációjával találkozik a fordító, addigra a méretet megadó kifejezés változói már ismertek kell legyenek:
/* deklaráció */
void print(int, int, char (*)[*]);
/* definíció */
void print(int height, int width, char (*arr)[width]) {
for (int y = 0; y != height; ++y) {
for (int x = 0; x != width; ++x)
putchar(arr[y][x]);
putchar('\n');
}
}A függvény definíciója a formális paraméterek neveit is tartalmazza. Ha csak deklarációt adunk meg, a nevek szerepeltetése
nem kötelező; a kifejezéssel megadott pointer típusú paramétereknél is elhagyható a név. Mivel azonban a deklarációban
char(*)[]-ot nem írhatunk (definiálatlan méretű tömb továbbra sem létezik!), valahogy jelölni kell azt, hogy a
méret is meg lesz adva. Ezt a deklarációban a tömb mérete helyére beírt * karakterrel tudjuk megtenni. Vagyis a
fenti függvénydeklaráció valami ilyesmit jelent: „A függvény vár két int típusú értéket és egy pointert. A pointer
char[] tömbökre mutat, amelyek méretét a függvény majd valahonnan tudni fogja.” Hogy honnan tudja, az pedig már a
függvény dolga, és azt a definíció adja meg.
Talán mégis a legjobb, ha inkább a deklarációkba is beírjuk a változók nevét, és kifejezzük azt, hogy mi mitől függ, hiszen ez a függvény használóit segíti. De ne feledjük, a tömbök helyett mindig az első elemükre mutató pointerek adódnak át paraméterként! Ezért az összes alábbi deklaráció egyenértékű:
void print(int height, int width, char arr[height][width]);
void print(int height, int width, char arr[*][width]);
void print(int height, int width, char arr[*][*]);
void print(int height, int width, char (*arr)[width]);
void print(int height, int width, char (*arr)[*]);
void print(int, int, char (*)[*]);Az így átadott tömbnek egyébként nem kell feltétlenül VLA-nak lennie, hanem lehet konstans méretű tömb is. A C99 nyelv a változóval megadott típusú pointer által képessé vált arra is, hogy tetszőleges méretű (szélességű és magasságú) kétdimenziós tömböt adjon át függvényparaméterként.
#include <stdio.h>
#include <stdlib.h>
void print(int height, int width, char arr[height][width]) {
for (int y = 0; y != height; ++y) {
for (int x = 0; x != width; ++x)
putchar(arr[y][x]);
putchar('\n');
}
}
int main(void) {
char man[4][3] = {
{ ' ', 'o', '/' },
{ '/', '|', ' ' },
{ ' ', '|', ' ' },
{ '/', ' ', '\\' },
};
char diamond[2][2] = {
{ '/', '\\' },
{ '\\', '/' },
};
print(4, 3, man);
printf("\n");
print(2, 2, diamond);
}változata sem támogatja!
Van helyette std::vector.
int n;
printf("Hány szám lesz?\n");
scanf("%d", &n); /* garantáltan */
int arr[n]; /* futási időben :) */A stack-en jön létre, még a sizeof operátor is működik rajta:
for (int i = 0; i != 10; ++i) {
int arr[rand() % 10 + 10];
printf("Most %d eleme lett.\n", (int) ( sizeof(arr) /
sizeof(arr[0]) ));
}