Kérjük, függessze fel az AdBlockot ezen az oldalon.

A tömb a legegyszerűbb összetett adattípus. Amikor a változókat tárgyaltuk, jó analógiát találtunk egy dobozzal. Térjünk vissza rá. Ha egy változó egy doboz, akkor egy tömb több számozott azonos dobozból áll, amelyeknek ugyanaz a neve, és csak a sorozatszámuk különbözik egymástól.

1. ábra Változók és tömbök. Analógia a dobozokkal.

A fenti képen három tömb látható:

• egy arr_int nevű 8 elemű egész tömb
• 11 elemből álló float tömb arr_float néven
• egy arr_char nevű 6 elemű karaktertömb

A tömbnek, akárcsak a változónak, saját neve és adattípusa van. Ezen kívül a tömbnek is van egy további jellemző– tömb mérete. Egy tömb mérete a benne tárolható elemek száma. Dobozhasonlatunkban ez a dobozok száma.

Jegyzet!

A tömbelemek számozása nullától kezdődik, nem egytől.

Tömb deklarálása és inicializálása

Egy tömb deklarálása nagyon hasonló a változó deklarálásához. Az egyetlen különbség az, hogy szögletes zárójelben meg kell adni a tömb méretét is. Íme néhány példa:

Lista 1.

Int arr_int; double arr_float; lebegőszám;

A tömbnévre a változónévre vonatkozó korlátozásokhoz hasonló korlátozások vonatkoznak.

Tömb elnevezési szabály

A tömb neve karakterekből, számokból és aláhúzásjelből álló "_" karaktersorozat, amely betűvel kezdődik. A betűk nagybetűi fontosak.

Íme néhány további példa a tömbdeklarációra:

2. lista.

Int évfolyamok, sorrend; dupla árak;

Egy tömbhöz, mint minden változóhoz, deklaráláskor kezdőértékeket lehet rendelni. Ha a tömbelemekhez nincs hozzárendelve érték, akkor a rendszeres változókhoz hasonlóan szemetet tárolnak.

3. lista.

Int arr_int = (2, 5, 5, 3, 4); double arr_float = (1,2, -2,3, 4,5, 3,83, 0,01, -0,12, 44,2, 123,7, 23,44, -3,7, 7);

Ha hozzá kell rendelni nulla értékek a tömb összes elemét, akkor ezt a következőképpen teheti meg:

4. lista.

Double arr = (0);

Egyedi tömbelemekkel való munka

Egy adott tömbelemre való hivatkozáshoz szögletes zárójelbe kell írni annak nevét és sorozatszámát. Ne felejtsük el, hogy a számozás nullától kezdődik, nem egytől.

Jelenítsük meg például egy ötelemű tömb elemeit a képernyőn.

5. lista.

#beleértve int main(void)( int arr = (2, 4, 3, 5, 5); printf("%d %d %d %d %d\n",arr, arr, arr, arr, arr); return (0); )

Természetesen, ha a tömb nagyon nagy, akkor így elemenként kiadni akkor is élvezet. És ezt senki sem csinálja kis tömbökkel. Jobb és helyesebb a hurkok használata. Például:

6. lista.

#beleértve int main(void)( int arr = (0); for(int i = 0; i< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

Az első ciklusban lévő program az első száz páros számot egy tömbbe menti, a második ciklusban pedig megjeleníti a képernyőn.

Új eszközeinkkel felvértezve írjuk át programunkat az óra elejétől úgy, hogy az egy tömb segítségével tárolja a véletlenszámú statisztikákat.

Lista 7.

#beleértve #beleértve #beleértve int main(void) ( srand(time(NULL)); int count = (0); int rand_szám; for (int i = 0; i< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Ügyeljen a programban használt technikára.
A tömb nulla eleme a 0 szám előfordulásának számát tárolja, az első elem - az 1-es szám előfordulásainak számát, a második elem - a 2-es számot. Vagyis maga a generált szám lehetővé teszi annak meghatározását, hogy a tömb melyik eleméhez kell hozzáadni egyet. Ezért nincs szükség kapcsolókiválasztási utasításra. Kényelmes, nem?

Utolsó frissítés: 2017.09.17

Egy tömb azonos típusú adatok halmazát képviseli. A tömb formális meghatározása a következő:

Változó_típusú tömbnév [tömb_hossza]

A változó típusa után következik a tömb neve, majd a mérete szögletes zárójelben. Például definiáljunk egy 4 számból álló tömböt:

Int számok;

Ez a tömb négy számot tartalmaz, de ezeknek a számoknak mindegyike meghatározatlan értékkel rendelkezik. Azonban elvégezhetjük az inicializálást, és néhány kezdeti értéket rendelhetünk ezekhez a számokhoz kapcsos zárójelekkel:

Int számok = (1,2,3,4);

A göndör kapcsos zárójelben lévő értékeket inicializálóknak is nevezik. Ha kevesebb inicializátor van, mint ahány elem van a tömbben, akkor a rendszer inicializálókat használ az első elemekhez. Ha több inicializáló van, mint elem a tömbben, akkor a fordítás során hiba történik:

Int számok = (1, 2, 3, 4, 5, 6);

Itt a tömb mérete 4, de 6 érték kerül átadásra.

Ha a tömb mérete nincs kifejezetten megadva, az inicializálók számából következik:

Int számok = (1, 2, 3, 4, 5, 6);

Ebben az esetben a tömb 6 elemből áll.

A karaktertömbök inicializálásának megvannak a maga sajátosságai. Egy inicializáló készletet és egy karakterláncot is átadhatunk egy karaktertömbnek:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "világ";

Sőt, a második esetben az s2 tömbnek nem 5 eleme lesz, hanem 6, mivel egy karakterlánccal inicializálva a „\0” null karakter automatikusan hozzáadódik a karaktertömbhöz.

Ebben az esetben egy tömb hozzárendelése egy másik tömbhöz nem megengedett:

Int szám1 = (1,2,3,4,5); int számok2 = számok1; // hiba szám2 = szám1; // hiba

Ha egy tömb definiált, akkor az egyes elemeit index alapján érhetjük el. Az indexek nulláról indulnak, így az első elem eléréséhez a 0 indexet kell használnunk. Ha egy elemet indexenként érünk el, megkaphatjuk az értékét vagy megváltoztathatjuk:

#beleértve int main() ( int számok = (1,2,3,4); int első_szám = számok; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

A tömbelemek száma egy konstanssal is meghatározható:

Const int n = 4; int számok[n] = (1,2,3,4);

Iteráció tömbökön keresztül

A hurkok segítségével a teljes tömbön keresztül iterálhat, és indexeken keresztül hozzáférhet annak elemeihez:

#beleértve int main() ( int számok = (1,2,3,4); int méret =(számok)/sizeof(számok); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Egy tömbön való hurkoláshoz először meg kell találnia a tömb hosszát. A sizeof operátor a hossz meghatározására szolgál. Lényegében egy tömb hossza megegyezik elemeinek teljes hosszával. Minden elem ugyanazt a típust képviseli, és azonos méretet foglal el a memóriában. Ezért a sizeof(numbers) kifejezés segítségével a teljes tömb hosszát találjuk meg bájtban, a sizeof(numbers) kifejezéssel pedig egy elem hosszát bájtban. A két érték elosztásával megkaphatjuk a tömb elemeinek számát. Ezután egy for ciklust használva addig iteráljuk az összes elemet, amíg az i számláló egyenlővé nem válik a tömb hosszával. Ennek eredményeként a tömb összes eleme megjelenik a konzolon:

De van egy másik formája is a for ciklusnak, amelyet kifejezetten gyűjteményekkel való munkára terveztek, beleértve a tömböket is. Ennek az űrlapnak a következő formális meghatározása van:

For(változó típusa: gyűjtemény) ( utasítások; )

Ezt az űrlapot használjuk egy tömb iterálásához:

#beleértve int main() ( int számok = (1,2,3,4); for(int szám: számok) std::cout<< number << std::endl; return 0; }

Ha egy tömbön keresztül iterál, minden iterált elem a számváltozóba kerül, amelynek értéke ciklusban kerül kinyomtatásra a konzolra.

Ha nem ismerjük a tömbben lévő objektumok típusát, akkor az automatikus specifikátort használhatjuk a típus meghatározásához:

For(auto number: numbers) std::cout<< number << std::endl;

Többdimenziós tömbök

A C++-ban az egydimenziós tömbök mellett vannak többdimenziós tömbök is. Az ilyen tömbök elemei maguk is tömbök, amelyekben az elemek tömbök is lehetnek. Például definiáljunk egy kétdimenziós számtömböt:

Int számok;

Egy ilyen tömb három elemből áll, és mindegyik elem két elemből álló tömböt képvisel. Inicializáljunk egy tömböt a következőképpen:

Int számok = ( (1, 2), (4, 5), (7, 8) );

A beágyazott göndör kapcsos zárójelek körülhatárolják az egyes alsorok elemeit. Egy ilyen tömb táblázatként is ábrázolható:

A göndör kapcsos zárójeleket az inicializálás során is elhagyhatja:

Int számok = ( 1, 2, 4, 5, 7, 8 );

Az is lehetséges, hogy nem az összes elemet inicializálja, hanem csak néhányat:

Int számok = ( (1, 2), (), (7) );

A beágyazott tömb elemeinek eléréséhez két indexre van szüksége:

Int számok = ( (1, 2), (3, 4), (5, 6) ); std::cout<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Iteráljunk egy kétdimenziós tömbön:

#beleértve int main() ( const int sorok = 3, oszlopok = 2; int számok = ( (1, 2), (3, 4), (5, 6) ); for(int i=0; i< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

A for ciklus egy másik formáját is használhatja a többdimenziós tömb elemei közötti iterációhoz:

#beleértve int main() ( const int sorok = 3, oszlopok = 2; int számok = ( (1, 2), (3, 4), (5, 6) ); for(auto &alszámok: számok) ( for(int szám : alszámok) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

A tömbben szereplő tömbök közötti iterációhoz hivatkozásokat használnak. Ez azt jelenti, hogy a for(auto &alszámok: számok) külső ciklusában az &alszámok egy altömb hivatkozást jelentenek a tömbben. A belső ciklusban a for(int szám: alszámok) minden alcsoportból az alszámokban az egyes elemeit a számváltozóba kapjuk, és annak értékét kiadjuk a konzolba.

Mik azok a tömbök C-ben?

Hogyan deklaráljunk tömböket C-ben?

Hogyan inicializáljuk a tömböket C-ben?

Tömbök C-ben a bábukhoz.

Tömbök C-ben

A C-beli tömb azonos típusú elemek gyűjteménye, amelyek index segítségével érhetők el. A C-beli tömbök elemei egymás után helyezkednek el a számítógép memóriájában.

Egy egyszerű példa egy tömb létrehozására és kitöltésére C nyelven:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0 ;)

Kapunk:

A példában egy int típusú elemeket tartalmazó tömböt deklarálunk:

itt a tömb neve nArr, a tömbelemek száma három, a tömbelem típusa int.

A tömb elemek gyűjteménye. A tömb minden elemére a számával hivatkozhatunk. A számot általában indexnek nevezik. A tömb elemei nullától kezdődően vannak számozva. Adjunk értéket a tömb első eleméhez, és az első elem indexe nulla:

Adjunk értéket a tömb második eleméhez, és a második elemnek van egy indexe:

Adjunk értéket a tömb harmadik eleméhez, és a harmadik elemnek kettős indexe van:

Amikor tömbelemeket jelenítünk meg a képernyőn, megkapjuk azok értékét. Mint ez:

printf("nArr\t=\t%d\n", nArr);

Egy tömbelem beszerzéséhez meg kell adnia a tömb nevét és az elemindexet:

Ez a tömb első eleme, mivel az első elem indexe nulla.

Adjuk hozzá a tömb harmadik elemének értékét az int a változóhoz:

a tömb harmadik elemének indexe egyenlő kettővel, mivel az indexeket nullától számítjuk.

Most az általános szabály a tömbök deklarálására C-ben: egy tömb deklarálásakor meg kell adni a nevét, az elemek típusát és az elemek számát. Az elemek száma természetes szám, azaz. az egész pozitív. A nulla nem lehet az elemek száma. Nem adhat meg változó számú tömbelemet. Íme példák a C tömbdeklarációra:

int nArr; // Egy tömb száz egész számot tartalmaz;
float farr; // Egy 5 float szám tárolására tervezett tömb deklarálásra került;
char cArr; // Egy tömb két karakter tárolására lett deklarálva;

Hiba lenne változó elemszámú tömböt deklarálni:

Int varElem;
int nArr; // Hiba! Az elemek száma nem állítható változóra;

De beállíthatja az elemek számát állandó értékkel: vagy egy közvetlen pozitív egész szám 1, 2, 3... vagy egy konstans:

Const int arrayLength = 3;
int nArr;

Amikor deklarál egy tömböt C-ben, azonnal inicializálhatja:

int nTömeg = (1, 2, 3);

Ha az összes tömbelem inicializálva van, elhagyhatja a szögletes zárójelben lévő tömbelemek számát:

int nTömeg = (1, 2, 3);

az elemek száma ebben az esetben automatikusan meghatározásra kerül.

Egy tömb elemeinek csak egy részét határozhatja meg deklaráláskor:

int nTömeg = (1, 2);

ebben a példában a tömb első két eleme inicializálva van, de a harmadik nincs meghatározva.

Példa egy karaktertömbre:

char cArr = ("S", "B", "P");

Egy tömb deklarálásakor nem adható meg egy változó elemeinek száma. De használhat változókat a tömbelemek elérésekor:

Int ind = 0;
char cr = cArr;

Ezt a hurkokkal végzett munka során használják. Példa:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

A példában az első ciklusban int típusú elemekkel töltjük ki a tömböt, a második ciklusban pedig ezeket az elemeket jelenítjük meg a képernyőn.

Tömbök

Sor azonos típusú változók gyűjteménye, amelyekre közös névvel lehet hivatkozni. A C#-ban a tömbök lehetnek egydimenziósak vagy többdimenziósak. A tömbök többféle célt szolgálnak, mivel kényelmes eszközt kínálnak a kapcsolódó változók csoportosítására.

A tömböket a C#-ban ugyanúgy használhatja, mint más programozási nyelvekben. Van azonban egy sajátosságuk: tárgyként valósítják meg őket.

Egy tömb programban való használata kétlépéses eljárást igényel, mivel a C# a tömböket objektumként valósítja meg. Először is deklarálnia kell egy változót, amely hozzáfér a tömbhöz. Másodszor pedig létre kell hoznia egy példányt a tömbből az új operátor segítségével.

Rendszer használata; a System.Collections.Generic használatával; a System.Linq; a System.Text használatával; namespace ConsoleApplication1 ( osztály Program ( static void Main(string args) ( // A tömb deklarálása int myArr = new int; // A tömb minden elemének inicializálása kézzel myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 ; foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); ) ) )

Ne feledje, hogy ha egy tömb csak deklarálva van, de nincs explicit módon inicializálva, akkor minden elem a megfelelő adattípus alapértelmezett értékére lesz beállítva (például a bool típusú tömb elemei false értékre lesznek állítva, és egy int típusú tömb 0-ra lesz állítva).

Egy tömb inicializálása

A tömb elemenkénti kitöltése mellett (ahogyan az előző példában látható), speciális tömb inicializálási szintaxissal is kitöltheti. Ehhez kapcsos zárójelben ( ) kell felsorolni a tömbben szereplő elemeket. Ez a szintaxis akkor hasznos, ha ismert méretű tömböt hoz létre, és gyorsan be kell állítania a kezdeti értékeit:

// Szintaxis egy tömb inicializálásához // a new int kulcsszó használatával myArr = new int (10,20,30,40,50); // Szintaxis tömb inicializálásához // kulcsszó használata nélkül new string info = ( "Vezetéknév", "Keresztnév", "Patronymic" ); // Használja az új kulcsszót és a kívánt méretet char symbol = new char ( "X", "Y", "Z", "M" );

Vegye figyelembe, hogy a kapcsos kapcsos zárójelek szintaxisának használatakor nem kell megadnia a tömb méretét (amint az a myArr változó létrehozásánál látható), mert a méret automatikusan a kapcsos kapcsos zárójelben lévő elemek száma alapján kerül kiszámításra. Használja a kulcsszót is új opcionális (mint az információs tömb létrehozásakor).

A var kulcsszó lehetővé teszi egy változó definiálását, hogy a fordító következtessen annak mögöttes típusára. Hasonló módon definiálhat implicit módon beírt helyi tömböket is. Ezzel a megközelítéssel új tömbváltozót definiálhat anélkül, hogy megadná a tömbben található elemek típusát. Nézzünk egy példát:

Rendszer használata; a System.Collections.Generic használatával; a System.Linq; a System.Text használatával; névtér ConsoleApplication1 ( osztály Program ( static void Main(string args) ( var arr1 = new ( 1, 2, 3 ); ); Console.WriteLine("Arr1 tömbtípus (0)",arr1.GetType()); var arr2 = new ( "Egy", "Két", "Három" ); Console.WriteLine("Tömbtípus arr2 - (0)",arr2.GetType()); Console.ReadLine(; ) ) )

Természetesen, csakúgy, mint explicit C# szintaxist használó tömb létrehozásakor, a tömb inicializálási listában megadott elemeknek azonos alaptípusúaknak kell lenniük (vagyis mindegyiknek int, string vagy MyCar kell lennie).

Objektumtömb meghatározása

A legtöbb esetben egy tömb definiálásakor a tömbben található elem típusa kifejezetten meg van adva. Bár ez első pillantásra elég egyértelműnek tűnik, van egy fontos jellemzője. A .NET típusú rendszer minden típusának középpontjában (beleértve az alapvető adattípusokat is) végső soron egy alaposztály, a System.Object áll. Az eredmény az, hogy ha objektumok tömbjét definiálja, a benne lévő elemek bármiek lehetnek:

Rendszer használata; a System.Collections.Generic használatával; a System.Linq; a System.Text használatával; névtér ConsoleApplication1 ( osztály Program ( static void Main(string args) ( // Objektumtömb deklarálása és inicializálása object arrByObject = ( true, 10, "Hello", 13.7m ); // Minden tömbtag típusának kinyomtatása a console foreach (objektum engem az arrByObject-ben) Console.WriteLine("Típus (0) - (1)",me,me.GetType()); Console.ReadLine(; ) ) )