Az egydimenziós (1D) és a kétdimenziós (2D) tömb közötti különbség

2019

A tömb olyan változók gyűjteménye, amelyek hasonló adattípusokból állnak, és egy közönséges névvel hivatkoznak. A tömb egy adott elemét egy adott index egy indexe éri el. A Java munkái másképp működnek, mint a C ++. A vita fő témája az egydimenziós és a kétdimenziós tömb különbsége. Az egydimenziós tömb az azonos adattípusú változók listája, míg a kétdimenziós tömb a hasonló adattípusokkal rendelkező tömbök tömbje. A C ++-nak nincs megkötve ellenőrzése a tömbökön, míg a Java szigorúan kötelező ellenőrzése a tömbökön.

Tehát kezdjük az egydimenziós és a kétdimenziós tömb különbségei között egy összehasonlító táblázattal.

Összehasonlító táblázat:

Az összehasonlítás alapja	Egydimenziós	Kétdimenziós
Alapvető	Tárolja a hasonló adattípusú elemek egyetlen listáját.	Tárolja a 'listák listáját' vagy 'tömbök tömbjét' vagy 'egydimenziós tömbök tömbjét'.
Nyilatkozat	/ * nyilatkozat C ++-ban írja be a változó_nevet [méret]; * / / * Jelentés Java-ban type_name []; változó_név = új típus [méret]; * /	/ * nyilatkozat C ++-ban type_name [size1] [méret2]; * / / * Jelentés Java-ban type_name = new int [méret1] [méret2]; * /
Alternatív nyilatkozat	/ * Java-ban int [] a = új int [10]; * /	/ * Java-ban int [] [] a = új int [10] [20]; * /
Teljes méret bájtokban	Összes bájt = méret (tömbváltozó adattípusa) * tömb mérete.	Összes bájt = méret (a tömbváltozó adattípusa) * az első index * mérete a második index méretének.
Fogadó paraméter	Egy mutatóban, méretű tömbben vagy nem méretezett tömbben fogadható.	A befogadó paraméternek meg kell határoznia egy tömb jobb szélességét.
Méretek	Egydimenziós.	Kétdimenziós.

Egydimenziós tömb meghatározása (1-D tömb)

Az egydimenziós vagy egydimenziós tömböt a "hasonló adattípusok változóinak listája" -nek tekintjük, és minden változó egyértelműen hozzáférhető, ha az indexet négyszögletes zárójelben adja meg, amelyet a tömb neve követ.

A C ++-ban a mérettel rendelkező tömbváltozó deklarációja elegendő ahhoz, hogy a memóriában helyet biztosítson számukra. Java-ban ez két lépésben érhető el. Először meg kell adnia a kívánt típusú változót. Másodszor, meg kell osztanod a memóriát, hogy a tömböt „új” használatával tartsuk, és hozzárendeljük a deklarált tömbváltozóhoz. Ezért a tömbök dinamikusan vannak kijelölve Java-ban.

Beszéljünk C ++ kontextusban

 // C ++ típusú változó_név [méret];

Itt a típus kijelöli a tömbváltozó adattípusát, és a méret határozza meg a tömbben tárolt elemek számát.

Például, ha egy tömböt szeretnénk bejelenteni, amely az év minden hónapjának egyenlegét tartalmazza.

 // példa int month_balance [12];

A hónap _balance a tömbváltozó, amely a 12 egész számot fogja meg, ami az egyes hónapok egyenlegét mutatja. Most, ha el akarjuk érni az „április” hónap egyenlegét, egyszerűen meg kellett említenünk a változó nevét, majd a szögletes zárójelet, amely az április hónapra vonatkozó indexértéket tartalmazza, azaz a „month_balance [3]”. De mivel az „április” az év negyedik hónapja, de „[3]” -et említünk, mert minden tömbben az első elem indexe 0.

Java-ban ez megtörténhet

 // nyilatkozat Java típusú változó_neve []; változó_név = új típus [méret];

Itt kezdetben egy tömbváltozót jelentettünk meg a típusával, majd az új és a hozzárendelt „új” hozzárendelést a kijelölt tömbváltozóhoz adtuk. Tegyük fel a fenti példát, ha egy tömböt szeretnénk kimutatni, amely az év minden hónapjában tartalmazza az egyensúlyt.

 // példa int month_balance []; month_balance = new int [12];

Itt az „új” a memóriát a „month_balance” tömbváltozóhoz rendeli, így most a mont_balance most 12 egész értékre fogja tárolni a memóriát.

A tömböket inicializálhatjuk, amikor bejelentik őket. A tömb inicializáló a vesszővel elválasztott értékek, amelyeket göndör zárójelek vesznek körül.
//példa

 int month_balance = {100, 500, 200, 750, 850, 250, 630, 248, 790, 360, 450, 180};

A kétdimenziós tömb meghatározása (2-D tömb)

Mind a C ++, mind a Java támogatja a többdimenziós tömböt. A többdimenziós tömb egyik legegyszerűbb formája egy kétdimenziós tömb vagy 2-D tömb. A kétdimenziós tömb a tömbök vagy az egydimenziós tömbök tömbje. A kétdimenziós tömbváltozó deklarálásához meg kell adnunk a tömb nevét, majd két szögletes zárójelet, ahol a második index a szögletes zárójelek második csoportja.

A kétdimenziós tömböt a sor-oszlop mátrix formában tároljuk, ahol az első index a sor és a második index az oszlopot jelzi. A tömb második vagy jobb oldali indexe nagyon gyorsan változik az első vagy bal oldali indexhez képest, miközben egy tömb elemeit használja.

A C ++-ban a kétdimenziós tömböt mint:

 // nyilatkozat C ++ típusú változó_neve [méret1] [méret2];

Például szeretnénk tárolni az egyenleget minden 30 napban az év minden hónapjában, egy 2-D tömbben.

 // példa int month_balance [12] [30];

Java-ban a kétdimenziós tömböt a

 // nyilatkozat Java típusú változó_név = új int [méret1] [méret2]; // példa int month_balance = new int [12] [30];

Mivel nem tudjuk átadni a teljes tömböt paraméterként egy függvénynek, egy sor mutatót kapunk a tömb első elemére. A kétdimenziós tömböt befogadó argumentumnak meg kell határoznia, hogy ez a leginkább megfelelő dimenzió. A jobb oldali dimenzióra azért van szükség, mert a fordítónak szüksége van rá, hogy megerősítse az egyes sorok hosszát, ha megfelelően szeretné indexelni a tömböt. Ha a jobb oldali indexet nem említik, a fordító nem tudja meghatározni, hogy hol kezdődik a következő sor.

 // példa Java void receptioning_funct (int a [] [10]) {. . . }

Amikor a memóriát dinamikusan osztjuk a kétdimenziós tömbre Java-ban, a bal oldali index meg van adva, és a fennmaradó méretek külön rendelhetők, azaz a tömb összes sora nem lehet azonos méretű.

 // példa Java int month_balance = new int [12] []; month_balance [0] = új int [31]; month_balance [1] = új int [28]; month_balance [2] = új int [31]; month_balance [3] = új int [30]; month_balance [4] = új int [31]; month_balance [5] = új int [30]; month_balance [6] = új int [31]; month_balance [7] = új int [30]; month_balance [8] = új int [31]; month_balance [9] = új int [30]; month_balance [10] = új int [31]; month_balance [11] = új int [30]; month_balance [12] = új int [31];

De ennek nincs előnye.

Az egydimenziós és kétdimenziós tömb legfontosabb különbségei

Az egydimenziós tömb egy olyan lista, amelynek elemei hasonló adattípusúak. Másrészt a kétdimenziós tömb egy olyan lista, amelynek elemei a hasonló adattípus tömbje.
A C ++-ban, amikor az egydimenziós tömböt a fogadó függvény paramétere fogadja, nem szükséges megemlíteni a tömb méretét, mivel a fordító megérti, hogy a típus tömbje (a megadott adattípus mellett) bizonyos hosszúságú be kell fogadni. Kétdimenziós tömbben a második vagy a jobb oldali indexet kell megadni, mivel a fordítónak tudnia kell, hogy egy sor vége és egy új sor kezdődik.
A C ++-ban az egydimenziós tömböt az indexelt sorrendben egymás melletti memóriahelyen tárolják, míg a kétdimenziós tömböt a szomszédos memóriahelyen is tárolják, de mivel kétdimenziós tömbben több sor található, az első sor után egy második és a harmadik, és így tovább.

Jegyzet:

Mindkét, egydimenziós tömb, valamint a kétdimenziós tömb átvitele egy függvényhez hasonló, azaz mindkettőt csak a tömb neve adja át

 // példa pass_funt (name_of_array);

Következtetés:

Az Egydimenziós és kétdimenziós tömbben az index nagyon fontos szerepet játszik, mivel ez az egyetlen dolog, amely specifikusan azonosítja a tömbben lévő elemet. Mind az egydimenziós, mind a kétdimenziós tömböt a nyilatkozatuk idején inicializálhatjuk.