Statikus tömb: deklaráció, kitöltés, használat. Egydimenziós tömbök Egydimenziós tömb c példa

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;
16 — 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ő, 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érete csak inicializáláskor hagyható el, egy tömb normál deklarálásakor a tömb méretét kell megadni. 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 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

Nagy mennyiségű azonos típusú adattal kapcsolatos problémák megoldása során a különböző nevű változók használata, amelyek nincsenek memóriacímek szerint rendezve, megnehezíti a programozást. Ilyen esetekben a C nyelv tömbnek nevezett objektumokat használ.

egy összefüggő memóriadarab, amely azonos típusú objektumok sorozatát tartalmazza, egy névvel jelölve.

A tömböt a következő alapfogalmak jellemzik:

Tömbelem (tömbelem értéke)– a tömbön belül egy adott memóriacellában tárolt érték, valamint ennek a memóriacellának a címe.
Minden tömbelemet három érték jellemez:

• elem címe - a kezdő memóriacella címe, amelyben ez az elem található;
• elem index (az elem sorszáma a tömbben);
• elem értéke.

Tömbcím – a tömb kezdőelemének címe.

A tömbnév a tömbelemekre utaló azonosító.

Tömbméret – tömbelemek száma

Az elem mérete az egy tömbelem által elfoglalt bájtok száma.

Grafikusan a tömb helye a számítógép memóriájában egy folyamatos címsávként ábrázolható.

Az ábrán látható tömb q elemet tartalmaz 0-tól q-1-ig terjedő indexekkel. Minden elem k bájtot foglal el a számítógép memóriájában, és az elemek elrendezése a memóriában szekvenciális.

A tömb i-edik elemének címei a következők

A tömbcím a tömb kezdő (nulla) elemének címe. A tömbelemek eléréséhez az elem sorozatszámát (indexét) használjuk, melynek kezdőértéke 0. Tehát, ha egy tömb q elemet tartalmaz, akkor a tömbelemek indexei 0 és q-1 között változnak.

A tömb hossza a memóriában lefoglalt bájtok száma a tömb összes elemének tárolására.

Array Length = Elem mérete * Elemek száma

A függvény segítségével meghatározható egy tömbelem mérete

int sizeof(type);

Például,

mérete(char) = 1;
mérete(int) = 4;
mérete(úszó) = 4;
sizeof(double) = 8;

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

Egy tömb deklarálásához C nyelvben a következő szintaxist kell használni:

típusnév[dimenzió]=(init);

Az inicializálás a tömbelemek kezdeti értékeinek halmaza, kapcsos zárójelben megadva, vesszővel elválasztva.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // 10 egész számból álló a tömb

Ha a kapcsos zárójelben megadott inicializálási értékek száma kisebb, mint a szögletes zárójelben megadott tömbelemek száma, akkor a tömb összes többi eleme (amelyhez nem volt elegendő inicializálási érték) nulla lesz. Ez a tulajdonság kényelmesen használható egy tömb összes elemének nullára való beállításához.

int b = (0); // 10 elemből álló b tömb 0-ra inicializálva

Ha a tömb deklaráláskor inicializálva van, akkor elemeinek állandó kezdeti értékeit vesszővel elválasztva kapcsos zárójelben jelzik. Ebben az esetben a szögletes zárójelben lévő elemek száma elhagyható.

int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);

A tömbelemek elérésekor a kívánt elem indexe szögletes zárójelben van feltüntetve.

Példa a C-ben

1
2
3
4
5
6
7
8

#beleértve
int main()
{
int a = ( 5, 4, 3, 2, 1 ); // az a tömb 5 elemet tartalmaz
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
visszatérés 0;
}

A program végrehajtásának eredménye:

Gyakran azonban szükség van a tömbelemek értékeinek beállítására a program végrehajtása során. Ez inicializálás nélküli tömbdeklarációt használ. Ebben az esetben az elemek számának szögletes zárójelben való feltüntetése kötelező.

int a;

A tömbelemek kezdeti értékeinek beállításához nagyon gyakran paraméteres hurkot használnak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#beleértve
int main()
{
int a;
int i;
// Tömbelemek bevitele
for (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// Kimeneti tömbelemek
for (i = 0; i<5; i++)
printf("%d " , a[i]); // nyomtatott formátumban szóköz szükséges
getchar(); getchar();
visszatérés 0;
}

A program végrehajtásának eredménye

Többdimenziós tömbök

A többdimenziós tömbök C-ben is deklarálhatók. A különbség a többdimenziós és az egydimenziós tömb között az, hogy egy egydimenziós tömbben egy elem helyzetét egy index határozza meg, a többdimenziós tömbben pedig több. A többdimenziós tömbre példa a mátrix.

A többdimenziós tömb deklarálásának általános formája

típusnév[dimenzió1][dimenzió2]...[dimenzió];

A többdimenziós tömb elemei az egymást követő RAM cellákban helyezkednek el, a címek növekvő sorrendjében. A számítógép memóriájában egy többdimenziós tömb elemei egy sorban vannak elrendezve, például egy 2 sorból és 3 oszlopból álló tömb,

int a;

a következőképpen fog elhelyezkedni a memóriában

Az adott kétdimenziós tömb elemeinek teljes számát a következőképpen határozzuk meg

Sorok száma * Oszlopok száma = 2 * 3 = 6.

A tömb befogadásához szükséges memória bájtok számát a következőképpen adja meg

Elemek száma * Elemméret = 6 * 4 = 24 bájt.

Többdimenziós tömbök inicializálása

A többdimenziós tömb elemeinek értékei, mint az egydimenziós esetben, deklaráláskor konstans értékekkel adhatók meg, kapcsos zárójelekbe zárva (). Ebben az esetben azonban a sorokban és oszlopokban lévő elemek számát szögletes zárójelben kell feltüntetni.

Példa a C-ben

1
2
3
4
5
6
7
8
9

#beleértve
int main()
{
int a = ( 1, 2, 3, 4, 5, 6 );
printf("%d %d %d\n" , a, a, a);
getchar();
visszatérés 0;
}

A program végrehajtása során azonban gyakrabban kell megadnia egy többdimenziós tömb elemeinek értékeit. Erre a célra célszerű beágyazott parametrikus hurkot használni.

Példa a C-ben

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#beleértve
int main()
{
int a; // 2 sorból és 3 oszlopból álló tömb
int i, j;
// Tömbelemek bevitele
for (i = 0; i<2; i++) // hurok a sorokon keresztül
{
for (j = 0; j<3; j++) // hurok oszlopokon keresztül
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Kimeneti tömbelemek
for (i = 0; i<2; i++) // hurok a sorokon keresztül
{
for (j = 0; j<3; j++) // hurok oszlopokon keresztül
{
printf("%d " , a[i][j]);
}
printf("\n" ); // új sor
}
getchar(); getchar();
visszatérés 0;
}

Tömb átadása függvénynek

A tömbfeldolgozás speciális funkciókkal kényelmesen megszervezhető. Egy tömb feldolgozásához argumentumként kell átadnia a függvénynek

• tömb címe,
• tömb mérete.

Kivételt képeznek a string feldolgozó függvények, ahol elég csak a címet átadni.

Amikor változókat adunk át argumentumként egy függvénynek, az adatok másolatokként kerülnek átadásra. Ez azt jelenti, hogy ha egy paraméter értéke megváltozik egy függvényen belül, az nem befolyásolja annak értékét a hívó függvényen belül.

Ha változó címet (vagy tömbcímet) adunk át egy függvénynek, akkor a függvényben a megadott cím hatókörén belüli adatokon végrehajtott összes művelet az eredeti adaton történik, így az eredeti tömb (vagy változó értéke) megváltoztatható. a hívott függvény által.

Példa a C Dan tömbben 10 elemből. Cserélje fel a tömb legnagyobb és kezdő elemeit. A maximális elemkeresési és csereműveletek érdekében használja a funkciót.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#beleértve
// Csere függvény
érvénytelen változás (int *x, int n)
{
// x - mutató tömbre (tömbcím)
// n - tömbméret
int i;
int max, index;
max = x;
index = 0;
// A maximális elem megkeresése
for (i = 1; i {
ha (x[i]>max)
{
max = x[i];
index = i;
}
}
// Csere
x = x;
x = max;
}
// Fő funkció
int main()
{
int a;
int i;
for (i = 0; i<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
változás(a, 10); // az Exchange függvény meghívása
// Kimeneti tömbelemek
for (i = 0; i<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
Visszatérés
p = p*x[i];
}
return p;
}
// Fő funkció
int main()
{
int a; // deklarált a tömb 5 elemből
int i;
int pr;
// Tömbelemek bevitele
for (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - a tömb i-edik elemének címe
}
pr = func(a, 5); // kiszámítja a szorzatot
printf("\n pr = %d" , pr); // páros elemek szorzatát adja ki
getchar(); getchar();
visszatérés 0;
}

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

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

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

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

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

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

Jegyzet!

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

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

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

Lista 1.

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

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

Tömb elnevezési szabály

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

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

2. lista.

Int évfolyamok, sorrend; dupla árak;

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

3. lista.

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

Ha nulla értéket kell hozzárendelnie egy tömb összes eleméhez, ezt a következőképpen teheti meg:

4. lista.

Double arr = (0);

Egyedi tömbelemekkel való munka

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

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

5. lista.

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

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

6. lista.

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

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

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

Lista 7.

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

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

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 jól tudja, hogy a programadatok a . De előfordul, hogy egy programnak több száz (vagy még több) azonos típusú adat változóját kell tárolnia, és dolgoznia kell velük - értékeket rendelnie, módosítania stb.

Például tárolnia kell a sorok sorszámát. Egyetértek – bárki megijedne 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 megvan a maga egyedi indexe - 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; }

// ebben a programban létrehozunk egy tömböt méret mérettel, // használja a for ciklust adatok beviteléhez az összes cellába // tömböt, és megjeleníti a tartalmukat a képernyőn #beleértve névtér használata std ; int main() setlocale(LC_ALL, "rus"); const int MÉRET = 10 ; //konstans deklarálása int firstTömb[MÉRET]; //deklarál egy tömböt a SIZE elemszámmal for (int i = 0 ; i< SIZE ; i ++ ) //töltse ki és jelenítse meg az értékeket a képernyőn firstArray[i] = i+1; // a ciklus első lépésében a firstArray 1 hozzárendelése (0 + 1) cout<< i << "-adik cella tárolja a számot"<< 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 (á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 egy 0 indexű elemhez – 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 számítja ki a fordító automatikusan 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 hozzárendel egy értéket az összes 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, akkor jobb, ha hurkot használ. A C++11-ben (kódolási szabvány) a lista inicializálása (inicializálás kapcsos kapcsos zárójelekkel) használatakor még a 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]; )

for (int i = 0 ; i< size ; i ++ ) //töltse ki és jelenítse meg az értékeket a képernyőn

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ö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-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 egyenlő: %d", méret();

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)

Nincsenek teljes értékű módszerek annak ellenőrzésére, hogy túlléptük-e a tömb határait 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 egy véges számú elemet, mondjuk 10-et. Ekkor előre tudható, hogy összesen legfeljebb 10 különböző érték lesz. 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, még nem található 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(flag == true); //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