Ugrás a tartalomhoz

one-dimensional array

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

one-dimensional array (tsz. one-dimensional arrays)

  1. (informatika) egydimenziós tömb

A egydimenziós tömb (vagy egyszerűen tömb) C++-ban egy olyan adatstruktúra, amely egy sorozatot vagy listát tárol azonos típusú elemekből. Az elemek egy adott index alapján érhetők el, és a tömbök fix méretűek, amit a deklaráláskor kell meghatározni.

Egydimenziós tömb deklarálása és inicializálása

C++-ban egy egydimenziós tömböt az alábbi módon deklarálhatunk:

típus tömbnév[méret];
  • típus: A tömbben tárolt elemek típusa, például int, float, double, stb.
  • tömbnév: A változó neve, amellyel a tömböt elérhetjük.
  • méret: A tömb mérete, amely meghatározza, hogy hány elemet tárolhat a tömb.

Példák

Egyszerű tömb deklarálás és értékadás

#include <iostream>
using namespace std;

int main() {
    // Tömb deklarálása és inicializálása
    int arr[5] = {1, 2, 3, 4, 5};

    // Tömb elemeinek kiírása
    for (int i = 0; i < 5; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    return 0;
}

Ebben a példában egy int típusú tömböt hozunk létre 5 elemre, és azokat a 1, 2, 3, 4, 5 értékekkel inicializáljuk. A for ciklussal végigiterálunk a tömb elemein és kiírjuk őket.

Tömb deklarálása csak alapértékek nélkül

#include <iostream>
using namespace std;

int main() {
    // Tömb deklarálása értékek nélkül
    int arr[5];

    // A tömb elemeinek értékadása
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    arr[3] = 40;
    arr[4] = 50;

    // A tömb elemeinek kiírása
    for (int i = 0; i < 5; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    return 0;
}

Ebben az esetben a tömb elemei nem kerülnek inicializálásra a deklaráláskor, hanem később, a program futása alatt kerülnek értékekhez. A tömböt itt is a for ciklus segítségével írjuk ki.

Hozzáférés a tömb elemeihez

A tömb elemei indexeléssel érhetők el. A tömb első eleme az index 0-val érhető el, a második az 1-gyel, és így tovább. Az alábbiakban bemutatok egy példát, hogyan lehet egy adott elemet elérni a tömbben:

#include <iostream>
using namespace std;

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

    // A tömb harmadik elemének (index 2) kiírása
    cout << "A harmadik elem: " << arr[2] << endl;

    // A tömb utolsó elemének (index 4) módosítása
    arr[4] = 100;

    // A tömb kiírása a módosítás után
    cout << "A módosított tömb utolsó eleme: " << arr[4] << endl;

    return 0;
}

Tömbök és ciklusok

A tömbök gyakran ciklusokkal együtt használatosak, hogy minden egyes elemhez hozzáférjünk. Az alábbi példában a for ciklus segítségével írjuk ki az összes tömbelemet:

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {2, 4, 6, 8, 10};

    // Tömb elemeinek kiírása ciklussal
    for (int i = 0; i < 5; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    return 0;
}

Ebben a példában az arr tömb 5 elemét írjuk ki egy for ciklussal, amely végigiterál az összes indexen, és kiírja a megfelelő elemet.

Tömb méretének meghatározása

A tömb méretének meghatározására használhatjuk a sizeof operátort. A sizeof segítségével megkaphatjuk a tömb teljes memóriában elfoglalt helyét bájtokban, majd ezt elosztva az egy elem méretével meghatározhatjuk a tömb elemének számát.

#include <iostream>
using namespace std;

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

    // A tömb méretének meghatározása
    int size = sizeof(arr) / sizeof(arr[0]);

    cout << "A tömb mérete: " << size << endl;

    return 0;
}

A dinamikus tömb

A statikus tömbökkel szemben, amikor nem tudjuk előre meghatározni a tömb méretét, dinamikus tömböket használhatunk a new és delete operátorok segítségével. A dinamikus tömbök létrehozásakor nem szükséges előre megadni a tömb méretét, és azokat a memóriát futás közben kezelhetjük.

#include <iostream>
using namespace std;

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

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

    // A dinamikus tömb elemeinek értékadása
    for (int i = 0; i < n; i++) {
        arr[i] = i * 10;
    }

    // A dinamikus tömb elemeinek kiírása
    for (int i = 0; i < n; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    // A dinamikus tömb felszabadítása
    delete[] arr;

    return 0;
}

Ebben a példában a felhasználó által megadott méretű dinamikus tömböt hozunk létre, és annak elemeit egy ciklussal inicializáljuk. A delete[] operátorral felszabadítjuk a dinamikusan foglalt memóriát, miután már nincs rá szükség.

Összegzés

A C++-ban az egydimenziós tömbök egyszerű és hatékony adatstruktúrák, amelyek segítségével több adatot tárolhatunk egyetlen változóban. A tömbök deklarálása, inicializálása, és azokhoz való hozzáférés alapvető része a C++ programozásnak. Fontos, hogy a tömbök méretét és a memória kezelését megfelelően végezzük, hogy elkerüljük a hibákat, például a túl indexelést vagy a memória szivárgást. A dinamikus tömbök lehetővé teszik a rugalmasabb memória kezelését, de mindig biztosítani kell, hogy a lefoglalt memória megfelelően fel legyen szabadítva a program végén.

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=one-dimensional_array&oldid=3490309”