array data structure

Angol

Főnév

array data structure (tsz. array data structures)

1. (informatika)

---

A tömb (array) egy azonos típusú elemekből álló adatszerkezet, amely lehetővé teszi az elemek index alapján történő elérését. A C++ nyelvben a tömbök nagyon hasznosak az adatok tárolására és feldolgozására.

---

1. Mi az a tömb?

A tömb olyan folytonos memóriaterületen tárolt adatok halmaza, amelyben az elemek ugyanolyan típusúak és index alapján érhetők el.

Tömbök típusai C++-ban

1. Statikus tömbök (fix méretű, stack memóriában tárolva)
2. Dinamikus tömbök (heap memóriában tárolva)
3. STL konténerek (std::array, std::vector) – modern alternatívák

---

2. Statikus tömbök deklarálása és inicializálása

A statikus tömb mérete deklaráláskor rögzített, és nem változtatható futásidőben.

Alap szintaxis:

adatTípus tömbNév[méret];

Példa – Egész számok tömbje

#include <iostream>

int main() {
    int szamok[5] = {10, 20, 30, 40, 50};

    std::cout << "A tömb első eleme: " << szamok[0] << std::endl;
    std::cout << "A tömb második eleme: " << szamok[1] << std::endl;
    
    return 0;
}

Kimenet:

A tömb első eleme: 10
A tömb második eleme: 20

• Indexelés: A tömb első eleme szamok[0], a második szamok[1], stb.
• Zárójelek {} használhatók az inicializáláshoz.
• A tömb mérete rögzített (itt 5 elem).

Tömbök alapértelmezett inicializálása

• Ha egy tömböt részben inicializálunk, a hiányzó elemek nullára inicializálódnak:

int szamok[5] = {1, 2}; // A maradék elemek 0 lesznek

• Ha egy tömböt üresen deklarálunk, véletlenszerű értékek lesznek benne.

---

3. Tömb bejárása for ciklussal

A tömb elemeinek feldolgozására a for ciklus a leggyakoribb eszköz.

Példa – Kiírás egy for ciklussal

#include <iostream>

int main() {
    int szamok[5] = {10, 20, 30, 40, 50};

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

    return 0;
}

Kimenet:

szamok[0] = 10
szamok[1] = 20
szamok[2] = 30
szamok[3] = 40
szamok[4] = 50

• Index alapú elérés: szamok[i]
• A ciklus végigmegy az összes elemen

---

4. Tartomány alapú for ciklus tömbökkel

C++11-től kezdve egyszerűsített for ciklust használhatunk a tömbök bejárására.

Példa – Tartomány alapú for ciklus

#include <iostream>

int main() {
    int szamok[] = {10, 20, 30, 40, 50};

    for (int szam : szamok) {
        std::cout << szam << " ";
    }
    
    return 0;
}

Kimenet:

10 20 30 40 50

• Egyszerűbb és olvashatóbb kód
• Nem kell indexelni, a ciklus automatikusan végigmegy az összes elemen

---

5. Többdimenziós tömbök

A többdimenziós tömbök olyan tömbök, amelyek más tömböket tartalmaznak.

2D tömb deklarálása és inicializálása

#include <iostream>

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

    std::cout << "matrix[1][2] = " << matrix[1][2] << std::endl; // 6
    return 0;
}

Kimenet:

matrix[1][2] = 6

• matrix[1][2] a második sor harmadik eleme (6).

Bejárás két for ciklussal

#include <iostream>

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

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

    return 0;
}

Kimenet:

1 2 3
4 5 6

• Két for ciklus kell a sorok és oszlopok végigjárásához.

---

6. Dinamikus tömbök (Heap memória)

A statikus tömbök mérete fix, de dinamikus tömbök esetén a méret futásidőben változtatható.

Példa – Dinamikus tömb a new kulcsszóval

#include <iostream>

int main() {
    int meret;
    std::cout << "Add meg a tömb méretét: ";
    std::cin >> meret;

    int* tomb = new int[meret]; // Dinamikus tömb létrehozása

    for (int i = 0; i < meret; i++) {
        tomb[i] = i * 2;
        std::cout << tomb[i] << " ";
    }

    delete[] tomb; // Felszabadítás
    return 0;
}

Fontos tudni: ✅ Heap memóriát használ
✅ A delete[] szükséges a memória felszabadítására

---

7. Modern alternatívák: std::array és std::vector

A hagyományos C++ tömbök helyett az STL konténerek ajánlottak.

std::array (fix méret)

#include <iostream>
#include <array>

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

    for (int szam : szamok) {
        std::cout << szam << " ";
    }
    return 0;
}

std::vector (dinamikus méret)

#include <iostream>
#include <vector>

int main() {
    std::vector<int> szamok = {1, 2, 3, 4, 5};
    szamok.push_back(6); // Új elem hozzáadása

    for (int szam : szamok) {
        std::cout << szam << " ";
    }
    return 0;
}

A std::vector dinamikusan növekszik, és biztonságosabb! 🚀

---

Összegzés

✅ A tömb egy alapvető adatszerkezet C++-ban
✅ Használjuk az std::array-t vagy std::vector-t a modern kódokban
✅ A dinamikus tömbök rugalmasabbak, de delete[] szükséges!
✅ Tartomány alapú for egyszerűbbé teszi a bejárást

További információk

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