Tömbök - bevezető

Tömbök (egydimenziós tömbök)

A tömb egy összetett homogén adatszerkezet, ami az elemeket egymás melletti memóriadarabokon tárolja.

Tömbök bejelentése C++-ban:

    alaptípus tömbnév[méret];

    pl. int t[100];

    |----|----|----| .... |----|
    (összesen 100 x 4B memória)

Elemek elérése:

    tömbnév[index] (lehet írni és olvasni is)

Az “index” egy szám, 0-tól sorszámozza az elemeket!

Pl. int t[100] esetén az elemek:

    t[0], t[1], t[2], ..., t[99]

1
2

    cout << t[0]; // kiírja az első (0 indexű) elemet
    t[99] = 2;   // beállítja az  utolsó elemet 2-re

Példa

Beolvasunk egy n hosszú (n≤100) sorozatot egy tömbbe, majd kiírjuk az elemeit:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>
using namespace std;

int main()
{
    int t[100];
    int n;

    cin >> n;

    for (int i = 0; i < n; i++)
        cin >> t[i];

    for(int i = 0; i < n; i++)
        cout << t[i] << " ";

    return 0;
}

Feladat:

Az input.txt fájlban adott n, majd egy n elemű sorozat. Olvassuk be az elemeket, majd írjuk ki fordított sorrendben! (n≤100)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream bemenet("input.txt");
    int tomb[100];
    int n;
    bemenet >> n;

    for (int i = 0; i < n; i++) {
        bemenet >> tomb[i];
    }
    for (int i = n-1; i >= 0; i--) {
        cout << tomb[i] << " ";
    }
    cout << endl;
    return 0;
}

Feladat:

Adott egy sorozat (max 1000 elemű). Írjuk ki a páratlan elemeit a megjelenésük fordított sorrendjében.

Példa:

    5
    1 2 3 4 5  --->  5 3 1

Megoldás: HF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream bemenet("input.txt");
    int tomb[100];
    int n;
    bemenet >> n;

    for (int i = 0; i < n; i++) {
        bemenet >> tomb[i];
    }

    for (int i = n-1; i >= 0; i--) {
        if (tomb[i] % 2 != 0)
            cout << tomb[i] << " ";
    }
    cout << endl;
    return 0;
}

Tömbök inicializálása

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;

int main()
{
    int t[100]; // nem tudjuk az elemek
                // kezdőértékét (nincsenek
                // inicializálva)

    int a[5] = {2,3,4,5,6};
        // 5 elemű, mindnek megadtuk a
        // kezdőértékét

    int b[100] = {10,20,30};
        // a b első három eleme 10, 20, 30
        // a többi elem nulla

    int c[100] = {};
        // c minden eleme 0

    return 0;
}

Számozási lehetőség 1-től

Ha 1-től akarjuk az elemeket sorszámozni, akkor megtehetjük egyszerűen kihagyva a 0-s indexet.

Pl.

1
2

    for (int i = 0; i < n; i++)
        cin >> t[i];

helyett:

1
2

    for (int i = 1; i <= n; i++)
        cin >> t[i];

Figyelem! A tömb ilyenkor 1-gyel nagyobb kapacitású kell legyen, mint amekkora sorozatot tárolni akarunk legfeljebb. A nulla indexen továbbra is létezik egy elem, csak azt nem használjuk.