array data structure

Üdvözlöm, Ön a array data structure szó jelentését keresi. A DICTIOUS-ban nem csak a array data structure szó összes szótári jelentését megtalálod, hanem megismerheted az etimológiáját, a jellemzőit és azt is, hogyan kell a array data structure szót egyes és többes számban mondani. Minden, amit a array data structure szóról tudni kell, itt található. A array data structure szó meghatározása segít abban, hogy pontosabban és helyesebben fogalmazz, amikor beszélsz vagy írsz. Aarray data structure és más szavak definíciójának ismerete gazdagítja a szókincsedet, és több és jobb nyelvi forráshoz juttat.

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;

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

#include <iostream>

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

    std::cout << "A tömb első eleme: " << szamok << std::endl;
    std::cout << "A tömb második eleme: " << szamok << 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, a második szamok, 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 = {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 = {10, 20, 30, 40, 50};

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

    return 0;
}

Kimenet:

szamok = 10
szamok = 20
szamok = 30
szamok = 40
szamok = 50
  • Index alapú elérés: szamok
  • 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 = {
        {1, 2, 3},
        {4, 5, 6}
    };

    std::cout << "matrix = " << matrix << std::endl; // 6
    return 0;
}

Kimenet:

matrix = 6
  • matrix a második sor harmadik eleme (6).

Bejárás két for ciklussal

#include <iostream>

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

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << matrix << " ";
        }
        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; // Dinamikus tömb létrehozása

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

    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