Tömbök C ++ - Nyilatkozat - Inicializálás - Mutatók tömb példákra

Tartalomjegyzék:

Anonim

Mi az a tömb?

A tömb olyan adatstruktúra, amely azonos adattípusú elemeket sorozatosan tárol. A C ++ tömb rögzített méretű.

A tömböt hasonló adattípusú változók gyűjteményeként tekintheti meg. Az egyes változók deklarálása és az értékek külön-külön rendelése helyett deklarálhat egy változót (a tömböt), és hozzáadhatja a különféle változók értékeit. A tömb minden hozzáadott értékét index azonosítja.

Ebben a C ++ oktatóanyagban megtudhatja:

  • Mi az a tömb?
  • Miért van szükség tömbökre?
  • Nyilvánítson egy tömböt C ++ nyelven
  • Tömb inicializálása
  • A tömbök típusai
    • Egydimenziós tömb
    • Többdimenziós tömb
    • Kétdimenziós tömb
    • Háromdimenziós tömb
    • Mutató egy tömbhöz
  • Hozzáférés egy tömb értékeihez
  • Egy tömb előnyei C ++ nyelven
  • Egy tömb hátrányai C ++ nyelven

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

A tömbök nagyon fontosak minden programozási nyelvben. Kényelmesebb módot kínálnak a változók vagy hasonló adattípusú adatgyűjtés együttes tárolása helyett. A tömb minden értékét külön-külön fogják elérni.

Nyilvánítson egy tömböt C ++ nyelven

A tömb deklarációja C ++ nyelven magában foglalja a tömb által tárolandó elemek típusát és számát. Szintaxis:

type array-Name [ array-Size ];

Az egydimenziós tömb C ++ nyelven történő deklarálásának szabályai.

  • Típus: A típus a tömbben tárolandó elemek típusa, és érvényes C ++ adattípusnak kell lennie.
  • 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. Ennek egésznek és 0-nál nagyobbnak kell lennie.

Például létrehozhat egy tömb nevű tömböt, és 5 diák korát tárolhatja az alábbiak szerint:

int age[5];

A tömbkor 5 egész számot tárol, amelyek a különböző diákok életkorát jelentik.

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ásban vagy egyenként. Megjegyezzük, hogy egy tömb első eleme a 0 indexen van tárolva, míg az utolsó elem az n-1 indexen van tárolva, ahol n a tömb összes elemének száma.

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

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

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

A (z) {} elemen belüli elemek száma nem haladhatja meg a [] értéket. A 19. elem a 0., 18., az 1., a 21., a 2., a 20., a 3. és a 17., a 4. indexen található. Ha nem adja meg a [] tömbben tárolandó elemek számát, a tömb csak akkora lesz, hogy a (z) {} fájlban hozzáadott elemeket megtartsa. 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ő. A tömbhöz egy elemet is rendelhet az indexe segítségével. Például:

age[3] = 20;

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

A tömbök típusai

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

  • Egydimenziós tömb
  • Többdimenziós tömb
  • Mutató egy tömbhöz

Egydimenziós tömb

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

datatype array-name[size];
  • A tömb neve a tömb neve.
  • A méret a tömbben tárolandó elemek száma.

Például:

#include using namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };for (int x = 0; x < 5; x++){cout <

Kimenet:




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




Kód Magyarázat:


    

  1. Az iostream fejlécfájl belefoglalása a kódunkba. Ez lehetővé teszi számunkra, hogy a konzolról olvassunk és írjunk.
    2. 

  2. Beleértve az std névteret annak osztályainak és függvényeinek felhasználása érdekében, anélkül, hogy meghívnánk.
    3. 

  3. A main () függvény meghívása, amelyen belül hozzá kell adni a program logikáját.
    4. 

  4. A fő () függvény törzsének kezdete.
    5. 

  5. Az életkor nevű tömb deklarálása 5 egész szám tárolására. Az 5 egész számot inicializáltuk.
    6. 

  6. Hozzon létre egy x egész változót a for ciklus segítségével.
    7. 

  7. A for hurok testének eleje.
    8. 

  8. Az x ciklusváltozó segítségével iterálhat a tömbkor értékei felett, és kinyomtathatja azokat a konzolra. A "\ n" új vonalas karakter, és minden iteráció után új sorba nyomtat.
    9. 

  9. A hurok testének vége.
    10. 

  10. A fő () függvény törzsének vége.
    11. 



Többdimenziós tömb


Ez egy tömb, amelyben az adatelemek tömbtömböt alkotnak. A többdimenziós tömbnek tetszőleges dimenziója lehet, de a kétdimenziós és a háromdimenziós tömbök gyakoriak. Szintaxis:





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


A tömb neve annak a tömbnek a neve, amelynek n dimenziója lesz. Például:


Kétdimenziós tömb


A 2D tömb adatokat tárol egy 1-D tömbös listában. 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ényes C ++ típusú adattípusnak kell lennie. Lásd a 2D tömböt táblázatként, ahol x a sorok, míg y az oszlopok számát jelöli. Ez azt jelenti, hogy a 2D tömb minden egyes elemét az [x] [y] alak segítségével azonosítja, ahol x a sorok száma és y 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, amely 2x3 mátrixnak tekinthető. 2 sor és 3 oszlop van. A 0 elem [0] [1] néven érhető el, mivel a 0 indexelt és az 1 indexelt oszlop metszéspontjában található. A 3 elem hozzáférhető [1] [2] néven, mert az az indexelt 1-es és a 2-es oszlop metszéspontja.


Vegye figyelembe, hogy egyszerűen göndör zárójeleket adtunk hozzá, hogy megkülönböztessük a különböző elemsorokat. Az inicializálás a következőképpen is történhetett:


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


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





#include using namespace std;int main(){// a 2x3 arrayint a[3][2] = { {0, 2}, {1, 4}, {3, 7} };// traverse array elementsfor (int i=0; i<3; i++)for (int j=0; j<2; j++){cout << "a[" <

Kimenet:




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




Kód Magyarázat:


    

  1. Az iostream fejlécfájl belefoglalása a kódunkba. Ez lehetővé teszi számunkra, hogy a konzolról olvassunk és írjunk.
    2. 

  2. Beleértve az std névteret annak osztályainak és függvényeinek felhasználása érdekében, anélkül, hogy meghívnánk.
    3. 

  3. A main () függvény meghívása, amelyen belül hozzá kell adni a kódot.
    4. 

  4. A fő () függvény törzsének kezdete.
    5. 

  5. Egy komment. A C ++ fordító ezt kihagyja.
    6. 

  6. 3 sorból és 2 oszlopból álló 2D tömb deklarálása. Elemeket is hozzáadtunk a tömbhöz.
    7. 

  7. Egy komment. A C ++ fordító ezt kihagyja.
    8. 

  8. Az i változó létrehozása egy a ciklushoz. Ez a változó a tömb sorindexei felett fog ismétlődni.
    9. 

  9. A j változó létrehozása a ciklushoz tartozó a használatával. Ez a változó a tömb oszlopindexei felett fog ismétlődni.
    10. 

  10. A hurkok testének kezdete.
    11. 

  11. Nyomtassa ki az i és j változók értékeit a konzolon a konzol szögletes zárójelében.
    12. 

  12. Nyomtassa ki az a tömb [i] [j] indexében tárolt értéket.
    13. 

  13. A hurkok testének vége.
    14. 

  14. A main () függvénynek egész számot kell adnia, ha a program jól fut.
    15. 

  15. A fő () függvény törzsének vége.
    16. 



Háromdimenziós tömb


A 3D tömb tömb tömb. A 3D tömb minden egyes elemét 3 index halmaza azonosítja. A 3D tömb elemeihez való hozzáféréshez hármat használunk a hurkokhoz. Például:


#includeusing 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";}


Kimenet:




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




Kód Magyarázat:


    

  1. Az iostream fejlécfájl belefoglalása a kódunkba. Ez lehetővé teszi számunkra, hogy a konzolról olvassunk és írjunk.
    2. 

  2. Beleértve az std névteret annak osztályainak és függvényeinek felhasználása érdekében, anélkül, hogy meghívnánk.
    3. 

  3. A main () függvény meghívása, amelyen belül hozzá kell adni a program logikáját.
    4. 

  4. A fő () függvény törzsének kezdete.
    5. 

  5. 2x3x2 méretű 3D tömb deklarálása. A tömb értékeit inicializáltuk.
    6. 

  6. Hozzáférés a tömb [0] [1] [0] indexében tárolt elemhez, és kinyomtatás a konzolra.
    7. 

  7. Hozzáférés a tömb [0] [1] [1] indexében tárolt elemhez, és kinyomtatás a konzolra.
    8. 

  8. A fő () függvény törzsének vége.
    9. 



Mutató egy tömbhöz


A mutató egy változó, amely címet tartalmaz. Azon kívül, hogy 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 a $ age [0] mutató, az age nevű tömb első elemének címe. Tekintsük a következő példát:


#include using namespace std;int main(){int *john;int age[5] = { 19, 18, 21, 20, 17 };john = age;cout << john << "\n";cout << *john;}


Kimenet:




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


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




Kód Magyarázat:


    

  1. Az iostream fejlécfájl belefoglalása a kódunkba. Ez lehetővé teszi számunkra, hogy a konzolról olvassunk és írjunk.
    2. 

  2. Beleértve az std névteret annak osztályainak és függvényeinek felhasználása érdekében, anélkül, hogy meghívnánk.
    3. 

  3. A main () függvény meghívása, amelyen belül hozzá kell adni a program logikáját.
    4. 

  4. A fő () függvény törzsének kezdete.
    5. 

  5. * John nevű mutatóváltozó deklarálása.
    6. 

  6. Kor egész elnevezésű tömb deklarálása 5 egész szám tárolására. Az egész számok értékét is inicializáltuk.
    7. 

  7. A john változó hozzárendelése a tömbkor első indexében tárolt elem címének értékéhez.
    8. 

  8. A john változó értékének kinyomtatása, amely a tömbkor első indexében tárolt elem címe.
    9. 

  9. A tömbkorban tárolt első érték kinyomtatása.
    10. 

  10. A fő () függvény törzsének vége.
    11. 



A tömb nevek állandó 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ékhez a * (életkor + 3) gombbal férhet hozzá. Például:


#include using namespace std;int main() {// an array of 5 elements.int age[5] = { 19, 18, 21, 20, 17 };int *p;p = age;// output array valuescout << "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;}


Kimenet:




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




Kód Magyarázat:


    

  1. Az iostream fejlécfájl belefoglalása a kódunkba. Ez lehetővé teszi számunkra, hogy a konzolról olvassunk és írjunk.
    2. 

  2. Beleértve az std névteret annak osztályainak és függvényeinek felhasználása érdekében, anélkül, hogy meghívnánk.
    3. 

  3. A main () függvény meghívása és a main () függvény törzsének kezdete.
    4. 

  4. Egy komment. A C ++ fordító ezt kihagyja.
    5. 

  5. Az életkor nevű tömb deklarálása 5 egész szám tárolására.
    6. 

  6. Egész mutató létrehozása p.
    7. 

  7. P-hez rendeljük a tömbkor első elemének címét.
    8. 

  8. Egy komment. A C ++ fordító ezt kihagyja.
    9. 

  9. Nyomtasson ki egy kis szöveget a konzolon.
    10. 

  10. Hozzon létre egy x egész számot a ciklus a segítségével. A {jelöli a for ciklus törzsének kezdetét.
    11. 

  11. Nyomtassa ki az x értékeit más szöveggel kombinálva a konzolon.
    12. 

  12. Nyomtassa ki a * (p + x) értékeket a konzolon.
    13. 

  13. A hurok testének vége.
    14. 

  14. Nyomtasson ki egy kis szöveget a konzolon.
    15. 

  15. Hozza létre az x változót a ciklushoz tartozó a használatával. A {a for hurok törzsének kezdetét jelöli.
    16. 

  16. Nyomtassa ki az x értékeit 0-tól 4-ig más szöveg mellett.
    17. 

  17. Nyomtassa ki a * (kor + x) értékeit.
    18. 

  18. A for hurok testének vége.
    19. 

  19. Visszatérési érték, ha a program sikeresen fut.
    20. 

  20. A fő () függvény törzsének vége.
    21. 




Hozzáférés egy tömb értékeihez


A tömb elemeihez a megfelelő indexekkel férhet hozzá. Az elérni kívánt elem indexe szögletes zárójelekbe kerül [] közvetlenül a tömb neve után. Például:


int john = age[2];


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


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

Kimenet:




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




Kód Magyarázat:


    

  1. Az iostream fejlécfájl belefoglalása a kódunkba. Ez lehetővé teszi számunkra, hogy a konzolról olvassunk és írjunk.
    2. 

  2. Beleértve az std névteret annak osztályainak és függvényeinek felhasználása érdekében, anélkül, hogy meghívnánk.
    3. 

  3. A main () függvény meghívása, amelyen belül hozzá kell adni a kódot.
    4. 

  4. A fő () függvény törzsének kezdete.
    5. 

  5. Az age nevű tömb deklarálása 5 egész elem tárolására.
    6. 

  6. Hozzáférés a tömbkor 2-es indexében tárolt értékhez, és értékének tárolása a john nevű változóban.
    7. 

  7. A john változó értékének kinyomtatása a konzolra más szöveg mellé.
    8. 




Egy tömb előnyei C ++ nyelven


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


    

  • A tömbelemek könnyen átjárhatók.
    • 

  • Könnyen kezelhető a tömbadatok.
    • 

  • A tömb elemek véletlenszerűen érhetők el.
    • 

  • A tömbök megkönnyítik a kód optimalizálását; ennélfogva sok munkát végezhetünk kevesebb kód használatával.
    • 

  • Könnyen rendezhető tömbadatok.
    • 




Egy tömb hátrányai C ++ nyelven


    

  • Egy tömb rögzített méretű; ennélfogva az inicializálás után nem adhatunk hozzá új elemeket.
    • 

  • A szükségesnél több memória elosztása memóriaterület pazarlásához vezet, és a memória kevesebb elosztása problémát okozhat.
    • 

  • A tömbben tárolandó elemek számát előre tudni kell.
    • 



Összegzés


    

  • A tömb egy olyan adatstruktúra, amely azonos adattípusú elemeket tárol.
    • 

  • A tömbelemeket egymás után tároljuk.
    • 

  • A tömb elemeket a megfelelő indexükkel jelöljük. Az első elem a 0, míg az utolsó elem az n-1 indexnél van, ahol a tömb elemek teljes száma található.
    • 

  • A tömb deklarálása magában foglalja a tömb elemek adattípusainak, valamint a tömbben tárolandó elemek számának meghatározását.
    • 

  • Egy dimenziós tömb egymás után tárolja az elemeket.
    • 

  • A kétdimenziós tömb elemeit sorokban és oszlopokban tárolja.
    • 

  • A háromdimenziós tömb tömbtömb.
    • 

  • Az elemek indexeik segítségével hozzáadhatók egy tömbhöz.
    • 

  • A tömb elemeihez indexeik segítségével férhetünk hozzá.
    • 

  • Egy többdimenziós tömbnek több dimenziója van.
    • 

  • A tömb neve az első elemére mutat.
    • 

  • A tömbök rögzített méretűek, vagyis az inicializálás után nem lehet új elemeket hozzáadni a tömbhöz.
    •