TÖMBÖK 2009. 10. 09 – péntek Jordán Sándor

Találkoztunk már olyan feladattal, amelyben sok értékkel kellett dolgoznunk. Például: beolvasok a bementről (fájlból) számokat, majd megvizsgálom, hogy valamelyikük 7-e. Hogy is festett ez?

i:=0 CIKLUS Amíg i<10. BE: x. HA x=7 AKKOR i:=0 CIKLUS Amíg i<10 BE: x HA x=7 AKKOR KI: „Találtam 7-es számot!”, SV HA_VÉGE i:=i+1 CIKLUS_VÉGE

Ezzel akadnak bizonyos problémák Ezzel akadnak bizonyos problémák! Addig rendben van, hogy megkeresek benne egy 7-es számot … … de mi van, ha meg szeretném mondani, hogy mi volt az 7-es előtt? Tároljam el még egy változóban az előtte lévőket? És ha az az előttit is vissza szeretném kapni … és az azelőttit … stb?

Tehát ott tartunk, hogy legyen annyi változónk mint beolvasandó számunk … … rendben, de ez meg olvashatatlanná teszi a kódot, valamint a ciklusunkat így jó pár elágazással is pluszban megtoldja. Konklúzió: ezt a megoldást el is felejthetjük.

Ott tartunk, hogy nagy mennyiségű adatot szeretnénk tárolni, esetleg 1000 darabot is, de nem szeretnénk 1000 változót … … sőt, mi egyet szeretnénk csak! Hasonló megoldással találkozhattunk már Plangos pályafutásunk alatt. Közvetlenül nem köszönt vissza, hogy ő egy „valami”, ami sok dolgot tárol, de a dolga ez volt. Hol lehetett ilyen?

Láttuk, hogy a SZÖVEG típusú változó, az egy olyan „valami”, ami sok KARAKTER-t tárol. Egy SZÖVEG karaktereit mindig el tudtuk érni, egy futás alatt számtalanszor is. Tehát sok változót tárol egy változóban, és bármikor elérhetjük azokat. Hogy is nézett ki a SZÖVEG kezelése?

PROGRAM tutorial VÁLTOZÓK: sz: SZÖVEG sz := "" PROGRAM tutorial VÁLTOZÓK: sz: SZÖVEG sz := "" ** üres szöveg létrehozása sz := sz + 'b‘ ** érték belerakása KI: sz PROGRAM_VÉGE

Menjünk ennél egy kicsit tovább, hisz attól, hogy van egy rakás adatom egy helyen és ki tudom onnan őket nyerni, azzal csak félig vagyok meg, hisz ezeket az adatokat valahogy módosítanom is kellene alkalom adtán. Nézzük meg azt, hogy egy-egy elem módosítására képes-e a SZÖVEG? Egyszerűbben: karaktereket szeretnék változtatni.

PROGRAM tutorial VÁLTOZÓK: sz: SZÖVEG sz := "" sz := sz + 'b' KI: sz, SV ** itt b lesz az eredmény sz[0] := 'a‘ ** az első!!! Elem ‘a’ lesz KI: sz ** itt b lesz az eredmény PROGRAM_VÉGE

Foglaljuk össze milyen tulajdonságokat láttunk amikre nekünk szükségünk van: - Sok változó egy helyen - Folyamatosan elérem minden tagját - Folyamatosan felül írhatom minden tagját Mellék tulajdonság: CSAK EGY FÉLE VÁLTOZÓ LEHET BENNE!!!

CSAK EGY FÉLE VÁLTOZÓ LEHET BENNE. Tehát olyan, mint egy almás rekesz CSAK EGY FÉLE VÁLTOZÓ LEHET BENNE!!! Tehát olyan, mint egy almás rekesz. Szeretjük, ha az üzletbe, szépen minden alma egy rekeszben van, szépen sorban, mert így bármelyiket el tudjuk venni. DE kiakadunk ha körtét találunk benne … pont mint a Plang 

- Sok változó egy helyen - Folyamatosan elérem minden tagját - Folyamatosan felül írhatom minden tagját CSAK EGY FÉLE VÁLTOZÓ LEHET BENNE!!!

Most már csak arra van szükségünk, hogy ne csak karaktereket tudjunk így tárolni, hanem bármit … EGÉSZ-et, LOGIKA-it, SZÖVEG-et … stb Erre való nekünk a TÖMB

A tömb pontosan olyan változó mint a szöveg, egész, valós, logikai … stb Éppen ezért használat előtt deklarálni kell a változók között, épp úgy mint bármely más mezei típust. A deklaráció így fest: a: EGÉSZ[10]

Tehát nem az történt amire számítottunk … nem így festett a deklaráció: a: TÖMB Tehát az hogy EGÉSZ[10] valami plusz információt szolgáltat a Planganak, de ezek számunkra mit jelentenek?

Az első probléma: miért írok én a kettőspont után ilyet, hogy EGÉSZ Az első probléma: miért írok én a kettőspont után ilyet, hogy EGÉSZ? (A választ ekkor kórusban zengi a csoport )

MERT CSAK EGY FÉLE VÁLTOZÓ LEHET A TÖMBBEN MERT CSAK EGY FÉLE VÁLTOZÓ LEHET A TÖMBBEN!!! És ezt meg kell nekünk mondani, hogy mi is az.

Rendben, akkor már csak az nem világos, hogy mi az a [10] … … Plangban meg kell előre mondani, hogy mekkora TÖMB-öt kérek a programtól. Ugyebár a túl nagy helyet kérnék, akkor a memóriát foglalnám feleslegesen, ha meg túl keveset, akkor nem lenne elég hely a változóimnak.

Felmerülhet az az igény, hogy miért nem lehet akármekkora TÖMB-be egyfolytában pakolni az elemeket . Így teljesüljön minden kívánságunk … a C++ majd lehetőséget ad erre Tehát Plangban muszály előre megmondani, hogy mekkora tömböt kérünk.

Hozzunk létre egy 3 férőhelyes TÖMB-öt, ami EGÉSZ típusú változókat képes tárolni: a: EGÉSZ[3] [0] EGÉSZ szám lesz az érték --- [1] [2]

Tegyük a TÖMB első elemét egyenlővé 7-tel. a[0] := 7 EGÉSZ szám lesz az érték --- [1] [2]

Tegyük a TÖMB első elemét egyenlővé 7-tel. a[0] := 7 EGÉSZ szám lesz az érték Az értéke 7 [1] --- [2]

Most legyen a második érték 1138. a[1] := 1138 [0] EGÉSZ szám lesz az érték Az értéke 7 [1] --- [2]

Most legyen a második érték 1138. a[1] := 1138 [0] EGÉSZ szám lesz az érték Az értéke 7 [1] Az értéke 1138 [2] ---

Az utolsó érték pedig legyen 77525 a[2] := 77525 [0] EGÉSZ szám lesz az érték Az értéke 7 [1] Az értéke 1138 [2] ---

Az utolsó érték pedig legyen 77525 a[2] := 77525 [0] EGÉSZ szám lesz az érték Az értéke 7 [1] Az értéke 1138 [2] Az értéke 77525

Remélem mindenki észrevette, hogy a tömb ELSŐ elemére a [0] paraméterrel hivatkoztunk!!! Ugyebár a SZÖVEG adott sorszámú betűjének lekérdezésénél már találkoztunk az indexelés eme tulajdonságával. Tehát egy a nevű, n elemű tömb utolsó eleme a[n-1] !!

Mi van akkor ha létrehozunk egy új tömböt: Mi van akkor ha létrehozunk egy új tömböt: t: VALÓS[10] és rögtön ki szeretnénk íratni az első elemét: KI: t[0] HIBA!!!

A TÖMB méretét mi tudjuk, hisz mi adjuk meg, de szeretnénk, hogy a gép is tudja pontosan az elemek számát. Példa: fusson le egy ciklus annyiszor ahány eleme van egy tömbnek. Tehetnénk azt is, hogy egy másik EGÉSZ változóban eltároljuk a méretet, de ez nem célszerű, nem szép.

Helyette a TÖMB tudja saját maga méretet, ami le is kérdezhető Helyette a TÖMB tudja saját maga méretet, ami le is kérdezhető. t: KARAKTER[100] ki: |t| És a program kiírja a t tömb méretét. Azaz a abszolút érték jelbe rakva egy tömböt visszakapom a méretét.

Nézzünk egy példát arra, hogy mit tudunk csinálni az eddig tanultakkal.

Feladat: Generáljunk 50db véletlen számot 0-100 között, és ezeket tároljuk el egy TÖMB-ben.

PROGRAM tutorial VÁLTOZÓK: a: EGÉSZ[50], ** Létrehozunk egy 50 férőhelyes tömböt i: EGÉSZ ** Létrehozzuk a ciklusváltozót i := 0 ** Lenullázzuk a ciklusváltozót CIKLUS AMÍG (i < |a|) ** Amíg végig nem megyünk a tömbön a[i] := RND 100 ** ‘a’ aktuális eleme egy véelten szám i := i + 1 ** Léptetjük a ciklusváltozót CIKLUS_VÉGE PROGRAM_VÉGE

Észrevehető, hogy az eddig bemutatott tömbök nem voltak mások mint vektorok, azaz egy dimenziósok voltak. Ha nem vektort, hanem mátrixot szeretnénk eltárolni egy tömbben, akkor erre létrehozhatunk egy többdimenziós tömböt is. t: egész[10] [10]

Ha egy kicsit átgondoljuk a dolgokat, akkor arra jutunk, hogy az előbb bemutatott deklarációnál létrehoztunk egy 10 elemű tömböt ami 10 elemű tömböket tárol! Hiszen azt mondtuk, hogy a tömb bármely típust képes lesz tárolni … akár tömb típusút is, mint láttuk. t: egész[10] [10]

Az előbbieket figyelembe véve, mennyi elemet tudunk eltárolni az alábbi tömbben? t: egész[10] [10] 10 db*10 db = 100 db

Ez a dimenzió növelés elviekben bármeddig folytatódhat, azaz értelme van ezt „mondani” a Plangnak: t: VALÓS [10] [7] [30] [2] Ekkor elemeinek száma: 10*7*30*2

Lássunk még egy példa feladatot az önálló munka előtt: Feladat: Olvassunk be 10 számot a bementről és tároljuk el őket egy TÖMB-ben, majd számoljuk ki az átlagukat.

PROGRAM össszead_tömb. VÁLTOZÓK:. t: VALÓS[10],. s: VALÓS,. i: EGÉSZ PROGRAM össszead_tömb VÁLTOZÓK: t: VALÓS[10], s: VALÓS, i: EGÉSZ i := 0 s := 0 CIKLUS AMÍG (i < |t|) BE: t[i] s := s+ t[i] i := i+ 1 CIKLUS_VÉGE KI: ”A számok átlaga: ”, s / 10 PROGRAM_VÉGE

Összefoglaló: Dekalráció: t= EGÉSZ [10] , g=LOGIKAI [3] [5] Műveletek: t[0] => t első eleme n:= |t| => n a tömb mérete lesz t[n-1] => t utolsó eleme t[5]:= 7 => a tömb 6-dik eleme 7 t[7]:= t[8] + t[9] => értékadás