Bevezetés a 3D tömbökbe C
Egy tömb egy elemcsoport, amelynek azonos (homogén) adattípusa van. Származtatott adattípusnak is hívják. Mint már észrevettük, egy 3D-s tömb exponenciálisan növeli a teret, és egy extra pozícióval bővítjük az elem helyét a tömbben. Ebben a témakörben megismerjük a C tömböket.
Vegyünk például egy 4 szintű épületet, ahol sok rés van a kerékpár parkolásához. Tehát itt, hogy megkapjuk a parkolt kerékpár tökéletes nyílásait, meg kell mondanunk a szint számát a sor és az oszlop számával. Amikor csak elmondja a tömböt, a 7. sor és a 4. oszlop, melyik szintet keresi? Ez a 3D tömb csak több adatmennyiség tárolására és a pozíciók ábrázolására szolgál.
Hogyan lehet meghatározni és végrehajtani őket? Ha tovább megyünk, értjük ezeket a fogalmakat.
Szintaxis:
A C-ben a dimenziós tömbök a következők szerint deklarálhatók:
Tehát ugyanúgy kijelenthetjük a 3D-tömböt:
A fenti ábrázolás jelentése a következőképpen érthető:
- A c változóhoz hozzárendelt memória int típusú.
- A tömb teljes kapacitása 2 * 3 * 4, amely megegyezik 24 elemmel.
- Az adatokat 2 tömb, 3 sor és 4 oszlop formájában ábrázolja.
| Oszlopok | |||||
| c (0) tömb | sorok | c (0) (0) | c (0) (1) | c (0) (2) | c (0) (3) |
| c (1) (0) | c (1) (1) | c (1) (2) | c (1) (3) | ||
| c (2) (0) | c (2) (1) | c (2) (2) | c (2) (3) | ||
| Oszlopok | |||||
| c (1) tömb | sorok | c (0) (0) | c (0) (1) | c (0) (2) | c (0) (3) |
| c (1) (0) | c (1) (1) | c (1) (2) | c (1) (3) | ||
| c (2) (0) | c (2) (1) | c (2) (2) | c (2) (3) | ||
A tömbön belüli adatok a fenti ábrán keresztül érhetők el. A 3D-s tömbök ábrázolásában az első szögletes zárójel jelöli a figyelembe veendő tömb szintjét, a második a sorok száma, a harmadik az oszlopok számát jelenti.
Az első elem tömbének index-ábrázolása mindig nullával kezdődik, és az 1-es mérettel végződik. Tehát például, ha a sorok száma 3, akkor a sorokban lévő adatokhoz való hozzáféréshez az index ábrázolása 0, 1 és 2 lesz. Ugyanez a logika vonatkozik a tömbszintre és az oszlopindexekre is. A fenti ábrázoláshoz a tömb 1. szintjének a 2. oszlop 3. oszlopával való eléréséhez c (0) (1) (2) hozzáféréssel érhetjük el.
3D-s tömbök inicializálása C-ben
Inicializálhatunk egy 3D tömböt, amely hasonló a 2-D tömbhöz.
Mint fentebb említettük, a tömbbe illeszthető elemek száma tömb méret1 * tömb méret2 * tömb méret3. Itt 2 * 4 * 3, ami 24-et ad.
Elemek beillesztése:
Hasonlóan a 2D tömbhöz, az elemek beillesztéséhez a 3D-tömbbe az adatokat szintbe, sorba és oszlopba kell beilleszteni. Tehát erre a hurkok koncepcióját használjuk. Az adatok tömbben történő inicializálásának a fenti folyamatában előre meghatároztuk az értékeket.
Itt az elemeket a felhasználó a követelményeknek megfelelően dinamikusan beillesztheti. Az alábbiakban található egy példakód az elemek beillesztésére.
Kód:
#include
int main()
(
int c(2)(4)(3);
int i, j, k;
printf("Enter elements into 3-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
for(k=0;k<3;k++)
(
scanf("%d", &c(i)(j)(k));
)
)
)
)
Amint azt a kód megfigyelte:
- Először a tömb változóját és a tömb dimenzióit deklaráljuk a tömb, a sorok és az oszlopok számával.
- Ezután három változót deklarálunk a tömb elemeinek iterálására.
- Ezután hurkokhoz használják. Az első hurok a szintek iterációjára szolgál, a második a sorokra és a harmadik hurok az oszlopokra.
- A Scanf függvény az adatokat beolvasáskor használja az olvasáshoz, majd az beszúrott értéket i, j és k helyzetbe helyezi.
A fenti példában az adatokat egy 2 szint, 4 sor és 3 oszlop mátrixba illesztettük. A következők kimenete az alábbiak szerint kapható:
Mivel a printf funkciót nem használtuk a kimenet megjelenítéséhez, az írt program csak a felhasználó által megadott értékeket olvasta. A nyomtatási funkció megírása után (hurkok használatával) a kimenet a következőképpen jelenik meg:
Elemek frissítése:
A tömb elemeinek frissítése elvégezhető vagy azzal, hogy meghatározza a cserélni kívánt elemet, vagy meghatározza egy helyet, ahol a csere megtörténik. A frissítéshez általában az alábbi részletekre van szükségünk.
- Egy tömb elemei
- Pozíció / elem, ahova be kell illeszteni
- A beillesztendő érték.
A tömb adatainak frissítéséhez az elem részletein keresztül először meg kell keressük azt az elemet a tömbben, meg kell értenünk annak helyét, majd a régi elemet új elemre kell cserélnünk.
Az alábbiakban két példát mutattunk be a 3D tömb elemének frissítésére.
Először olvassa el egy példát, ahol a frissítendő elem helyzete már ismert.
Kód
#include
int main()
(
int c(2)(4)(3);
int i, j, k, num;
printf("Enter elements into 3-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
for(k=0;k<3;k++)
(
scanf("%d", &c(i)(j)(k));
)
)
)
c(1)(1)(1) = 85;
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
for(k=0;k<3;k++)
(
printf("\t%d", c(i)(j)(k));
)
printf("\n");
)
printf("\n");
)
return 0;
)
A fenti programban az 1. szint, az 1. sor és az 1. oszlop eleme van kiválasztva, és az adatok értéke abban a helyzetben frissült.
A fenti eredmény a következő:
A második példában bemutatjuk, hogy az elem pozícióját miként lehet dinamikusan figyelembe venni a felhasználó által megadott értékként, és frissítjük az elem értékét az adott pozícióban.
Kód:
#include
int main()
(
int c(2)(4)(3);
int i, j, k, num;
printf("Enter elements into 3-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
for(k=0;k<3;k++)
(
scanf("%d", &c(i)(j)(k));
)
)
)
printf("Enter the level, row and column number: ");
scanf("%d %d %d", &i, &j, &k);
printf("Enter the new number you want to update with: ");
scanf("%d", &num);
c(i)(j)(k) = num;
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
for(k=0;k<3;k++)
(
printf("\t%d", c(i)(j)(k));
)
printf("\n");
)
printf("\n");
)
return 0;
)
A kimenet a következő. Itt a scanf függvényt olvastam meg a felhasználó által megadott értéket egy elem pozíciójára vonatkozóan, a tömb szintje, a sorok és az oszlopok száma alapján.
Gyakorlatként megpróbálhat egy programot írni a mátrix teljes oszlopának frissítésekor a felhasználó által megadott értékekkel?
Most, amint tudjuk, a 3D-s tömbben a tömb méretét az elején deklaráljuk. Tisztában vagyunk a tömb méretével, de mi van, ha a felhasználó véletlenszerű sort és oszlopot ad meg a tömb méretén kívül?
Mi lenne, ha több elemet írnánk be, mint amennyire szükség van a tömb belsejébe?
Figyelem: mivel nem írtunk semmilyen if / condition feltételt vagy try / catch blokkot, a mátrix kimenete nem változik. Azonban a fenti feltételekkel írhatjuk a kódot, hogy ilyen esetekben hibákat jelenítsünk meg.
Utolsó példaként: Ön nem kíváncsi, mi történik, ha néhány elemet kihagyunk a kettő között? Mit csinál a programom?
A fenti kimenet szerint:
- 4 értéket hiányzott a bemeneten, csak szóköz megadásával és az enter megnyomásával
- De megvan a lehetőségünk, hogy belépjünk a fennmaradó 4 elembe.
- Aztán meghatároztuk az utolsó szintet, az utolsó sort és az utolsó oszlop elemet, amelyet 78-ra kell cserélni. És a kimenet a vártnak felel meg, nem igaz?
Elemek törlése
Az adatok beillesztésének és a 3D tömbbe történő frissítésének fogalma után nézzük meg, hogyan lehet egy sort törölni a tömbből.
Egyszerű formátumban írtunk programot, hogy a különféle műveletek fogalma könnyen érthető legyen.
Kód:
#include
int main()
(
int c(2)(4)(3), i, j, k, num, x;
printf("Enter elements into 3-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
for(k=0;k<3;k++)
(
scanf("%d", &c(i)(j)(k));
)
)
)
printf("Enter the value of row number to delete: ");
scanf("%d", &x);
for(i=0;i<2;i++)
(
for(j=0;j<4;j++)
(
if(j==x)
(
for(k=0;k<3;k++)
(
if((j+1)<4)
(
printf("\t%d", c(i)(j+1)(k));
)
)
j ++;
)
más
(
A (k = 0; k <3; k ++)
(
printf („% d”, c (i) (j) (k));
)
)
printf ( „\ n”);
)
printf ( „\ n”);
)
)
A tömb értékeit dinamikusan vette át.A követett lépések a következők:
- A felhasználót kérte, hogy írja be a törlendő sor számát (indexét).
- A tömbszintek, sorok és oszlopok hurok iterációjának felhasználása. Összehasonlítottuk, hogy a sor száma és a felhasználói beviteli szám megegyezik-e.
- Ha ezek megegyeznek, és ha a sor száma kisebb, mint a tömb mérete, akkor a következő sort nyomtatjuk ki. Máskülönben a sort úgy nyomtatjuk, ahogy van.
- Mivel a tömb szintjén semmilyen feltétel nem volt, a megadott sorszámot mindkét tömbszintről töröljük.
A kimenet a következő:
Mi lenne, ha megadnánk a sor számát a tömb határán kívül?
A teljes tömb kinyomtatásával nem fogja megtalálni a sort a program törlésére és kilépésére.
Mint már ismert, dinamikusan deklarálhatjuk a sorok és oszlopok számát is, és ennek megfelelően megírhatjuk a programot.
Nem tűnik egyszerűnek és könnyen megtanulhatónak?
Gyakorlatként megpróbálhatja törölni egy adott elemet a 3d tömbből?
Következtetés
Ebben a szakaszban megtanultuk a háromdimenziós tömbök alapvető műveleteit.
A 3D tömb sok 2D-tömb-készletből áll. Amint láttuk, hogy a sakktábla egy 2D-s példa, ha sok sakktáblát helyezünk el egymással, akkor a 3D-s tömb először kiválaszthatja a sakktáblát, amellyel játszani kíván, majd keresse meg a sakktábla sorát és oszlopát.
Próbálja meg megoldani a 3d tömbök alapvető műveleteit, és érezd jól magad a C tanulásban.
Ajánlott cikkek
Ez egy útmutató a 3D tömbökhez a C-ben. Itt tárgyaljuk egy 3D tömb inicializálását, amely hasonló a 2D tömbhöz és a tömb elemeinek. A következő cikkben további információkat is megnézhet -
- Tömbök R-ben
- Adattípusok a MATLAB-ban
- Hogyan hozzunk létre tömböt a C # -ben?
- Hogyan definiálták a 3D-tömbök a Java-ban?
- Tömbök a PHP-ben