Hogyan néz ki egy tömb c. Statikus tömb: deklaráció, kitöltés, használat. Kezdeti tömb inicializálása

Utolsó frissítés: 17.09.2017

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 jön a tömb neve, majd be szögletes zárójelek a mérete. 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);

Értékek benne göndör fogszabályozó inicializátoroknak 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 stringgel 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 a tömb definiált, akkor hozzáférhetünk egyedi elemek index szerint. 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 használatával 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 egyes altömbből az alszámokban az egyes elemeit a számváltozóba kapjuk, és ennek értékét kiadjuk a konzolba.

Tegyük fel, hogy nagy mennyiségű azonos típusú adattal kell dolgoznunk. Például egy inga koordinátáinak ezer mérése van bizonyos időlépéssel. 1000 változó létrehozása az összes érték tárolására nagyon... nehézkes. Ehelyett sok azonos típusú adat kombinálható egy név alatt, és minden egyes elem elérhető a sorozatszámával.
Egy tömb C-ben a következőképpen definiálható
<тип> <имя массива>[<размер>];
Például,
int a;
nevű tömböt kapunk a, amely száz típusú elemet tartalmaz int. A változókhoz hasonlóan a tömb is tartalmaz szemetet.
Az első elem eléréséhez írja be a számát (indexét) szögletes zárójelbe. Például

#beleértve #beleértve void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Az első elem indexszáma 0. Fontos megérteni, hogy miért. A következőkben a számítógép memóriáját szalagként fogjuk ábrázolni. A tömbnév egy mutató arra a memóriacímre, ahol a tömbelemek találhatók.

Rizs. 1 A tömb az első elem címét tárolja. Az i elem indexe i*sizeof(type) byte eltolás az elejétől

A tömb index azt jelzi, hogy hány bájtot kell eltolni a tömb elejétől a kívánt elem eléréséhez. Például ha a tömb A típusa van int, akkor A azt jelenti, hogy 10*sizeof(int) byte-ot eltoltunk az elejéhez képest. Az első elem a legelején van, és eltolása 0*sizeof(int) .
C-ben egy tömb nem tárolja a méretét, és nem ellenőrzi a tömb indexének helyességét. Ez azt jelenti, hogy kiléphet a tömbből, és hozzáférhet a tömb utolsó eleménél távolabbi (vagy közelebbi) memóriához.

A tömb kezdeti inicializálása.

Írjunk egy egyszerű programot. Hozzunk létre egy tömböt, majd keressük meg a maximális elemét.

#beleértve #beleértve void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); előjel nélküli i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Nézzünk egy példát. Először létrehozzuk a tömböt, és létrehozáskor inicializáljuk. Ezt követően a maximálisan talált elemhez rendeljük a tömb első elemének értékét.

Max = a;

Ezután végigmegyünk a tömbön. Mivel az első elemet már megnéztük (1-es indexe van), nincs értelme újra megnézni.
Ugyanez a példa, csak most a felhasználó adja meg az értékeket

#beleértve #beleértve void main() ( int a; előjel nélküli i; int max; printf("Írjon be 10 számot\n"); for (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] >max) ( max = a[i]; ) ) printf("max elem %d", max); getch(); )

Ha az inicializálás során kevesebb értéket adunk meg, mint a tömb mérete, a fennmaradó elemeket nullákkal töltjük fel.

#beleértve #beleértve void main() ( int a = (1,2,3); előjel nélküli i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Ha a teljes tömböt nullákkal kell kitöltenie, akkor írjon

Int a = (0);

Nem kell például kifejezetten megadnia a tömb méretét

Int a = (1, 2, 3);

a tömb mérete 3 lesz

Tömb mérete

A C-beli tömbnek állandó méretűnek kell lennie. Ez azt jelenti, hogy lehetetlen például a felhasználótól kérni egy méretet, majd ezt a méretet egy tömbre állítani.

Printf("Adja meg a tömb hosszát"); scanf("%d", &length); ( lebegő x; )

A dinamikus tömbök létrehozásáról a mutatókkal és a memóriával végzett munka során lesz még szó.
Bizonyos esetekben a függvény segítségével megtudhatja a tömb méretét mérete.

#beleértve #beleértve void main() ( int A; //sizeof a teljes tömb méretét adja vissza bájtban //Az elemek számának meghatározásához //ossza el a tömb méretét az elem méretével int size = sizeof(A) / sizeof(int); printf("A tömb mérete: %d", méret); getch(); )

De ez nem valószínű, hogy hasznos lesz. Amikor egy tömböt argumentumként adunk át egy függvénynek, a rendszer egy mutatót ad át, így a tömb mérete nem lesz ismert.
A statikus tömbök akkor hasznosak, ha az elemek száma előre ismert. Gyors, de bizonytalan hozzáférést biztosítanak az elemekhez.

Tömb túlcsordulás

Reméljük, megvan ez a kód

Int A; int i; for (i=0; i<=10; i++) { A[i] = 1; }

Itt van egy hurok számára hibával van megadva. A fordítóprogramok néhány régebbi verziójában ez a kód ismétlődően fut. A lényeg az, hogy a változó én a fordítás során közvetlenül a tömb után került elhelyezésre A. Amikor a tömb túllépte a határokat, a számláló 1-re állt.
A tömbök nem biztonságosak, mivel az indexel való helytelen munka a memória tetszőleges részéhez való hozzáféréshez vezethet (Elméletileg. A modern fordítók maguk gondoskodnak arról, hogy ne ássunk bele valaki más memóriájába).
Ha tömbökkel dolgozik, gondoskodnia kell arról, hogy a számláló ne haladja meg a tömb méretét, és ne legyen negatív. Ehhez legalább

• 1. Használja a size_t típust az indexeléshez. Megvédi Önt a negatív értékektől, és mindig elegendő lesz bármilyen méretű tömbhöz.
• 2. Ne feledje, hogy a tömb nulláról kezdődik.
• 3. A tömb utolsó elemének indexe van (a tömb mérete 1)

Példák

Íme néhány tipikus példa a tömbökkel való munkára
1. Fordítsa meg a tömböt.

#beleértve #beleértve //Ez egy makró. A kódban a MÉRET helyére 10u lép #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); előjel nélküli i, j; // számlálja az előjel nélküli felét; //a tömb közepe előjel nélküli tmp; //ideiglenes változó az értékek cseréjéhez half = SIZE / 2; //Az egyik számláló balról jobbra, a másik jobbról balra megy (i = 0, j = MÉRET - 1; i< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Itt van egy számodra ismeretlen design

#define MÉRET 10u

makró. A kód során az előfeldolgozó automatikusan lecseréli a SIZE minden előfordulását 10u-ra.
2. A felhasználó által kiválasztott elem törlése.

#beleértve #beleértve #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); előjel nélküli i; //számláló int index; //a felhasználó által beírt index / /Kimeneti tömb ehhez: (i = 0; i< SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index >0 && index< SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

Ebben az esetben természetesen az elem nem törlődik. A tömb mérete ugyanaz marad, mint korábban. Egyszerűen felülírjuk a törlendő elemet a következővel, és SIZE-1 elemeket adunk ki.
3. A felhasználó értékeket ír be a tömbbe. Ezt követően nyomtassa ki az összes általa megadott értéket.
Adjon meg a felhasználónak véges számú elemet, mondjuk 10-et. Ekkor előre tudható, hogy összesen legfeljebb 10 különböző érték lesz. Valahányszor a felhasználó beír egy számot, végigmegyünk a tömbön és ellenőrizzük hogy beírtak-e ilyen számot.

#beleértve #beleértve #define SIZE 10u void main() ( int A = (0); előjel nélküli i, j; int számláló = 1; //hány különböző szám van beírva. Legalább egy. int bemenet; int wasntFound; //jelölje meg, hogy a a beírt szám nem található //Írja be az első számot. Még nem található. printf("0. "); scanf("%d", &A); for (i = 1; i< SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. A felhasználó beír egy számot - a mérések számát (2-től 10-ig). Ezt követően beírja az összes mérést. A program megjeleníti az átlagértéket, a szórást és a hibát.

#beleértve #beleértve #beleértve #define SIZE 20u void main() ( //A tanuló együtthatók két dimenzióból indulnak ki const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do ( printf("Adja meg a mérések számát "); scanf("%u", &limit); if (limit > 1 && limit< 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Array buborék rendezés

#beleértve #beleértve #define SIZE 10 #define false 0 #define true !false void main() ( float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0 f); float tmp; előjel nélküli i, j; char flag; //Tömb megjelenítése az (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >a) ( tmp = a[i]; a[i] = a; a = tmp; flag = igaz; ) ) ) while(zászló == igaz); //Kiírja a rendezett tömböt az (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Keverje össze a tömböt. Ehhez használjuk az algoritmust

A tömbök rendkívül fontos téma a C++-ban. Nagyon gyakran használják a programokban, és alaposan meg kell érteni ezt a témát. Azonnal boldoggá teszlek - a tömbök megértése és használatának megtanulása még egy kezdő számára is meglehetősen egyszerű.

Tehát miért van szükség tömbökre és mik ezek? Mostanra már jól tudja, hogy a programadatok a . De előfordul, hogy egy programnak több száz (vagy még több) változót kell tárolnia azonos típusú adatokból, és dolgoznia kell velük - értékeket kell rendelnie, módosítania stb.

Például tárolnia kell a sorok sorszámát. Egyetértek – bárki megrémülne attól a gondolattól, hogy ötszáz int típusú változót hozzon létre, mindegyiknek egyedi nevet adjon, és 1 és 500 közötti értéket rendeljen hozzá. (Már félek :) Ebben az esetben a tömbök egyszerűen megmentenek minket.

Jegyezzük meg a főbb pontokat, és térjünk át egy gyakorlati példára:

• A C++ tömbje bizonyos számú azonos típusú, azonos nevű változó gyűjteménye. Például, int tömb ;. Ez a bejegyzés azt jelenti, hogy deklaráltunk egy nevű tömböt sor, melyik tartalmaz 3 típusú változók int ;
• a tömbváltozókat elemeknek nevezzük;
• Minden elemnek saját egyedi indexe van - saját sorozatszáma. Egy index segítségével elérhetünk egy adott elemet. FONTOS - a tömbelemek indexelése 0-tól kezdődik . Tehát a tömbben int tömb az első elemnek van indexe 0 , és az utolsó az 2 . Például egy tömb nulla elemének eléréséhez és értékének megváltoztatásához meg kell adnia a tömb nevét, és szögletes zárójelben meg kell adnia az elem indexét - tömb = 33 .

Nézzünk egy példát:

C++ tömbök

// ebben a programban méretű tömböt hozunk létre, // for ciklus segítségével a tömb összes cellájába beírunk adatokat // és azok tartalmát megjelenítjük a képernyőn #include névtér használata std; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //konstans deklarálása int firstArray; //egy tömb deklarálása elemszámmal SIZE for (int i = 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

A 12. sorban definiálunk egy egész konstanst MÉRET, amely a tömb méretét fogja tárolni (az általunk meghatározott, elemeinek számát). A 13. sorban deklarálunk egy tömböt: megadjuk a tömb celláiban tárolt adatok típusát, nevet adunk és szögletes zárójelben megadjuk a méretet.

Fontos, hogy csak konstans egész értékeket írjunk szögletes zárójelbe. Egy tömb deklarálásakor vagy azonnal meg kell adnia egy egész számot szögletes zárójelben ( int firstArray;), vagy definiáljon egy egész állandót a tömb deklarálása előtt, és adja meg ennek az állandónak a nevét szögletes zárójelben (mint a példánkban).

A második módszert akkor célszerű használni, ha a program során többször is el kell érnie a tömböt egy hurkon keresztül. Ez azzal magyarázható, hogy amikor deklarálunk egy ciklust, megadhatjuk benne a számláló értékre váltásának feltételét. MÉRET .

Képzeljük csak el, hogy a tömb méretét 10 elemről 200-ra kell módosítanunk. Ebben az esetben csak az egész konstans értékét kell megváltoztatnunk, és így automatikusan új méretértékekkel helyettesítjük mindkét tömbben és a program összes ciklusában.

Példánkban megpróbálhat bármilyen más számot hozzáadni a konstanshoz MÉRET. És látni fogja, hogy a program nagyszerűen fog működni - létrehoz egy tömböt annyi elemmel, amennyit megad, beírja az adatokat, és megjeleníti a képernyőn.

És ha a tömb nagyon kicsi, például 5 elemből áll, akkor deklaráció után azonnal inicializálhatja:

Tehát a 0 indexű elem – firstArray– érték lesz hozzárendelve 11 , és a tömb utolsó eleme firstArray- jelentése 1 5 . Van egy ilyen trükk - nem jelezheti a tömb méretét szögletes zárójelben, és ezt írja be:

Az előző bejegyzés ezzel egyenértékű. Csak a második esetben fogja a fordító automatikusan kiszámítani a tömb méretét a kapcsos zárójelben lévő adatok mennyisége alapján.

Ezenkívül a tömbelemek kezdeti inicializálása során, amikor a tömböt meg kell tisztítani a „szeméttől” (más programokból származó maradék adatok a memóriában), jobb, ha azonnal értéket rendel minden elemhez. 0 . Ez így néz ki:

Emlékeztetni kell arra, hogy az ilyen inicializálás csak nullákkal való kitöltéshez lehetséges. Ha a tömbelemeket más számokkal kell kitöltenie, jobb, ha hurkot használ. C++11-ben (kódolási szabvány) a lista inicializálása (inicializálás göndör kapcsos zárójelekkel) használatakor még az előjelet is eldobhatja = .

Egy tömb létrehozásakor még egy inicializálási technikát szeretnék bemutatni. Például egy 30 elemből álló tömbhöz meg kell adnunk az értékeket 33 És 44 csak indexszel rendelkező cellákra 0 És 1 ennek megfelelően, a többit pedig töltse fel nullákkal. Akkor ezt csináljuk:

ezek az adatok a nulla és az első cellákba kerülnek, a többi pedig automatikusan felveszi az értéket 0 .

Az operátor segítségével egy tömb kitöltését is megszervezheti cin:

for (int i = 0; i< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> firstArray[i]; )

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.

A tömb egy adatstruktúra, amely azonos típusú cellák csoportjaként jelenik meg, egyetlen név alatt egyesülve. A tömbök nagy mennyiségű azonos típusú adat feldolgozására szolgálnak. A tömb neve a pointerek, kicsit később elmondom. Egy tömb egyedi adatcelláját tömbelemnek nevezzük. Egy tömb elemei bármilyen típusú adatok lehetnek. A tömbök egy vagy több dimenzióval rendelkezhetnek. A dimenziók számától függően a tömbök egydimenziós tömbökre, kétdimenziós tömbökre, háromdimenziós tömbökre vannak osztva, és így tovább egészen n-dimenziós tömbig. A programozás során leggyakrabban egy- és kétdimenziós tömböket használnak, ezért csak ezeket a tömböket fogjuk figyelembe venni.

Egydimenziós tömbök C++ nyelven

Az egydimenziós tömb egy olyan tömb, amelynek egy paramétere jellemzi az egydimenziós tömb elemeinek számát. Valójában az egydimenziós tömb olyan tömb, amelynek csak egy sora és n számú oszlopa lehet. Az egydimenziós tömb oszlopai a tömb elemei. Az 1. ábra egy egész szám egydimenziós tömb szerkezetét mutatja a. Ennek a tömbnek a mérete 16 cella.

1. ábra - Tömbök C++ nyelven

Vegye figyelembe, hogy egy egydimenziós tömb maximális indexe a 15, de a tömb mérete 16 cella, mivel a tömb celláinak számozása mindig 0-tól kezdődik. A cella index egy nem negatív egész szám, amellyel a tömb minden celláját elérheti és bármilyen műveletet végrehajthat rajta ( sejt).

//szintaxis egydimenziós tömb deklarálásához C++-ban: /*adattípus*/ /*egydimenziós tömb neve*/; //példa az 1. ábrán látható egydimenziós tömb deklarálására: int a;

ahol int egész szám;

A egy egydimenziós tömb neve;
A 16 egy egydimenziós tömb mérete, 16 cella.

Mindig közvetlenül a tömb neve után szögletes zárójelek vannak, amelyekben az egydimenziós tömb mérete van megadva, ez különbözteti meg a tömböt az összes többi változótól.

//egydimenziós tömbök deklarálásának másik módja int mas, a;

Két egydimenziós tömb mas és a 10-es, illetve 16-os mérettel van deklarálva. Ezenkívül ebben a deklarációs módszerben minden tömbnek azonos adattípusa lesz, esetünkben - int.

// a tömbök deklarálva inicializálhatók: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // egydimenziós tömb inicializálása

Az egydimenziós tömb inicializálása a jel után kapcsos zárójelben történik egyenlő, minden tömbelemet vessző választ el az előzőtől.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // a tömb inicializálása méretének meghatározása nélkül.

Ebben az esetben maga a fordító határozza meg az egydimenziós tömb méretét. Egy tömb méretét csak inicializáláskor lehet elhagyni, egy tömb normál deklarálásakor meg kell adni a tömb méretét. Készítsünk egy egyszerű programot egy egydimenziós tömb feldolgozására.

// array.cpp: Meghatározza a konzolalkalmazás belépési pontját. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// kód Code::Blocks

// Dev-C++ kód

// array.cpp: Meghatározza a konzolalkalmazás belépési pontját. #beleértve névtér használata std; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

BAN BEN 10-11. sor Deklarációra és inicializálásra került egy tömb1 nevű egész egydimenziós tömb, melynek mérete 16 cella, azaz egy ilyen tömb 16 számot tud tárolni. Bármilyen tömbfeldolgozás csak ciklusokkal együtt lehetséges. Ön dönti el, hogy melyik hurkot választja a tömb feldolgozásához. De erre a feladatra ez a legalkalmasabb. A számláló változó számlálóját fogjuk használni az egydimenziós tömb tömb1 elemeinek eléréséhez. A for ciklus folytatásának feltétele szigorú egyenlőtlenségjelet tartalmaz, mivel az egydimenziós tömbtömbben nincs tizenhatod index. És mivel a cellák számozása nulláról indul, a tömbben 16 elem található.A for ciklus törzsében a cout operátor egy egydimenziós tömb elemeit írja ki (lásd 2. ábra).

Obrabotka massiva indexek elemet massiva tömb1 5 tömb1 -12 tömb1 -12 tömb1 9 tömb1 10 tömb1 0 tömb1 -9 tömb1 -12 tömb1 -1 tömb1 23 tömb1 65 tömb1 64 tömb1 11 tömb1 43 tömb1 - Bármelyik 1 billentyűt a tömb folytatásához nyomja meg a 39 gombot. . .

2. ábra - Tömbök C++ nyelven

Fejlesszünk egy másik programot egy egydimenziós tömb feldolgozására C++ nyelven. A programnak egymás után tíz beírt számot kell beolvasnia a billentyűzetről. Az összes beírt szám összeadódik, és az eredmény megjelenik a képernyőn.

// array_sum.cpp: Meghatározza a konzolalkalmazás belépési pontját. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// kód Code::Blocks

// Dev-C++ kód

// array_sum.cpp: Meghatározza a konzolalkalmazás belépési pontját. #beleértve névtér használata std; int main(int argc, char* argv) ( int array1; // egész tömb cout deklarálása<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>tömb1; // beolvassa a billentyűzetről beírt számokat<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Egy tömb feldolgozása előtt deklarálni kell, és az egydimenziós tömb mérete 10, mivel ezt a feladat feltétele határozza meg. Az összeg változóban egy egydimenziós tömb elemeinek összegét fogjuk felhalmozni. Az első for ciklus kitölti a deklarált egydimenziós tömböt a billentyűzetről beírt számokkal, 12-13. sor. A számlálóváltozó az egydimenziós tömb1 elemeinek szekvenciális elérésére szolgál, a 0 indextől kezdve a 9. indexig. A második for ciklus a tömb elemeit jeleníti meg, 15-16. sor. A harmadik for ciklus szekvenciálisan beolvassa egy egydimenziós tömb elemeit, és összeadja azokat, az összeg az összeg változóban halmozódik fel. 17-18. sor. A program eredménye a 3. ábrán látható.

Írja be az elementi massiva értéket: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 A folytatáshoz nyomja meg bármelyik billentyűt. . .

3. ábra - Tömbök C++ nyelven

Először mind a 10 számot egymás után beírtuk, majd egy egydimenziós tömböt jelenítettünk meg, és a tömbben lévő számok összegét nyomtattuk ki.

Kétdimenziós tömbök C++ nyelven

Eddig az egydimenziós tömböket vettük figyelembe, amelyekre nem mindig lehet korlátozni. Tegyük fel, hogy fel kell dolgoznia néhány adatot egy táblázatból. A táblázatnak két jellemzője van: a sorok száma és az oszlopok száma. A kétdimenziós tömbben is a tömbelemek számán kívül vannak olyan jellemzők, mint a kétdimenziós tömb sorainak és oszlopainak száma. Vagyis vizuálisan a kétdimenziós tömb egy szabályos táblázat, sorokkal és oszlopokkal. Valójában a kétdimenziós tömb egydimenziós tömbök egydimenziós tömbje. Egy a névre keresztelt kétdimenziós tömb szerkezete, amelynek mérete m x n, az alábbiakban látható (lásd a 4. ábrát).

4. ábra - Tömbök C++ nyelven

ahol m egy kétdimenziós tömb sorainak száma;
n egy kétdimenziós tömb oszlopainak száma;
m * n — a tömbelemek száma.

// szintaxis kétdimenziós tömb deklarálásához /*adattípus*/ /*tömbnév*/;

Kétdimenziós tömb deklarálásakor, valamint egydimenziós tömb deklarálásakor mindenekelőtt meg kell adnia:

• adattípus;
• tömbnév.

Ezt követően az első szögletes zárójelek a kétdimenziós tömb sorainak számát, a második szögletes zárójelek a kétdimenziós tömb oszlopainak számát jelzik. A kétdimenziós tömböt vizuálisan egy második szögletes zárójelpár különbözteti meg az egydimenziós tömbtől. Nézzünk egy példát egy kétdimenziós tömb deklarálására. Tegyük fel, hogy deklarálnunk kell egy kétdimenziós tömböt, amelynek elemszáma 15. Ebben az esetben egy kétdimenziós tömbnek lehet három sora és öt oszlopa vagy öt sora és három oszlopa.

// példa deklaráció egy kétdimenziós tömbről: int a;

• a az egész tömb neve
• az első szögletes zárójelben lévő szám a kétdimenziós tömb sorainak számát jelzi, ebben az esetben 5 van;
• a második szögletes zárójelben lévő szám a kétdimenziós tömb oszlopainak számát jelöli, ebben az esetben 3 van.

// kétdimenziós tömb inicializálása: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Ez a tömb 5 sorból és 3 oszlopból áll. a hozzárendelési jel után általános göndör zárójelek kerülnek, amelyekbe annyi pár göndör zárójel kerül, ahány vonalnak kell lennie egy kétdimenziós tömbben, és ezeket a zárójeleket vesszővel választjuk el. Minden kapcsos zárójelpárba írja be egy kétdimenziós tömb elemeit vesszővel elválasztva. Minden göndör kapcsos zárójelben az elemek számának azonosnak kell lennie. Mivel öt sor van a tömbben, van öt belső pár zárójel is. Három elemet írunk a belső zárójelbe, mivel az oszlopok száma három. Grafikusan a tömbünk kétdimenziós táblázatnak fog kinézni (lásd 5. ábra).

5. ábra - Tömbök C++ nyelven

Egy kétdimenziós tömb minden cellájában a az érték látható, ennek a cellának a címe a jobb alsó sarokban. A kétdimenziós tömb cellacíme a tömb neve, sorszáma és oszlopszáma.

Fejlesszünk ki egy egyszerű programot egy kétdimenziós tömb feldolgozására, az úgynevezett „Labyrinth”. A labirintust egy kétdimenziós tömb alapján kell megépíteni. A labirintus méretét saját belátásunk szerint választjuk meg.

// array2.cpp: Meghatározza a konzolalkalmazás belépési pontját. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) else cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kód Code::Blocks

// Dev-C++ kód

// array2.cpp: Meghatározza a konzolalkalmazás belépési pontját. #beleértve névtér használata std; int main(int argc, char* argv) ( // 1-feltételesen „a labirintus falai” // 2- „helyes út, kilépés a labirintusból” // 0- „hamis út” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // egy kétdimenziós tömb inicializálása ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1), (1,2) ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // két hurok - belső és külső, amelyek a tömb minden elemét elérik a következőhöz: (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) else cout<< " "; // вывести два пробела cout << endl; } return 0; }

A helyes és a hamis elérési út jelölhető ugyanazzal a számmal, például nullával, de az érthetőség kedvéért a helyes elérési utat 2-es számmal jelöljük. A tömb inicializálása kézzel történt, csak a program egyszerűsítése érdekében. Mivel a program kétdimenziós tömböt dolgoz fel, két hurok szükséges a kétdimenziós tömb elemei közötti váltáshoz. Az első for ciklus egy kétdimenziós tömb sorai között vált. Mivel egy kétdimenziós tömbben 33 sor van, az i számlálóváltozó 0-ról 33-ra növekszik, 46. ​​sor. Az első hurkon belül van egy for ciklus, amely egy kétdimenziós tömb sorelemein mozog. A második for ciklus törzsében egy unáris adattípus átalakítási műveletet hajtanak végre benne - static_cast<>() , amely a 176-os karakterszámot írja ki. Az adattípus-konverziós művelet megkettőződik a labirintus szélességének növelése érdekében. A program eredménye (lásd 6. ábra).

6. ábra - Tömbök C++ nyelven