fel
le

Vektorok

Gyakori eset, hogy programunk nem néhány, hanem nagyon sok adattal kell dolgozzon. Minden egyes adat számára deklarálhatunk változót is, de ez esetben minden egyes változónak saját nevet kell kitalálni, mely kényelmetlen is lehet. Valamint egyes algoritmusok alkalmazása igényli a "minden adat" típusú műveletvégzést, amikor is minden adatelemet elő kell venni, megvizsgálni, gyakran módosítani is az értékét. Ha minden adatelemünknek más-más változója van, melyeknek más-más a nevük, úgy az összes adatelem elérése túl bonyolult és áttekinthetetlen kódot eredményezne.

Ilyen esetekben vektorokat használunk. A vektor olyan változónak tekinthető, mely nem egyetlen, de sok, több érték tárolására képes egy időben. A vektor a tömb típuscsoport tagja, s mint minden tömb, az alábbiak jellemzik:

  • összetett adattípus, vagyis egyetlen vektor típusú változó egy időben több értéket is képes tárolni,
  • homogén, vagyis minden egyes tárolt érték ugyanolyan alaptípusba tartozik, ezt a vektor létrehozásakor meg kell adni
  • random elérésű, vagyis bármely tárolt érték kiolvasása vagy módosítása ugyanannyi ideig tart
  • fix méretű, vagyis a vektorok létrehozásakor meg kell adni hány értéket kívánunk tárolni majd benne, és ez a darabszám később nem változhat meg
  • folytonos tárolású, vagyis a vektorban tárolt értékek a memória egy folytonos területén, egymás mögött elhelyezkedve

Egyszerű vektorok

int a = 12;
int[] t;
t  = new int[20];
 

Ebben a kódrészletben deklarált a változóról tudjuk, hogy egyetlen int típusú értéket képes tárolni. A kezdőértékadás során ezt az értéket be is állítjuk 12-re. Az alatta szereplő t nevű változó típusa már nem egyszerű int, hanem int alaptípusból felépített vektor. Ezt jelöli a szögletes zárójelpár az int alaptípusnév mögött. Figyeljük meg, hogy még nem adtuk meg, hány elemet fogunk tárolni, csak hogy több int tárolása következik.

A vektor memóriaigénye a benne tárolt értékek alaptípusától, és darabszámától függ. A fenti esetben 20 db int tárolására készülünk, melynek memóriaigénye 20*4=80 byte. A memória lefoglalásáról ez esetben külön kell gondoskodnunk, a new utasítás segítségével. A new önnmagában nem fogja kitalálni a 80 byte helyigényt, ezért a new kulcsszó után újrab meg kell adni a számításhoz szükséges információkat. Ezért kell megadni újra hogy int alaptípusú a vektor, és hogy 20 elem tárolását tervezzük. Ez már szintaktikai részletkérdés, hogy ezt int[20] formában kell leírni.

Gyakori, hogy a vektorváltozó deklarációját, és a tényleges helyfoglalási részt összevonjuk a kezdőértékadás segítségével:

int[] t  = new int[20];
 

Valamint megoldható, hogy a vektor méretét nem tartalmazza a program ilyen konkrét módon, hanem akár futás közben derül ki:

Console.Write("Hány adatról van szó:");
int n = int.Parse(Console.ReadLine());
//
int[] t  = new int[n];
 

Az alábbi módon deklarált jegyek vektor így néz ki a memóriában:

int[] jegyek  = new int[35];
 
1. ábra: Vektor elhelyezkedése a memóriában

Elemek kezelése

A példában szereplő t vektor egy időben 20 darab int tárolására képes. Egy időben csak egy értékkel dolgozhatunk, mindíg meg kell mondani, hogy a 20 közül épp melyikkel. Ezt a t után szögletes zárójelbe írt sorszámmal tehetjük meg. A 20 darab elem egyedi sorszámokkal rendelkezik, 0..19 között (ez éppen 20 darab sorszám). A vektorbeli elemek sorszáma mindig 0-val kezdődik. A kezelés valami ilyen módon képzelhető el:

t[0] = 12;
t[1] = t[0]+10;
 

Ami a vektorok erőssége, hogy az elemek indexének meghatározása is történhet változókban tárolt értékek alapján. Az alábbi programkód a vektor minden elemét megduplázza:

int i=0;
while(i<20)
{
  t[i] = t[i] * 2;
  i++;
}
 

Ügyeljünk a ciklus tervezésére, az első futás alkalmával t[0]-ra kell hivatkozni a ciklusmagban, így az i értéke első menetben legyen 0. Az i értékét csak a ciklusmag végén növeljük, nehogy elromoljon. És ne engedjük a ciklust csak i=19-re lefutni utoljára, hiszen a legutolsó vektorelem sorszáma 19. Ezért i<20 vagy i<=19 legyen a vezérlő feltétel (utóbbi ellenjavallat).

A vektorok tárolják saját magukról az elemszámot. Ezt a .Length tulajdonsággal lehet elérni (ebben a példában ez a 20 értéket képviseli). Ennek megfelelően a fenti ciklus ehhez hasonlóan is megfogalmazható:

int i=0;
while(i<t.Length)
{
  t[i] = t[i] * 2;
  i++;
}
 
Hernyák Zoltán
2013-01-24 10:48:18