Tanuljuk tovább a C++ alapjait. Ebben a cikkben a tömböket nézzük meg.

A tömbök lehetővé teszik nagy mennyiségű adat tárolását kényelmes formátumban. Valójában, sor egy olyan változó, amely több értéket tárol egy név alatt, de minden értékhez saját index tartozik. olyan értékek listája, amelyekhez az indexek hozzáférnek.

Bevezetés a tömbökbe

Egy ilyen tömböt vizualizálhat:

Ez néhány érték halmaza, amelyek egymás után, egy név alatt kerülnek tárolásra. Ezen értékek megszerzéséhez nem kell új változókat létrehozni, csak meg kell jelölni azt az indexet, amely alatt az érték tárolódik a tömbben. Például a pókerhez öt játékkártyát kell kiosztania, ezeket a kártyákat egy tömbben tárolhatja, és csak az indexszámot módosíthatja új kártya kiválasztásához, új változó használata helyett. Ez lehetővé teszi, hogy ugyanazt a kódot használja az összes kártya inicializálásához, és a következőképpen írja le:

Card1 = getRandomCard(); Card2 = getRandomCard(); Card3 = getRandomCard(); Card4 = getRandomCard(); Card5 = getRandomCard();

For (int i = 0; i< 5; i++) { card[i] = getRandomCard(); }

Most képzeljük el, mi a különbség, ha 100 változó van!

Szintaxis

Egy tömb deklarálásához két dolgot kell megadni (a néven kívül): a tömb típusát és méretét:

Int my_array[6];

Ez a sor hat egész számból álló tömböt deklarál. Vegye figyelembe, hogy a tömb mérete szögletes zárójelben van a tömb neve után.

Szögletes zárójeleket használ a tömbelemek eléréséhez, de ezúttal megadja az elérni kívánt elem indexét:

Saját_tömb[3];

Ezt a folyamatot a következőképpen képzelheti el:

my_array a teljes tömbre utal, míg a my_array csak az első elemre, a my_array a negyedikre. vegye figyelembe, hogy indexelés A tömb elemei 0-val kezdődnek. Így a tömbelemekhez való hozzáférés mindig eltolással történik, például:

Int my_array[4]; // tömb deklaráció my_array[ 2 ] = 2; // a harmadik (nevezetesen a harmadik!) értékét állítsd 2-re

Többdimenziós tömbök deklarálása C++ nyelven

A tömbök többdimenziós adatok, például sakktábla vagy tic-tac-toe tábla ábrázolására is használhatók. Többdimenziós adatok használata esetén több indexet használ a rendszer a tömbelemek eléréséhez.

Egy kétdimenziós tömb deklarálásához meg kell adnia két dimenzió dimenzióját:

Int tic_tac_toe_board;

Egy tömb megjelenítése elemeinek indexeivel:

Egy ilyen tömb elemeinek eléréséhez két indexre lesz szüksége - az egyik a sorhoz, a másik az oszlophoz. A képen az egyes elemek eléréséhez szükséges indexek láthatók.

Tömbök használata

A tömbök használatakor nem nélkülözheti a . A cikluson való futtatáshoz egyszerűen nullára kell inicializálnia egy változót, és addig kell növelnie, amíg meg nem haladja a tömb méretét – ez a minta éppen megfelelő a ciklushoz.

A következő program bemutatja a ciklus használatát egy szorzótábla létrehozására és az eredmény kétdimenziós tömbben való tárolására:

#beleértve névtér használata std; int main() ( int tömb; // Egy sakktáblának tűnő tömb deklarálása a következőhöz: (int i = 0; i< 8; i++) { for (int j = 0; j < 8; j++) { array[i][j] = i * j; // Задаем значения каждого элемента } } cout << "Multiplication table:\n"; for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { cout << "[ " << i << " ][ " << j << "] = "; cout << array[i][j] << " "; cout << "\n"; } } }

Tömbök átadása függvényeknek

Mint látható, a C++ nyelv különböző elemei kölcsönhatásba lépnek egymással. A ciklusokhoz hasonlóan a tömbök is használhatók a -val együtt.

Egy tömb függvénynek való átadásához egyszerűen adja meg a nevét:

Int értékek[10]; sum_array(values);

Függvény deklarálásakor adjon meg egy tömböt argumentumként:

Int sum_array(int értékek);

Kérjük, vegye figyelembe, hogy a függvény argumentumában nem adjuk meg a tömb dimenzióját, ez normális az egydimenziós tömböknél, nincs szükség a dimenzió megadására. A méretet mikor kell feltüntetni tömbök deklarálása , mert A fordítónak tudnia kell, hogy mennyi memóriát kell lefoglalnia. Amikor átadunk egy függvénynek, egyszerűen átadunk egy meglévő tömböt, nincs szükség a méret megadására, mert Nem hozunk létre újat. Mert tömböt adunk át a függvénynek, a függvényen belül megtehetjük változás, ellentétben az egyszerű változókkal, amelyeket érték adja át, és ennek az értéknek a függvényen belüli megváltoztatása semmilyen módon nem befolyásolja az eredeti változót.

Mivel nem ismerjük a függvényen belüli tömb méretét, második argumentumként a dimenziót kell átadnunk:

Int sumArray(int értékek, int méret) ( int összeg = 0; for (int i = 0; i< size; i++) { sum += values[ i ]; } return sum; }

Amikor többdimenziós tömböket adunk át, az első kivételével minden dimenziót meg kell adnunk:

Int check_tic_tac_toe(int board);

Természetesen megadhatja az első dimenziót, de a rendszer figyelmen kívül hagyja.

Ezt a témát részletesebben a mutatókról szóló cikkben tárgyaljuk.

Egyelőre írjunk egy függvényt, amely kiszámolja a tömbelemek összegét:

#beleértve névtér használata std; int sumArray(int értékek, int méret) ( int sum = 0; // a ciklus leáll, amikor i == méret, mert az utolsó elem indexe = méret - 1 for (int i = 0; i< size; i++) { sum += values[i]; } return sum; } int main() { int values; for (int i = 0; i < 10; i++) { cout << "Enter value "<< én <<": "; cin >> értékek[i]; ) cout<< sumArray(values, 10) << endl; }

Tömb rendezése

Oldjuk meg a felhasználó által beírt 100 számból álló tömb rendezésének problémáját:

#beleértve névtér használata std; int main() ( int értékek[ 100 ]; for (int i = 0; i< 100; i++) { cout << "Enter value "<< én <<": "; cin >> értékek[ i ]; ) )

Kész, már csak ezt a tömböt kell rendezni :) Hogyan szokták rendezni az emberek a tömböket? Megkeresik benne a legkisebb elemet, és a lista elejére teszik. Ezután megkeresik a következő minimális értéket, és közvetlenül az első mögé teszik, és így tovább.

Ez az egész úgy néz ki, mint egy ciklus: végigfutjuk a tömböt, kezdve az első elemmel, és megkeressük a minimális értéket a maradék részben, és felcseréljük ezeket az elemeket. Kezdjük a kód megírásával az alábbi műveletek végrehajtásához:

Void sort(int tömb, int méret) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

Most elgondolkodhat két segédmódszer, a findSmallestRemainingElement és a swap megvalósításán. A findSmallestRemainingElement metódusnak végig kell haladnia a tömbön, és meg kell találnia a legkisebb elemet az i indextől kezdve:

Int findSmallestRemainingElement(int tömb, int méret, int index) ( int_legkisebb_érték indexe = index; for (int i = index + 1; i< size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = I; } } return index_of_smallest_value; }

Végül meg kell valósítanunk a swap függvényt. Mivel a függvény módosítja az eredeti tömböt, csak fel kell cserélnünk az értékeket egy ideiglenes változó segítségével:

Void swap(int tömb, int első_index, int második_index) ( int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; )

Az algoritmus teszteléséhez töltse ki a tömböt véletlenszerű számokkal, és rendezze. Minden programkód:

#beleértve #beleértve #beleértve névtér használata std; int findSmallestRemainingElement(int tömb, int méret, int index); void swap(int tömb, int első_index, int második_index); void sort(int array, int size) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } } int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = i; } } return index_of_smallest_value; } void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; } // вспомогательная функция для вывода массива void displayArray(int array, int size) { cout << "{"; for (int i = 0; i < size; i++) { // если элемент не первый выведем запятую if (i != 0) { cout << ", "; } cout << array[ i ]; } cout << "}"; } int main() { int array[ 10 ]; srand(time(NULL)); for (int i = 0; i < 10; i++) { array[ i ] = rand() % 100; } cout << "Original array: "; displayArray(array, 10); cout << "\n"; sort(array, 10); cout << "Sorted array: "; displayArray(array, 10); cout << "\n"; }

Az imént megnézett rendezési algoritmust ún beillesztési rendezés , ez nem a leggyorsabb algoritmus, de könnyen érthető és megvalósítható. Ha nagy mennyiségű adatot kell rendeznie, jobb, ha bonyolultabb és gyorsabb algoritmusokat használ.

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 mutatók, 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 vannak szögletes zárójelek, 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ő, 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); // 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. A tömb méretét csak inicializáláskor lehet elhagyni egy tömb normál deklarálásakor, a tömb méretét meg kell adni. 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ási 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, 16 elem van a tömbben 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 a 9. indexig bezárólag. 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óstó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 egy 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

Utolsó frissítés: 2017.09.17

Egy tömb azonos típusú adatok halmazát jelöli. 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 az első elemekhez inicializálókat használ. 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 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álva van, 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

Az egydimenziós tömbök mellett a C++ rendelkezik többdimenziós tömbökkel 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ó:

1	2
4	5
7	8

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.

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 az átlagos hőmérsékleti értéket számoltuk ki háromból. Ha nem három érték van, hanem sokkal több, akkor itt kell tömböket használni.

Mielőtt egy tömböt használna, meg kell határoznia azt. A tömb definíciója tartalmazza: a tömbben tárolt adatok típusát, a tömb nevét és a tömbelemek számát szögletes zárójelben:

int tömb;

Ebben a kódban definiáltunk egy tömböt tíz int típusú elemből álló azonosító (név) tömbbel.
Ebben a formában a tömb összes eleme még inicializálatlan. Deklarációjukkor a következő szintaxist kell használnia, hogy inicializálja őket:

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óhoz pedig 9 értéke van hozzárendelve.
A hurkok segítségével értékeket rendelhet a tömbelemekhez. Erre a legalkalmasabb a for ciklus lenne.

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

Itt a tömb minden elemét egy indexen keresztül érjük el - egy szám szögletes zárójelben. A ciklus minden iterációjával 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 alsó indexek kivételével a tömbelemeket ugyanúgy használjuk, mint bármely változót.

Húrok

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

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

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

Szerencsére van egy 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 lényeg az, hogy minden sornak a "\0" karakterkonstanssal kell végződnie, ami egy üres bájtot jelent.

Az előző példákban, ha megpróbálunk hat karakternél hosszabb karakterláncot beírni a string tömbbe, a tömb túlcsordul, mert A program futása közben nem módosíthatja a tömb méretét (bár nem mindig):

char húr; // karakterlánc hat karaktert és "\0"

string = "karakterlánc!"; // a sor hét karaktert tartalmaz
Nem ajánlott ezt csinálni :)

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. A programjainkba még nem írunk be karakterláncokat, ezért ezt az esetet nem részletezem.

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

Nos, végre elérkeztünk a legfontosabb dologhoz ebben a kérdésben.

A térkép a stratégiai (és nem csak) játékokban (RTS) cellákra van osztva (angolul - csempe). Ezeket a cellákat célszerű kétdimenziós tömb segítségével ábrázolni.

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

A cellákat szimbólumokkal fogjuk ábrázolni. A "kártya" mérete 15x20. Tizenöt magas, húsz széles. A játékost a T szimbólummal fogjuk ábrázolni.

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

Továbbfejlesztett pseudo_game

Csak kódrészleteket adok. Javasoljuk, 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őbe, és kövesse a szöveget.

Adatinicializálás:

C++ kód char act; // változó a felhasználói bemenet olvasásához int ch; // változó az act változó redukált értékének tárolására int x = 0; // két változó a játékos koordinátáinak tárolására int y = 0; char térkép; // tömb a játékkártya tárolására // a 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 egy új operátor számunkra a kétdimenziós tömb definíciója. De szinte semmiben sem különbözik az egydimenzióstól, csak egy újabb pár szögletes zárójelet ad hozzá. 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 soron. A belső hurok minden soránál "átjárjuk" az oszlopokat.

Hadd mondjak egy részletes példát: a külső ciklus többszöri iterációja után az i számláló egyenlő 9-cel. A külső ciklus törzse elkezdődik: a j változó (a belső hurok számlálója) nullára inicializálódik, a feltétel ellenőrzése és a belső ciklus törzse végrehajtásra kerül: map = " ";, Vagyis a tizedik sor első karakteréhez (nulla indexhez) (ne felejtsük el, hogy a visszaszámlálás nullától történik) egy szóköz van hozzárendelve. Ezután a j számlálóhoz 1-et rendelünk, a ciklus törzsét 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ő ciklus kilép. Ezután a külső számláló növekszik. Most egyenlő 10-zel, é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öljük a képernyőt az előző kimenetről.

Ezután két, az inicializálási ciklusokhoz hasonló ciklus van. A tömbelemek képernyőn való megjelenítésére szolgálnak. 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 nyomják meg. 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, ahol az objektum található. 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ömbelemhez a "T" karaktert 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, ez minden. 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éhez! Ez az alkalmazás lesz minden konzolprogramunk alapja. Grafikai fejlesztések nem lesznek. Egyszerűen nem lehet többet kihozni a DOS-konzolból, és a Windows-konzolt nem vesszük figyelembe. Ezzel jelentősen időt és erőfeszítést takaríthat meg.

Részletesen kommentáltam a pseudo_game programot, és valószínűleg minden nehézség nélkül megérti. Ha nem, akkor olvasd el újra a programlistát, és addig nem érted ezt a kérdést, amíg meg nem érted :). A gyakorlatok segítenek az anyag megszilárdításában. A gyakorlatok elvégzése kötelező. Ha valami nem világos, írjon az e-mailemre - megpróbálok segíteni.

Feladatok:

1. A program teljes felsorolásánál 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. Ellenőrizze, hogy elhagyta-e a térkép határait.

3. Gyakorlás céljából készítsünk egy programot, amely két mezőt rajzol a képernyőre egy tengeri csatához. 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özökkel. Szegély rajzolásához használjon mínuszt és egyenes elválasztó vonalat: -, |, sarkokhoz pedig # hash-t. Minden mezőtől balra egy halom szám található; tetején betűk.
A teljes mező inicializálásához több ciklusra is szükség lehet. Így nézhet ki a kód, amely kitölti a második mező számoszlopát:

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; }

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 mozgattunk 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ölteni, akkor írunk

Int a = (0);

Nem kell például kifejezetten beállítani a tömb méretét

Int a = (1, 2, 3);

a tömb mérete 3 lesz

Tömb mérete

A C-ben lévő 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 egyenlő: %d", méret();

De ez nem valószínű, hogy hasznos lesz. Amikor egy tömböt adunk át argumentumként egy függvénynek, egy mutató kerül átadásra, í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ődik. 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 végzett 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)

Nincsenek teljes értékű módszerek annak ellenőrzésére, hogy túlléptünk-e a tömbön vagy sem. Ezért vagy pontosan tudjuk a méretét, vagy eltároljuk egy változóban, és szükség esetén kiolvassuk.

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álók előjel nélküli fele //a tömb közepe unsigned 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 (i = 0, j = MÉRET - 1;< 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 nem lesz több, mint 10 különböző érték. Minden alkalommal, amikor 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 beírt szám nem található //Írja be az első számot. printf("0.");< 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 sum = .0f; float relError;< 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;< 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(jelző == 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