Tömb (adatszerkezet)
A tömb talán a legtöbb programozási nyelv által támogatott adatszerkezet. Alapesetben a tömb azonos (bázis) típusú elemek egy sorozatának tekinthető, aminek elemeit a sorszámukon (index) keresztül érhetjük el. A tömb mérete lehet előre - fordítási időben - rögzített (statikus), vagy futás közben változtatható (dinamikus). Ha a tömbelemek nem egy, hanem több - egymástól független - index megadásával címezhetők meg, akkor több dimenziós tömbről beszélünk, amely végső soron tömbök tömbjeinek is felfogható. Az egydimenziós tömböt vektornak, a kétdimenziós tömböt mátrixnak is nevezik. A programozási nyelvekben a tömbindexelést (tömb elemére hivatkozást) általában szögletes - ritkábban gömbölyű - zárójellel jelölik.
Példák[szerkesztés]
C / C++[szerkesztés]
A számozás nullától kezdődik.
Példakód statikus tömbre:
char arr[20];
arr[17]='t';
Dinamikus tömb:
#include <vector>
// üres tömb
std::vector<int> a;
// az 'a' tömb végére szúr egy 5-ös értéket
a.push_back(5);
// most még egy 42-t is, most tehát (5,42) a tartalma.
a.push_back(42);
// törli a 0. indexű (első) elemet, az 5-öst
a.erase(a.begin()+0);
// a méret most 1, az egyetlen elem pedig a 42
std::cout << a.size() << " " << a[0] << std::endl;
// 12 elemű tömb, minden eleme 0
std::vector<int> b(12);
// 42 elemű tömb, minden eleme 1.7
std::vector<double> c(42,1.7);
Java[szerkesztés]
A számozás nullától kezdődik.
Példakód statikus tömbre:
String [] arr = { "a", "b", "c" };
arr[2] = arr[1].concat("d");
JavaScript[szerkesztés]
A számozás nullától kezdődik.
Példakód statikus tömbre:
arr = new Array(1,'a',true);
arr2 = [1,'a',true];
Pascal[szerkesztés]
A Pascal nyelv jellegzetessége, hogy a tömb indexe egy meghatározott sorszámozott (enumerated) típus értékkészletéből vehet fel értékeket. Szokványos esetekben ez egy egész érték, és az értékkészletet az egész számok egy tartományaként adjuk meg a deklaráció során. Ebből következik, hogy az index akár negatív is lehet!
Egyszerű példakód egy egész indexű statikus tömbre:
Program tomb;
Var t:array[1..5]Of Byte;{egy egydimenziós tömb deklarálása}
i:Byte;{index változó}
Begin
{a tömb bejárása lehetséges cikluson keresztül,
vagy közvetlenül.}
{For ciklus segítségével}
For i:=1 to 5 Do Begin
Write(i,'. elem erteke: ');
ReadLn(t[i]);
End;
{közvetlen hozzáférés}
WriteLn('A tomb 4. eleme: ',t[4]);
End.
A fentieknél azonban sokkal összetettebb, a feladathoz jobban illeszkedő, ám a hagyományos - csupán egész indexű - tömbszemlélettel nehezen érthető tömböket is definiálhatunk. A Pascal-ban ugyanis a tömb deklarációja során az indexet sorszámozott típusként(!) definiáljuk, vagy a sorszámozott típus nevét megadva, vagy pedig a típus leírását feltüntetve. Ez utóbbi kétféle lehet:
- Intervallum (résztartomány) típus az egész illetve karakteres értékekből, pl.
1..90 {lottószámok}
-273..1000 {hőmérsékletek az abszolút 0 foktól}
'A'..'Z' {ASCII nagybetűk}
- Felsorolt típusok. Ezek a többi típussal nem kombinálható értékeket képviselnek, melyeket a fordító általában 0-tól kezdődő és egyesével növekvő értékként tárol a programban. Pl.
(alma, korte, szilva) {gyümölcsök}
(jan, feb, mar, apr, maj, jun, jul, aug, szep, okt, nov, dec) {hónapok}
(HighLevel, LowLevel, ThreeState) {TTL logikai kimenetek állapotai}
A fentieket mind szerepeltethetjük a tömb deklarációjában a szögletes zárójelek között, vagy pedig neveket adhatunk nekik a Pascal típudefiníciós részében, és a típusleírás helyett ezt a nevet tüntejük fel. A Pascal valójában az egész típusokat (ShortInt, Byte, Integer, Word) és a karakteres (Char) típust résztartományként, illetve a Boolean típust felsoroltként előre definiálja az alábbi módokon (Turbo Pascal System Unit-ja):
type
ShortInt = -128..127;
Byte = 0..255;
Integer = -32768..32767;
Word = 0..65535;
Char = #0..#255; {karakteres konstansok}
Boolean = (false, true);
Így az alábbi tömbdeklarációk mind megengedettek:
type {itt definiálunk néhány típust a fentiekből}
Lotto = 1..90;
Honap = (jan, feb, mar, apr, maj, jun, jul, aug, szep, okt, nov, dec);
Kimenet = (HighLevel, LowLevel, ThreeState);
var {változókat deklarálunk}
HanyszorHuztak : array[Lotto] of Word;
HaviAtlag : array[Honap] of Real;
Fajsuly : array[-273..1000] of Double;
Beirhato : array['A'..'Z'] of Boolean;
Impedance : array[Kimenet] of Real;
MikorErik : array[(alma, korte, szilva)] of Honap;
BUFF : array[Byte] of Byte; {256 bájtos puffer}
EBCDIC : array[Char] of Byte; {kódkonverziós táblához}
Magyarul : array[Boolean] of String; {a logikai értékek magyar nevét tárolhatjuk benne}
PHP[szerkesztés]
Ha a PHP tömbjeit hagyományos tömbként használjuk, az index számozása nullától kezdődik.
Példakód:
$arr = array("alpha","beta");
echo $arr[1]; // beta
A PHP-ban azonban a tömbök rendezett leképzéseket valósítanak meg, ahol is kulcsokhoz értékeket rendelünk. A kulcsokat indexként adjuk meg, és egész értékek mellet bármilyen más adattípus, tehát string is lehet. Egy tömbön belül a tömbelemek értékei - a hagyományos tömböktől eltérően - szintén tetszőleges típusúak lehetnek, és a program futása során a típus is megváltozhat. Az egésztől eltérő kulcsokat már a tömb definíciójánál is megadjuk, és ha a tömbelem értékadásában eddig még nem szerepelt kulcs jelenik meg, akkor a tömb kiegészül egy új elemmel:
$tomb = array("egy" => "Kati", "ketto" => "Pisti", "harom" => "Zoli");
echo $tomb["harom"]; // Zoli
$tomb["harom"]=15.6;
$tomb["tiz"]=84.3;
echo $tomb["harom"]; // 15.6
echo $tomb["tiz"]; // 84.3
Python[szerkesztés]
A Python terminológia szerint list (lista), dict (asszociatív tömb, szótár) és tuple (módosíthatatlan lista) típusok léteznek. Mivel nem kell definiálni a bennük szereplő adatok típusát, ezért int,float,string típusokat felváltva írhatunk bele. Sőt még összetett típusokat (list, dict, tuple, complex) is.
Példakód:
a = ["alpha","beta"] # üres lista is létrehozható, a = [] szintaktikával
a.append(45) # bővítés int típussal
a.append(45.) # bővítés float típussal
a.append("gamma") # bővítés stringgel
b = {"alma":"piros", "banan":"sarga"} # asszociatív tömb, üresen deklarálva b = {} lenne
a.append(b) # ekkor a lista N. eleme egy asszociatív tömb, ami tovább indexelhető a kulcsával.
print b["banan"]
print a[5]["banan"] # épp az 5. elemre esik az asszociatív tömb a fenti bővítések okán.
a.append(21 + 43j) # komplex számot is tárolhatunk.
print a.pop() # utolsó elem kiemelése és eltávolitása, stack
print a.pop(0) # első elem kiemelése és eltávolítása, fifo
c = (4, 5, "alma") # int,int,string értékeket felvevő módosíthatatlan lista, melynek neve tuple.
VB6/VBA[szerkesztés]
Példakód statikus tömbre:
' Option base 0 esetén
Dim arr(2)
arr(0) = 1
arr(1) = Date
arr(2) = "Helló világ"
'
Dim arr2(2 To 3)
arr2(2) = 1
arr2(3) = Time
'
Dim arr3
arr3 = Array(1, Date, "Helló")
'
Dim arr4()
ReDim arr4(1) 'Kitörölve a tartalmat, ha lenne
arr4(0) = 0
arr4(1) = Time
ReDim Preserve arr4(2) ' Megtartva az eddigi tartalmat
arr4(1) = "Helló"
'
Dim arr5(0)
arr5(0) = Array(Date, Time)
arr5(0)(0) = ""
arr5(0)(1) = Now()
Go[szerkesztés]
A számozás nullától kezdődik.
var arr [5]int
vagy
arr := make([]int,5)
vagy
arr := []int{1,2,3,4,5}
Nem szám típussal indexelt tömböket(map-ek), a 'map' nyelvi elem segítségével valósíthatunk meg.
arr2 := map[string]int{"str1":1,"str2":2,"str3":3 ... }
egyszerű kiiratás:
fmt.Printf("%v\n",arr) // teljes tomb
fmt.Printf("%v\n",arr[2:3]) // {3,4}
elemenkénti feldolgozás:
for i,v := range arr2 {
fmt.Println("%s: %d\n",i,v)
}