A tömbök rendkívül fontos téma a C++-ban. A programokban nagyon gyakran használják őket, és alaposan meg kell érteni ezt a témát. Azonnal örömet okozok Önnek - 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ünk tömbökre, és mik ezek? Mostanra már nagyon jól tudja, hogy a programadatokat a . De előfordul, hogy a programnak több száz (vagy még több) azonos típusú adatváltozót kell tárolnia, és dolgoznia kell velük - értékeket rendelnie, módosítania stb.

Például el kell tárolni a sorok sorszámát. Egyetértek - bárki megijed a gondolattól, hogy ötszáz int változót kell létrehoznia, mindegyiknek egyedi nevet kell adnia, és 1 és 500 közötti értéket kell hozzárendelnie. (Már félek :) Ebben az esetben a tömbök egyszerűen megmentenek minket.

Megjegyezzük a legfontosabb dolgot, és áttérünk 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 megvan a maga egyedi indexe - a sorozatszáma. Az index segítségével egy adott elemre hivatkozhatunk. FONTOS - A tömbelem indexelése 0-tól kezdődik . Tehát 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 .

Vegyünk egy példát:

C++ tömbök

// ebben a programban méretű tömböt hozunk létre, // a for ciklus segítségével a tömb összes cellájába // beírunk adatokat és megjelenítjük azok tartalmát a képernyőn #include névtér használata std; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //konstans int firstArray deklarálása; //egy tömb deklarálása a SIZE elemek számával a következőhöz: (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árolandó adatok típusát, nevet adunk és szögletes zárójelben megadjuk a méretet.

Fontos, hogy szögletes zárójelbe csak egész állandó értékeket írjunk. 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 szám állandót a tömbdeklaráció 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ód előnyösebb, ha a program során többször is hozzá kell férni a tömbhöz egy cikluson keresztül. Ez azzal magyarázható, hogy amikor deklarálunk egy ciklust, akkor meg lehet adni a feltételt, hogy a számlálót az értékre módosítsuk MÉRET .

Képzeljük el, hogy a tömb méretét 10 elemről 200-ra kell módosítanunk. Ebben az esetben csak egy egész konstans értékét kell megváltoztatnunk, és így automatikusan új méretértékeket fogunk beszúrni a tömbbe és minden programhurokba.

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 jól 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 elég kicsi, például 5 elemű, akkor a deklaráció után azonnal inicializálhatja:

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

Az előző bejegyzés ezzel egyenértékű. Csak a második esetben a fordító automatikusan kiszámítja 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 programok maradék adatai 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. A C++11-ben (a kódolási szabvány) a lista inicializálása (inicializálás göndör kapcsos zárójelekkel) esetén még az előjel eldobása is megengedett. = .

Szeretnék még egy inicializálási módszert bemutatni egy tömb létrehozásakor. Például egy 30 elemből álló tömbhöz értékeket kell megadnunk 33 És 44 csak indexszel rendelkező cellákban 0 És 1 rendre, 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 megszervezheti egy tömb kitöltését cin:

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

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 , mik azok a mutatók, azt kicsit később elmagyarázom. Egy egyedi tömb adatcellát tömbelemnek nevezünk. A tömbelemek bármilyen típusú adatot tartalmazhatnak. 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 egy n-dimenziós tömbig. A programozás során leggyakrabban egydimenziós és kétdimenziós tömböket használnak, ezért csak ezeket a tömböket vesszük figyelembe.

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

Az egydimenziós tömb egy olyan tömb, amelynek egy paramétere az egydimenziós tömb elemeinek számát jellemzi. Valójában az egydimenziós tömb olyan tömb, amelynek csak egy sora és n 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, mert 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, amivel az egyes tömbcellákhoz hozzá lehet férni és azokon bármilyen műveletet végrehajtani (cella ).

//szintaxis egydimenziós tömb deklarálásához C++-ban: /*adattípus*/ /*egydimenziós tömbnév*/; //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, amelyek megadják az egydimenziós tömb méretét, 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. Sőt, a deklarálás ezen módjával 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ő, a tömb minden elemét vessző választja el az előzőtől.

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

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

// array.cpp: a konzolalkalmazás belépési pontját határozza meg. #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: a konzolalkalmazás belépési pontját határozza meg. #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 tömb1 nevű deklarált és inicializált egész egydimenziós tömb, amelynek mérete 16 cellának felel meg, vagyis egy ilyen tömb 16 számot tud tárolni. Egy tömb bármilyen feldolgozása csak hurokkal együtt kivitelezhető. Ön dönti el, hogy melyik ciklust választja a tömb feldolgozásához. De erre a feladatra ez a legalkalmasabb. A számláló változót használjuk az egydimenziós tömb1 elemeire való hivatkozáshoz. A for ciklus folytatásának feltételében szigorú egyenlőtlenségjel szerepel, mivel az egydimenziós tömbtömbben nincs tizenhatod index. És mivel a cellaszámozás nulláról indul, a tömbben 16 elem található.A for ciklus törzsében a cout utasítás egy egydimenziós tömb elemeit írja ki (lásd 2. ábra).

A tömb1 feldolgozása indexeli az elemet tömb1 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 billentyűt a folytatáshoz - 1 39. . .

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. Adja össze az összes beírt számot, és jelenítse meg az eredményt a képernyőn.

// array_sum.cpp: a konzolalkalmazás belépési pontját határozza meg. #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: a konzolalkalmazás belépési pontját határozza meg. #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 beírt számokat a billentyűzetkiosztásból<< "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 összegzi azokat, az összeget az összeg változóban halmozzák fel, 17-18. sor. A program eredményét lásd a 3. ábrán.

Í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 gombot. . .

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.

2D tömbök C++ nyelven

Eddig a pontig egydimenziós tömböket vettünk figyelembe, amelyek nem mindig korlátozhatók. 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 a 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*/;

Egy kétdimenziós tömb deklarációjában, valamint egy egydimenziós tömb deklarációjában először a következőket kell megadni:

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

Ezt követően az első szögletes zárójelben a kétdimenziós tömb sorainak száma, a második szögletes zárójelben a kétdimenziós tömb oszlopainak száma. A kétdimenziós tömb vizuálisan különbözik az egydimenziós tömbtől a második pár szögletes zárójelben. Vegyü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 elemeinek szá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 egy kétdimenziós tömb deklarálására: int a;

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

// 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, amelyeken belül annyi pár göndör zárójel van, ahány vonalnak kell lennie egy kétdimenziós tömbben, és ezeket a zárójeleket vesszővel választjuk el. Minden göndör zárójelpárba írja be egy kétdimenziós tömb elemeit vesszővel elválasztva. Minden göndör kapcsos zárójelnek ugyanannyi elemet kell tartalmaznia. Mivel öt karakterlánc van a tömbben, van öt belső pár zárójel is. Három elemet írunk belső zárójelben, 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ó, az adott cella 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, melynek neve "Labirintus". A labirintust egy kétdimenziós tömb alapján kell felépíteni. A labirintus mérete rajtad múlik.

// 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 elérik a tömb minden elemét (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ő azonos számmal, például nullával, de az érthetőség kedvéért a helyes elérési utat a 2-es szám jelöli. 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ömbsor elemein keresztül halad. 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 számban írja ki a karaktert. 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

A tömböket több azonos típusú érték tárolására tervezték. Például a Fahrenheit to Celsius programban háromból számoltuk ki az átlaghőmérséklet értékét. Ha nem három érték van, hanem sokkal több, akkor itt tömböket kell használni.

Egy tömb használata előtt meg kell határozni. A tömbdefiníció a következőket tartalmazza: a tömbben tárolt adatok típusa, a tömb neve és a tömbelemek száma szögletes zárójelben:

int tömb;

Ebben a kódban definiáltunk egy tömböt tíz int típusú elem azonosítójával (névvel) tömböt (tömböt).
Ebben a formában a tömb összes eleme még nincs inicializálva. A deklaráció során történő inicializáláshoz használja a következő szintaxist:

int tömb = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Ebben az esetben a tömb első eleméhez 0, az utolsó eleméhez pedig 9-es érték tartozik.
A hurkok segítségével értékeket rendelhetünk egy tömb elemeihez. Erre a legalkalmasabb a for ciklus lenne.

c++ kód int tömb; // tömbdefiníció az (int i = 0; i< 10; i++) { array[i] = i; }

Itt a tömb minden elemére hivatkozunk az indexen keresztül - a szám szögletes zárójelben. A ciklus minden iterációjában nullától 9-ig vesz fel értékeket.

Vegye figyelembe, hogy az indexszámozás nullától kezdődik. Ezért az indexek száma mindig eggyel kevesebb, mint a tömbelemek száma.

A szögletes zárójelek és az index kivételével a tömbelemeket ugyanúgy használjuk, mint bármely más változót.

Húrok

Eddig csak konstansokban tudtunk karakterláncokat tárolni: "Constant String példa". A változókban csak egy karaktert tudtunk tárolni - a char típusban. A C++ kétféle karakterláncot használ: char és str típusú elemekből álló tömböt. Most az első lehetőségre összpontosítunk.

Szükségünk van egy tömbre egy karakterlánc tárolásához. Valahogy így néz ki:

char string = ("c", "t", "p", "o"."k", "a");

Szerencsére van egyszerűbb út is :)

char string = "karakterlánc";

Ebben az esetben automatikusan létrejön egy hét elemből álló tömb. Miért a hétből? A helyzet az, hogy minden sornak a "\0" karakterkonstanssal kell végződnie, amely egy üres bájtot jelent.

Az előző példákban, ha megpróbálunk hat karakternél nagyobb karakterláncot beírni a string tömbbe, akkor a tömb túlcsordul. nem módosíthatja a tömb méretét a program végrehajtása során (bár nem mindig):

karakterlánc; // karakterlánc hat karaktert és "\0"

string = "karakterlánc!"; // karakterlánc hét karaktert tartalmaz
Ez nem ajánlott :)

Van még egy pont, amire szeretném felhívni a figyelmet. Amikor a felhasználó beír egy karakterláncot, a szóközök „\0”-nak számítanak. Programjainkba egyelőre nem írunk be karakterláncokat, ezért ezt az esetet nem részletezem.

Tömbök tömbjei (kétdimenziós tömbök)

És végül elérkezünk a legfontosabb dologhoz ebben a kérdésben.

A stratégiai (és nem csak) játékok (RTS) térképe cellákra van osztva (angolul - csempe, csempe). Ezek a cellák kényelmesen ábrázolhatók egy kétdimenziós tömb segítségével.

Ebben a példában továbbra is a pseudo_game programmal dolgozunk, és egy kétdimenziós tömb segítségével modellezünk egy térképet, amelyen a játékos mozoghat. Eddig a "mozgást" x, y koordinátákkal jellemezték.

A cellákat szimbólumok jelölik. A "térkép" mérete 15x20. Tizenöt magas, húsz széles. A játékost T szimbólummal fogjuk ábrázolni.

Először adjon hozzá fejlécfájlt stdlib.h

Továbbfejlesztett pseudo_game

Csak kódrészleteket adok. Kívánatos, hogy a teljes program a szeme előtt legyen. Megtalálható a "programlista" részben - pseudo_game_0_2. Összeállítja és lefut. Csak másolja be az IDE szerkesztőjébe, és kövesse a szöveget.

Adatinicializálás:

c++ kód karakter aktus; // változó a felhasználói bemenet olvasásához int ch; // változó a változó csökkentett értékének tárolására act int x = 0; // két változó a játékos koordinátáinak tárolására int y = 0; charmap; // tömb a játékkártya tárolására // tömb inicializálása for (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Itt az új operátor számunkra egy kétdimenziós tömb definíciója. De szinte nem különbözik az egydimenzióstól, csak még egy pár szögletes zárójel van hozzáadva. Az első zárójelben a sorok számát, a másodikban az oszlopok számát jeleztük.

Ezt követően két ciklusban a tömb minden elemét " " értékkel inicializáljuk - ami csak egy szóköz karakter. Először is - a külső hurokban végigmegyünk az összes vonalon. A belső hurok minden egyes soránál "futtatjuk" az oszlopokat.

Mondok egy részletes példát: a külső ciklus többszöri iterációja után az i számláló egyenlővé válik 9-cel. A külső ciklus törzse megkezdődik a végrehajtás: a j változó (a belső ciklus számlálója) nullára inicializálódik, a feltétel be van jelölve, és végrehajtódik a belső ciklus törzse: map = " ";, Vagyis az első karakterhez (nulla index) a tizedik sorhoz (ne felejtsük el, hogy a szám nullától származik) szóköz van hozzárendelve. Ezután a j számlálóhoz 1-et rendelünk, a huroktestet végrehajtjuk... és így tovább, amíg a j számláló egyenlővé nem válik 20-al - a feltétel nem teljesül, és a belső hurok kilép. Ezután a külső számláló növekszik. Most 10, és a külső hurok törzse ismét végrehajtódik...

Szóközökkel történő inicializálás után az első sor első oszlopába helyezzük játékunk karakterét.

A fő ciklus elején meghívjuk a system() függvényt, hogy törölje a képernyőt a múltbeli kimenetről.

Ezután két, az inicializálási ciklusokhoz hasonló ciklus következik. Egy tömb elemeinek megjelenítésére szolgálnak a képernyőn. Az egyetlen jelentős különbség az újsor karakter kimenete az első ciklus törzsének végén.

Nos, akkor van egy elágazás, amelyben meghatározzák, hogy melyik billentyűt kell lenyomni. Maga az elágazás keveset változott a legutóbbi alkalomhoz képest, de a blokkok tartalmában vannak eltérések: először is egy szóközt rendelünk a koordinátákhoz, amelyeken az objektum áll. Vagyis töröljük az előző helyet. Ezután megváltoztatjuk az egyik koordinátát. Ezután az új indexekkel rendelkező tömb eleméhez a "T" szimbólumot rendeljük.

Példa a "75" kódra - mozgás balra:

c++ kód if else (ch == 75) ( térkép[x][y] = " "; y--; térkép[x][y] = "T"; )

Nos, általában ennyi. Jelenleg van egy 15x20-as térképünk, amelyen a nyilak segítségével mozgathatja a karaktert - a "T" betűt. Nem rossz a hatodik leckére! Ez az alkalmazás lesz minden konzolprogramunk alapja. Grafikai fejlesztések nem lesznek. Egyszerűen nem tud többet kipréselni a DOS-konzolból, és nem vesszük figyelembe a Windows konzolt. Ez jelentősen megtakarítja az időt és az erőfeszítést.

Részletesen kommentáltam a pseudo_game programot, és valószínűleg minden nehézség nélkül megérted. Ha nem, akkor olvassa el újra a program listáját és ezt a kiadást, amíg rá nem jön :). A gyakorlatok segítenek az anyag megszilárdításában. A gyakorlat kötelező. Ha valami nem tiszta, írj az e-mailemre - megpróbálok segíteni.

Feladatok:

1. A program teljes felsorolásában kapcsolóelágazást alkalmaztam. Itt látható az one if elágazás blokk kódja is. Adja hozzá a fennmaradó if-blokkokat.

2. Most már nem létező tömbelemekre tud írni a program. Végezzen határon túli ellenőrzést.

3. Gyakorlás céljából készíts egy programot, amely két csatateret rajzol a képernyőre. Az első - a játékos, a második - az ellenség. A második mezőnek az elsőtől jobbra kell lennie.
Töltse ki a belső cellákat szóközzel. Szegély rajzolásához használjon egy mínusz és egy előre elválasztó vonalat: -, |, sarkokhoz pedig egy # font jelet. Minden mezőtől balra található egy számoszlop; felső - betűk.
A teljes mező inicializálásához több hurokra lehet szüksége. Így nézhet ki a második mezőben lévő számoszlop kitöltésének kódja:

c++ kód int string; // sorokat reprezentáló változó int oszlopban; // oszlopokat reprezentáló változó char map; oszlop = 15; for (karakterlánc = 2; string< 12; string++) { map = string - 1; }