static array

Angol

Főnév

static array (tsz. static arrays)

(informatika) A statikus tömb C++-ban egy olyan adatszerkezet, amely egy fix méretű, egységes típusú elemekből álló sorozatot tartalmaz. A mérete a fordítás idején ismert, és a memóriában egy összefüggő blokkban van tárolva. A “statikus” szó ebben a kontextusban nem feltétlenül a static kulcsszóra utal (bár azzal is kombinálható), hanem arra, hogy a méret és a memóriafoglalás nem változik futás közben.

Szintaxis

T típusú_tömb_neve[méret];

T típusú: az elemek típusa (pl. int, double, char, stb.)
méret: pozitív egész szám, amely megadja a tömb méretét

Példa

int szamok[5];  // 5 elemű egész számokat tároló tömb

Inicializálás

A tömb elemei inicializálhatók deklaráláskor:

int szamok[5] = {1, 2, 3, 4, 5};

Ha kevesebb értéket adunk meg, mint a tömb mérete, a maradék elemek 0-ra (alapértelmezett értékre) lesznek inicializálva:

int szamok[5] = {1, 2};  // szamok[2]..szamok[4] = 0

Ha a méretet nem adjuk meg explicit, a fordító azt az initializer listából származtatja:

int szamok[] = {1, 2, 3, 4, 5};  // automatikusan 5 elemű lesz

Memóriafoglalás

A statikus tömb stack-en (veremmemóriában) kerül lefoglalásra (ha nem használjuk a static kulcsszót).

Ha static kulcsszóval deklaráljuk, akkor a tömb data segment-ben (adat szegmens) vagy BSS szegmensben helyezkedik el, és a program teljes élettartama alatt létezik.

Példa:

static int szamok[5];  // program teljes futása alatt létezni fog

Elem elérés

A tömb elemei indexeléssel érhetők el, nullától kezdődően:

szamok[0] = 10;
int x = szamok[2];

Fontos: nincs automatikus bounds checking (határvizsgálat). Ha szamok[5]-öt próbálsz elérni, az undefined behavior (nem definiált viselkedés).

Iterálás tömb felett

For ciklussal:

for (int i = 0; i < 5; i++) {
    std::cout << szamok[i] << std::endl;
}

Range-based for ciklussal (C++11-től):

for (int ertek : szamok) {
    std::cout << ertek << std::endl;
}

Statikus tömb méretének meghatározása

A tömb méretét (elem számát) fordítási időben ki tudjuk számolni:

int meret = sizeof(szamok) / sizeof(szamok[0]);

sizeof(szamok) → az egész tömb bájtban mért mérete
sizeof(szamok[0]) → egyetlen elem bájtban mért mérete
az osztás eredménye: hány elem van a tömbben

Statikus vs dinamikus tömb

Statikus tömb	Dinamikus tömb (pl. `new` vagy `std::vector`)
Mérete fix (fordítási időben ismert)	Mérete futásidőben is változhat
Stack-en vagy data segment-ben tárolódik	Heap-en tárolódik
Gyors allokáció, kis overhead	Lassabb allokáció, nagyobb overhead
Nincs bounds checking	Pl. `std::vector` esetén van (opcionális)

Használati esetek

Statikus tömböt általában akkor használunk, ha:

A tömb mérete ismert a fordítás idején
Fix méretű adathalmazt akarunk reprezentálni
Nagy teljesítmény a cél (stack nagyon gyors)

Példák:

lookup table (pl. szinuszértékek előre kiszámítva)
napok nevei:

const char* napok[] = {"Hetfo", "Kedd", "Szerda", "Csutortok", "Pentek", "Szombat", "Vasarnap"};

Többdimenziós statikus tömbök

C++-ban statikus tömb lehet többdimenziós is.

Példa 2D tömbre:

int matrix[3][4];  // 3 sor, 4 oszlop

Inicializálás:

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

Elem elérés:

matrix[1][2] = 42;  // 2. sor 3. elem

Iterálás:

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        std::cout << matrix[i][j] << " ";
    }
    std::cout << std::endl;
}

A `static` kulcsszó jelentése tömb esetén

Ha a tömböt függvényen belül static-ként deklaráljuk:

void f() {
    static int tomb[10];
}

A tomb nem a stacken, hanem a data segment-ben lesz.
Az értékei a függvényhívások között is megmaradnak.
Az első híváskor inicializálódik.

Példa:

void szamlalo() {
    static int count = 0;
    count++;
    std::cout << count << std::endl;
}

Tipikus hibák

Indexelési hiba:
- szamok[5] → nem létezik, mivel az indexelés 0..4-ig tart.
Elfelejtett inicializálás:
- Nem inicializált stack tömb tartalma random garbage.
Túl nagy stack tömb:
- Nagy méretű tömb stacken → stack overflow hibát okozhat.
Pl.:
```
int nagyTomb[10000000];  // veszélyes, inkább dinamikus tömb kellene
```

Statikus tömb + `std::array`

C++11-től a std::array az STL-ből egy jobb alternatíva statikus tömb helyett:

#include <array>

std::array<int, 5> szamok = {1, 2, 3, 4, 5};

Előnyök:

Mérete fordítási időben ismert, de típusként kezelhető
Van .size(), .at(), .begin(), .end(), stb.
Bounds checking .at() esetén

Összefoglalás

Előnyök	Hátrányok
Egyszerű, gyors	Méret fix
Stacken gyorsan elérhető	Bounds checking hiánya
Nagyon kis overhead	Nehézkes átadni függvényeknek (átalakul pointerré)
Könnyen inicializálható	Nagy tömb stack overflow-hoz vezethet

Mikor használd?

Ha kis méretű, fix méretű adathalmazt akarsz.
Ha a teljesítmény kulcsfontosságú.
Ha memóriahasználat determinisztikus kell legyen.

Ha flexibilitás kell → std::vector vagy std::array jobb választás.

További információk

static array - Szótár.net (en-hu)
static array - Sztaki (en-hu)
static array - Merriam–Webster
static array - Cambridge
static array - WordNet
static array - Яндекс (en-ru)
static array - Google (en-hu)
static array - Wikidata
static array - Wikipédia (angol)