Tömbök be C++ | Nyilatkozni | Inicializálás | Mutató a tömbpéldákra

Miért van szükségünk tömbökre?

tömbök nagyon fontosak minden programozási nyelvben. Kényelmesebb módot biztosítanak a változók vagy hasonló adattípusú adatok gyűjteményének együttes tárolására, ahelyett, hogy külön-külön tárolnák őket. A tömb minden értéke külön lesz elérhető.

Deklaráljon egy tömböt C++

Tömb deklaráció be C++ magában foglalja a tömb által tárolandó elemek típusának és számának megadását. Szintaxis:

type array-Name [ array-Size ];

Az egydimenziós tömb deklarálásának szabályai C++.

• Típus: A típus a tömbben tárolandó elemek típusa, és érvényesnek kell lennie C++ adattípus.
• Tömbnév: A tömbnév a tömbhöz rendelendő név.
• Tömbméret: A tömbméret a tömbben tárolandó elemek száma. Egész számnak kell lennie, és nagyobbnak kell lennie 0-nál.

Például létrehozhat egy életkor nevű tömböt, és tárolhatja 5 tanuló életkorát a következőképpen:

int age[5];

A tömb életkora 5 egész számot fog tárolni, amelyek a különböző tanulók életkorát reprezentálják.

Tömb inicializálása

A tömb inicializálása az elemek hozzárendelése/tárolása egy tömbhöz. Az inicializálás történhet egyetlen utasítással vagy egyenként is. Vegye figyelembe, hogy a tömb első eleme a 0 indexen, míg az utolsó elem az n-1 indexen van tárolva, ahol n a tömb elemeinek teljes száma.

Az age tömb esetében az első elem a 0, míg az utolsó elem a 4-es indexen lesz tárolva.

Használjuk az age tömböt annak bemutatására, hogyan lehet a tömb inicializálását elvégezni:

int age[5] = {19, 18, 21, 20, 17};

A(z) { }-on belüli elemek teljes száma nem haladhatja meg a [ ]-ben megadott értéket. A 19-es elem a 0-s, a 18-as az 1-es indexnél, a 21-es a 2-es indexnél, a 20-as a 3-as indexnél és a 17-es a 4-es indexnél. Ha nem adja meg a tömbben tárolandó elemek számát a [ ]-on belül, a tömb csak akkora lesz, hogy el tudja fogadni a(z) { } keretbe felvett elemeket. Például:

int age[] = {19, 18, 21, 20, 17};

A fenti utasítás pontosan ugyanazt a tömböt hozza létre, mint az előző. Egy elemet hozzárendelhet egy tömbhöz az indexe segítségével is. Például:

age[3] = 20;

A fenti utasítás a 20-as értéket az age nevű tömb 3. indexében tárolja. Ez azt jelenti, hogy a 20 lesz a 4^th eleme a tömbnek.

Tömbök típusai

Kétféle típus létezik C++ tömbök:

• Egydimenziós tömb
• Többdimenziós tömb
• Mutasson egy tömbre

Egydimenziós tömb

Ez egy olyan tömb, amelyben az adatelemek lineárisan, csak egy dimenzióban vannak elrendezve. Általában 1-D tömbnek nevezik. Szintaxis:

datatype array-name[size];

• A tömbnév a tömb neve.
• A méret a tömbben tárolandó elemek száma.

Például:

#include <iostream>
using namespace std;

int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	for (int x = 0; x < 5; x++)
	{
		cout <<age[x]<<"\n";
	}
}

output:

Itt van egy képernyőkép a kódról:

Kód magyarázata:

1. Az iostream fejlécfájl belefoglalása a kódunkba. Lehetővé teszi számunkra, hogy olvassunk a konzolról és írjunk oda.
2. Beleértve az std névteret, hogy az osztályait és függvényeit hívás nélkül használhassuk.
3. A main() függvény meghívása, amelyen belül a program logikáját hozzá kell adni.
4. A main() függvény törzsének kezdete.
5. Kor nevű tömb deklarálása 5 egész szám tárolására. Az 5 egész szám is inicializálva lett.
6. Hozzon létre egy x egész változót a for ciklus segítségével.
7. A for ciklus törzsének eleje.
8. Az x ciklusváltozó használata a tömb életkorának értékeinek megismétléséhez, és kinyomtatásához a konzolon. A „\n” egy újsor karakter, és minden iteráció után új sorban jelenik meg.
9. A test vége a hurokhoz.
10. A main() függvény törzsének vége.

Többdimenziós tömb

Ez egy tömb, amelyben az adatelemek tömbök tömbjét alkotva vannak elrendezve. Egy többdimenziós tömbnek tetszőleges számú dimenziója lehet, de gyakoriak a kétdimenziós és háromdimenziós tömbök. Szintaxis:

datatype array-name[d1][d2][d3]...[dn];

A tömbnév annak a tömbnek a neve, amelynek n mérete lesz. Például:

Kétdimenziós tömb

A 2D tömb az adatokat egy listában tárolja 1D tömbbel. Ez egy mátrix sorokkal és oszlopokkal. 2D tömb deklarálásához használja a következő szintaxist:

type array-Name [ x ][ y ];

A típusnak érvényesnek kell lennie C++ adattípus. Tekintse meg a 2D tömböt táblázatként, ahol x a sorok számát, y pedig az oszlopok számát jelöli. Ez azt jelenti, hogy a 2D tömb minden elemét a[x][y] formában azonosítja, ahol x a sorok száma, y ​​pedig azoknak az oszlopoknak a száma, amelyekhez az elem tartozik.

Íme egy példa a 2D tömb inicializálására:

int a[2][3] = {  
   {0, 2, 1} ,   /*  row at index 0 */
   {4, 3, 7} ,   /*  row at index 1 */
   };

A fenti példában van egy 2D tömbünk, amely 2×3-as mátrixnak tekinthető. 2 sor és 3 oszlop van. A 0 elem a[0][1] néven érhető el, mert a 0 indexű sor és az 1 indexű oszlop metszéspontjában található. A 3. elem a[1][2] néven érhető el, mert a az 1 indexű sor és a 2 indexű oszlop metszéspontja.

Vegye figyelembe, hogy egyszerűen csak göndör kapcsos zárójeleket adtunk hozzá, hogy megkülönböztessük a különböző elemsorokat. Az inicializálást a következőképpen is meg lehetett volna tenni:

int a[2][3] = {0, 2, 1, 4, 3, 7};
   };

A következő C++ egy példa bemutatja, hogyan kell inicializálni és bejárni egy 2D tömböt:

#include <iostream>
using namespace std;
int main() 
{
	// a 2x3 array
	int a[3][2] = { {0, 2}, {1, 4}, {3, 7} };

	// traverse array elements

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

output:

Íme egy képernyőkép a fenti kódról:

Kód magyarázata:

1. Az iostream fejlécfájl belefoglalása a kódunkba. Lehetővé teszi számunkra, hogy olvassunk a konzolról és írjunk oda.
2. Beleértve az std névteret, hogy az osztályait és függvényeit hívás nélkül használhassuk.
3. A main() függvény meghívása, amelyen belül a kódot hozzá kell adni.
4. A main() függvény törzsének kezdete.
5. Egy megjegyzés. A C++ a fordító ezt kihagyja.
6. 2 sorból és 3 oszlopból álló 2D tömb deklarálása. Elemek is felkerültek a tömbbe.
7. Egy megjegyzés. A C++ a fordító ezt kihagyja.
8. i változó létrehozása a for a ciklus használatával. Ez a változó a tömb sorindexei között ismétlődik.
9. J változó létrehozása a for ciklus segítségével. Ez a változó a tömb oszlopindexei között ismétlődik.
10. A hurkok testének kezdete.
11. Nyomtassa ki az i és j változók értékét a konzolon szögletes zárójelek között a konzolon.
12. Nyomtassa ki az a tömb [i][j] indexénél tárolt értéket.
13. A hurkok testének vége.
14. A main() függvénynek egész értéket kell visszaadnia, ha a program jól fut.
15. A main() függvény törzsének vége.

Háromdimenziós tömb

A 3D tömb tömbök tömbje. A 3D tömb minden elemét 3 indexből álló halmaz azonosítja. A 3D tömb elemeinek eléréséhez három ciklust használunk. Például:

#include<iostream>
using namespace std;
void main()
{
	int a[2][3][2] = {{{4, 8},{2, 4},{1, 6}}, {{3, 6},{5, 4},{9, 3}}};
	cout << "a[0][1][0] = " << a[0][1][0] << "\n";
	cout << "a[0][1][1] = " << a[0][1][1] << "\n";
}

output:

Itt van egy képernyőkép a kódról:

Kód magyarázata:

1. Az iostream fejlécfájl belefoglalása a kódunkba. Lehetővé teszi számunkra, hogy olvassunk a konzolról és írjunk oda.
2. Beleértve az std névteret, hogy az osztályait és függvényeit hívás nélkül használhassuk.
3. A main() függvény meghívása, amelyen belül a program logikáját hozzá kell adni.
4. A main() függvény törzsének kezdete.
5. 3x2x3 méretű an nevű 2D tömb deklarálása. A tömb értékei is inicializálva lettek.
6. A tömb [0][1][0] indexén tárolt elem elérése és kinyomtatása a konzolon.
7. A tömb [0][1][1] indexén tárolt elem elérése és kinyomtatása a konzolon.
8. A main() függvény törzsének vége.

Mutasson egy tömbre

A mutató egy címet tartalmazó változó. Azon kívül, hogy egy mutatót használunk egy változó címének tárolására, használhatjuk egy tömbcella címének tárolására. Egy tömb neve folyamatosan az első elemére mutat. Vegye figyelembe az alábbi nyilatkozatot:

int age[5];

Az életkor egy mutató az $age[0]-ra, az age nevű tömb első elemének címére. Tekintsük a következő példát:

#include <iostream>
using namespace std;
int main()
{
	int *john;

	int age[5] = { 19, 18, 21, 20, 17 };

	john = age;

	cout << john << "\n";

	cout << *john;
	
}

output:

Vegye figyelembe, hogy a fenti kimenet első értéke eltérő értéket adhat vissza attól függően, hogy a számítógép memóriájában a tömb első eleméhez milyen cím van hozzárendelve.

Itt van egy képernyőkép a kódról:

Kód magyarázata:

1. Az iostream fejlécfájl belefoglalása a kódunkba. Lehetővé teszi számunkra, hogy olvassunk a konzolról és írjunk oda.
2. Beleértve az std névteret, hogy az osztályait és függvényeit hívás nélkül használhassuk.
3. A main() függvény meghívása, amelyen belül a program logikáját hozzá kell adni.
4. A main() függvény törzsének kezdete.
5. A *john nevű mutatóváltozó deklarálása.
6. Egy age nevű egész szám tömb deklarálása 5 egész szám tárolására. Az egész számok értékei is inicializálásra kerültek.
7. A john változó hozzárendelése a tömb kor első indexében tárolt elem címének értékéhez.
8. A john változó értékének kinyomtatása, amely a tömb kor első indexében tárolt elem címe.
9. A tömb korában tárolt első érték nyomtatása.
10. A main() függvény törzsének vége.

A tömbnevek konstans mutatóként használhatók, és fordítva is igaz. Ez azt jelenti, hogy a tömb életkorának 3. indexében tárolt értéket *(életkor + 3) érheti el. Például:

#include <iostream>
using namespace std;

int main() {
	// an array of 5 elements.
	int age[5] = { 19, 18, 21, 20, 17 };
	int *p;

	p = age;

	// output array values

	cout << "Using pointer: " << endl;

	for (int x=0; x<5; x++) {
		cout << "*(p + " << x << ") : ";
		cout << *(p + x) << endl;
	}
	cout << "Using age as address: " << endl;

	for (int x = 0; x < 5; x++) {
		cout << "*(age + " << x << ") : ";
		cout << *(age + x) << endl;
	}

	return 0;
}

output:

Itt van egy képernyőkép a kódról:

Kód magyarázata:

1. Az iostream fejlécfájl belefoglalása a kódunkba. Lehetővé teszi számunkra, hogy olvassunk a konzolról és írjunk oda.
2. Beleértve az std névteret, hogy az osztályait és függvényeit hívás nélkül használhassuk.
3. A main() függvény meghívása és a main() függvény törzsének kezdete.
4. Egy megjegyzés. A C++ a fordító ezt kihagyja.
5. Kor nevű tömb deklarálása 5 egész szám tárolására.
6. Egész mutató létrehozása p.
7. P hozzárendelése a tömbéletkor első elemének címének értékéhez.
8. Egy megjegyzés. A C++ a fordító ezt kihagyja.
9. Nyomtasson ki néhány szöveget a konzolon.
10. Hozzon létre egy x egész számot a for ciklus segítségével. A { jelzi a for ciklus törzsének kezdetét.
11. Nyomtassa ki az x értékeit más szöveggel kombinálva a konzolon.
12. Nyomtassa ki a *(p + x) értékeit a konzolon.
13. A for hurok törzsének vége.
14. Nyomtasson ki néhány szöveget a konzolon.
15. Hozzon létre egy x változót a for ciklus használatával. A { jelzi a for ciklus törzsének kezdetét.
16. Nyomtassa ki az x értékeit 0-tól 4-ig más szövegek mellé.
17. Nyomtassa ki a *(életkor + x) értékeit.
18. A for ciklus törzsének vége.
19. Visszatérési érték, ha a program sikeresen fut.
20. A main() függvény törzsének vége.

Egy tömb értékeinek elérése

Egy tömb elemei a hozzájuk tartozó indexekkel érhetők el. Az elérendő elem indexe közvetlenül a tömb neve után kerül szögletes zárójelek közé [ ]. Például:

int john = age[2];

A fenti példában egyszerűen kijelentjük, hogy János életkora az age nevű tömb 2. indexében van tárolva. Ez azt jelenti, hogy János életkora a 3^rd érték a tömb korában. Itt van egy teljes C++ példa, amely bemutatja, hogyan lehet elérni és kinyomtatni ezt az értéket:

#include<iostream>
using namespace std;
int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	int john = age[2];
	cout << "The age of John is:"<<john;
}

output:

Itt van egy képernyőkép a kódról:

Kód magyarázata:

1. Az iostream fejlécfájl belefoglalása a kódunkba. Lehetővé teszi számunkra, hogy olvassunk a konzolról és írjunk oda.
2. Beleértve az std névteret, hogy az osztályait és függvényeit hívás nélkül használhassuk.
3. A main() függvény meghívása, amelyen belül a kódot hozzá kell adni.
4. A main() függvény törzsének kezdete.
5. Egy age nevű tömb deklarálása 5 egész elem tárolására.
6. A tömb életkorának 2. indexén tárolt érték elérése és értékének tárolása egy john nevű változóban.
7. A john változó értékének kinyomtatása a konzolon más szövegek mellé.

A tömb előnyei C++

Itt vannak az Array in használatának előnyei/előnyei C++:

• A tömbelemek könnyen bejárhatók.
• Könnyen kezelhető tömbadatok.
• A tömb elemei véletlenszerűen érhetők el.
• A tömbök megkönnyítik a kódoptimalizálást; így kevesebb kód használatával sok munkát végezhetünk.
• Könnyen rendezhetők a tömbadatok.

A tömb hátrányai C++

• Egy tömbnek fix mérete van; ennélfogva az inicializálás után nem adhatunk hozzá új elemeket.
• A szükségesnél több memória lefoglalása memóriaterület-pazarláshoz vezet, és a kevesebb memóriafoglalás problémát okozhat.
• A tömbben tárolandó elemek számát előre tudni kell.

Összegzésként

• A tömb olyan adatstruktúra, amely azonos adattípusú elemeket tárol.
• A tömbelemek szekvenciálisan kerülnek tárolásra.
• A tömbelemeket a megfelelő indexekkel jelöljük. Az első elem a 0 indexnél, míg az utolsó elem az n-1 indexnél található, ahol a tömbelemek teljes száma.
• Egy tömb deklarációja magában foglalja a tömbelemek adattípusainak, valamint a tömbben tárolandó elemek számának meghatározását.
• Az egydimenziós tömb az elemeket szekvenciálisan tárolja.
• A kétdimenziós tömb az elemeket sorokban és oszlopokban tárolja.
• A háromdimenziós tömb tömbök tömbje.
• Az elemek indexeikkel hozzáadhatók egy tömbhöz.
• A tömbelemek az indexeik segítségével érhetők el.
• Egy többdimenziós tömbnek több dimenziója van.
• A tömb neve az első elemére mutat.
• A tömbök fix méretűek, ami azt jelenti, hogy az inicializálás után nem lehet új elemeket hozzáadni a tömbhöz.