Massiiv on andmestruktuur, mis on kujutatud sama tüüpi lahtrite rühmana, mis on ühendatud ühe nime all. Massiive kasutatakse suurte sama tüüpi andmete töötlemiseks. Osutajad on massiivi nimi, ütlen teile veidi hiljem. Massiivi üksikut andmelahtrit nimetatakse massiivielemendiks. Massiivi elemendid võivad olla mis tahes tüüpi andmed. Massiividel võib olla üks või mitu mõõdet. Sõltuvalt mõõtmete arvust jagatakse massiivid ühemõõtmelisteks massiivideks, kahemõõtmelisteks massiivideks, kolmemõõtmelisteks massiivideks ja nii edasi kuni n-mõõtmelise massiivini. Programmeerimisel kasutatakse kõige sagedamini ühe- ja kahemõõtmelisi massiive, seega käsitleme ainult neid massiive.

Ühemõõtmelised massiivid C++ keeles

Ühemõõtmeline massiiv on massiiv, millel on üks parameeter, mis iseloomustab ühemõõtmelise massiivi elementide arvu. Tegelikult on ühemõõtmeline massiiv massiiv, millel võib olla ainult üks rida ja n arv veerge. Ühemõõtmelise massiivi veerud on massiivi elemendid. Joonisel 1 on kujutatud täisarvulise ühemõõtmelise massiivi struktuur a. Selle massiivi suurus on 16 lahtrit.

Joonis 1 – massiivid C++ keeles

Pange tähele, et ühemõõtmelise massiivi maksimaalne indeks a on 15, kuid massiivi suurus on 16 lahtrit, kuna massiivi lahtrite nummerdamine algab alati 0-st. Lahtriindeks on mittenegatiivne täisarv, mille abil pääsete ligi massiivi igale lahtrile ja saate sellega mis tahes toiminguid teha ( kamber).

//süntaks ühemõõtmelise massiivi deklareerimiseks C++ keeles: /*andmetüüp*/ /*ühemõõtmelise massiivi nimi*/; //Näide joonisel 1 kujutatud ühemõõtmelise massiivi deklareerimisest: int a;

kus int on täisarv;

A on ühemõõtmelise massiivi nimi;
16 on ühemõõtmelise massiivi suurus, 16 lahtrit.

Alati on kohe massiivi nime järel nurksulud, milles on määratud ühemõõtmelise massiivi suurus, mis eristab massiivi kõigist teistest muutujatest.

//teine ​​viis ühemõõtmeliste massiivide deklareerimiseks int mas, a;

Kaks ühemõõtmelist massiivi mas ja a on deklareeritud vastavalt suurustega 10 ja 16. Veelgi enam, selle deklareerimismeetodi korral on kõigil massiividel sama andmetüüp, meie puhul - int.

// massiive saab lähtestada, kui need on deklareeritud: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // ühemõõtmelise massiivi lähtestamine

Ühemõõtmelise massiivi initsialiseerimine toimub tähise järel lokkis sulgudes võrdub, eraldatakse iga massiivi element eelmisest komaga.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // massiivi lähtestamine ilma selle suurust määramata.

Sel juhul määrab kompilaator ise ühemõõtmelise massiivi suuruse. Massiivi suuruse saab ära jätta ainult selle lähtestamisel massiivi tavapärasel deklareerimisel, tuleb määrata massiivi suurus. Töötame välja lihtsa programmi ühemõõtmelise massiivi töötlemiseks.

// array.cpp: määrab konsoolirakenduse sisenemispunkti. #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; }

// kood Code::Blocks

// Dev-C++ kood

// array.cpp: määrab konsoolirakenduse sisenemispunkti. #kaasa kasutades nimeruumi 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; }

IN read 10-11 Deklareeritud ja lähtestatud on täisarvuline ühemõõtmeline massiiv nimega massiiv1, mille suurus on 16 lahtrit ehk selline massiiv mahutab 16 numbrit. Igasugune massiivi töötlemine on võimalik ainult koos silmustega. Milline silmus massiivi töötlemiseks valida, on teie otsustada. Kuid see sobib selle ülesande jaoks kõige paremini. Ühemõõtmelise massiivi massiivi1 elementidele juurdepääsuks kasutame loenduri muutuja loendurit. For-tsükli jätkamise tingimus sisaldab ranget ebavõrdsuse märki, kuna ühemõõtmelises massiivi massiivi1 kuueteistkümnendat indeksit ei ole. Ja kuna lahtrite nummerdamine algab nullist, siis on massiivis 16 elementi For-tsükli kehas trükib operaator cout ühemõõtmelise massiivi elemendid (vt joonis 2).

Obrabotka massiva indekseerib elementi massiva massiiv1 5 massiiv1 -12 massiiv1 -12 massiiv1 9 massiiv1 10 massiiv1 0 massiiv1 -9 massiiv1 -12 massiiv1 -1 massiiv1 23 massiiv1 65 massiiv1 64 massiiv1 11 massiiv1 43 massiiv1 - mis tahes klahvi 39. . .

Joonis 2 – massiivid C++ keeles

Töötame välja teise programmi ühemõõtmelise massiivi töötlemiseks C++ keeles. Programm peab järjestikku lugema klaviatuurilt kümme sisestatud numbrit. Kõik sisestatud numbrid summeeritakse ja tulemus kuvatakse ekraanil.

// array_sum.cpp: määrab konsoolirakenduse sisenemispunkti. #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; }

// kood Code::Blocks

// Dev-C++ kood

// array_sum.cpp: määrab konsoolirakenduse sisenemispunkti. #kaasa kasutades nimeruumi std; int main(int argc, char* argv) ( int massiiv1; // deklareerib täisarvu massiivi cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>massiivi1; // loeb klaviatuurilt sisestatud numbreid<< "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; }

Enne massiivi töötlemist tuleb see deklareerida ja ühemõõtmelise massiivi suurus on 10, kuna selle määrab ülesande tingimus. Muutujas summa kogume ühemõõtmelise massiivi elementide summa. Esimene for-silmus täidab deklareeritud ühemõõtmelise massiivi klaviatuurilt sisestatud numbritega, read 12-13. Loendurmuutujat kasutatakse järjestikuse juurdepääsu saamiseks ühemõõtmelise massiivi massiivi1 elementidele, alustades indeksist 0 kuni üheksandani (kaasa arvatud). Teine silmus näitab massiivi elemente, read 15-16. Kolmas for tsükkel loeb järjestikku ühemõõtmelise massiivi elemente ja summeerib need, summa akumuleeritakse summa muutujasse. read 17-18. Programmi tulemus on näidatud joonisel 3.

Sisesta elementi massiva: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Jätkamiseks vajutage suvalist klahvi. . .

Joonis 3 – massiivid C++ keeles

Kõigepealt sisestati järjestikku kõik 10 numbrit, misjärel kuvati ühemõõtmeline massiiv ja trükiti massiivi numbrite summa.

Kahemõõtmelised massiivid C++ keeles

Siiani oleme käsitlenud ühemõõtmelisi massiive, millega ei saa alati piirduda. Oletame, et peate töötlema tabelis olevaid andmeid. Tabelil on kaks tunnust: ridade arv ja veergude arv. Ka kahemõõtmelises massiivis on lisaks massiivi elementide arvule sellised omadused nagu kahemõõtmelise massiivi ridade arv ja veergude arv. See tähendab, et visuaalselt on kahemõõtmeline massiiv tavaline tabel koos ridade ja veergudega. Tegelikult on kahemõõtmeline massiiv ühemõõtmeliste massiivide ühemõõtmeline massiiv. Kahemõõtmelise massiivi, nimega a, mille suurus on m x n, struktuur on näidatud allpool (vt joonis 4).

Joonis 4 – massiivid C++ keeles

kus m on kahemõõtmelise massiivi ridade arv;
n on kahemõõtmelise massiivi veergude arv;
m * n — massiivi elementide arv.

// süntaks kahemõõtmelise massiivi deklareerimiseks /*andmetüüp*/ /*massiivi nimi*/;

Kahemõõtmelise massiivi deklareerimisel ja ka ühemõõtmelise massiivi deklareerimisel peate kõigepealt täpsustama:

• andmetüüp;
• massiivi nimi.

Pärast seda näitavad esimesed nurksulud kahemõõtmelise massiivi ridade arvu ja teised nurksulud kahemõõtmelise massiivi veergude arvu. Kahemõõtmelist massiivi eristab visuaalselt ühemõõtmelisest massiivist teine ​​nurksulgude paar. Vaatame näidet kahemõõtmelise massiivi deklareerimisest. Oletame, et peame deklareerima kahemõõtmelise massiivi, mille elementide arv on 15. Sel juhul võib kahemõõtmelisel massiivil olla kolm rida ja viis veergu või viis rida ja kolm veergu.

// kahemõõtmelise massiivi näidisdeklaratsioon: int a;

• a on täisarvu massiivi nimi
• arv esimestes nurksulgudes näitab kahemõõtmelise massiivi ridade arvu, sel juhul on neid 5;
• number teises nurksulgudes näitab kahemõõtmelise massiivi veergude arvu, sel juhul on neid 3.

// kahemõõtmelise massiivi lähtestamine: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Sellel massiivil on 5 rida, 3 veergu. pärast omistamismärki asetatakse üldised lokkis sulud, mille sisse asetatakse nii mitu paari lokkis sulgusid, kui kahemõõtmelises massiivis ridu peaks olema, ja need sulud eraldatakse komadega. Kirjutage igasse lokkis sulgude paari kahemõõtmelise massiivi elemendid, eraldades need komadega. Kõigis lokkis traksides peab elementide arv olema sama. Kuna massiivi on viis rida, siis on ka viis sisemist paari sulgusid. Sisesulgudesse kirjutatakse kolm elementi, kuna veergude arv on kolm. Graafiliselt näeb meie massiiv välja nagu kahemõõtmeline tabel (vt joonis 5).

Joonis 5 – massiivid C++ keeles

Kahemõõtmelise massiivi igas lahtris a kuvatakse väärtus, kuvatakse selle lahtri aadress paremas alanurgas. Kahemõõtmelise massiivi lahtri aadressiks on massiivi nimi, rea number ja veeru number.

Töötame välja lihtsa programmi kahemõõtmelise massiivi töötlemiseks, nimega “Labürint”. Labürint tuleb ehitada kahemõõtmelise massiivi alusel. Labürindi suuruse valime oma äranägemise järgi.

// array2.cpp: määrab konsoolirakenduse sisenemispunkti. #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); ) muidu cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kood Code::Blocks

// Dev-C++ kood

// array2.cpp: määrab konsoolirakenduse sisenemispunkti. #kaasa kasutades nimeruumi std; int main(int argc, char* argv) ( // 1-tinglikult "labürindi seinad" // 2-"õige tee, labürindist väljumine" // 0-"vale tee" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // kahemõõtmelise massiivi lähtestamine ( 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) ); // kaks tsüklit – sisemine ja väline, mis pääsevad juurde igale massiivi elemendile jaoks (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); ) muidu cout<< " "; // вывести два пробела cout << endl; } return 0; }

Õiget ja vale teed võiks tähistada sama numbriga, näiteks nulliga, kuid selguse huvides on õige tee tähistatud numbriga 2. Massiiv initsialiseeriti käsitsi, ainult programmi lihtsustamiseks. Kuna programm töötleb kahemõõtmelist massiivi, on kahemõõtmelise massiivi elementide vahel vahetamiseks vaja kahte silmust. Esimene for loop lülitub kahemõõtmelise massiivi ridade vahel. Kuna kahemõõtmelises massiivis on 33 rida, suurendatakse loenduri muutujat i vahemikus 0 kuni 33, rida 46. Esimese tsükli sees on for-silmus, mis liigub läbi kahemõõtmelise massiivi reaelementide. Teise for-tsükli kehas tehakse sees unaarse andmetüübi teisendusoperatsioon - static_cast<>() , mis prindib märginumbri 176. Labürindi laiuse suurendamiseks dubleeritakse andmetüübi teisendusoperatsioon. Programmi tulemus (vt joonis 6).

Joonis 6 – massiivid C++ keeles

Massiivid on loodud mitme sama tüüpi väärtuse salvestamiseks. Näiteks programmis Fahrenheit to Celsius arvutasime välja keskmise temperatuuri väärtuse kolmest. Kui väärtusi pole kolm, vaid palju rohkem, peate siin kasutama massiive.

Enne massiivi kasutamist peate selle defineerima. Massiivi määratlus sisaldab: massiivi salvestatud andmete tüüpi, massiivi nime ja massiivi elementide arvu nurksulgudes:

int massiiv;

Selles koodis oleme määratlenud massiivi, mille identifikaator (nimi) koosneb kümnest elemendist, mille tüüp on int.
Sellisel kujul on kõik massiivi elemendid endiselt initsialiseerimata. Nende deklareerimisel lähtestamiseks peate kasutama järgmist süntaksit:

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

Sel juhul omistatakse massiivi esimesele elemendile väärtus 0 ja viimasele väärtus 9.
Massiivielementidele väärtuste määramiseks saate kasutada silmuseid. Selleks oleks kõige sobivam for-silmus.

C++ kood int massiiv; //massiivi definitsioon jaoks (int i = 0; i< 10; i++) { array[i] = i; }

Siin pääseme igale massiivi elemendile indeksi kaudu – nurksulgudes oleva numbri kaudu. Iga tsükli iteratsiooniga võtab see väärtused nullist 9-ni.

Pange tähele, et indeksi nummerdamine algab nullist. Seetõttu on indeksite arv alati ühe võrra väiksem kui massiivi elementide arv.

Välja arvatud nurksulud ja alamindeksid, kasutatakse massiivi elementi nagu kõiki muutujaid.

Stringid

Seni saime stringe salvestada ainult konstantidena: "Konstantse stringi näide." Muutujatesse saime salvestada ainult ühe märgi – char-tüüpi. C++ kasutab kahte tüüpi stringe: elementide massiivi tüüpi char ja tüüpi str. Praegu keskendume esimesele võimalusele.

Stringi salvestamiseks vajame massiivi. See näeb välja umbes selline:

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

Õnneks on lihtsam viis :)

char string = "string";

Sel juhul luuakse automaatselt seitsmest elemendist koosnev massiiv. Miks seitsmest? Asi on selles, et iga rida peab lõppema märgikonstandiga "\0", mis tähistab tühja baiti.

Kui proovime eelmistes näidetes sisestada stringimassiivi kuuest tähemärgist pikemat stringi, voolab massiiv üle, kuna Massiivi suurust ei saa programmi töötamise ajal muuta (kuigi mitte alati):

söe string; // stringi saab salvestada kuus märki ja "\0"

string = "string!"; // rida sisaldab seitset märki
See pole soovitatav :)

On veel üks punkt, millele tahan teie tähelepanu juhtida. Kui kasutaja sisestab stringi, loetakse tühikud kui "\0". Me ei sisesta veel oma programmidesse stringe, nii et ma ei selgita seda juhtumit üksikasjalikult.

Massiivide massiivid (kahemõõtmelised massiivid)

Noh, lõpuks jõuame selle küsimuse kõige olulisema asjani.

Strateegia (ja mitte ainult) mängude (RTS) kaart on jagatud lahtriteks (inglise keeles - tile). Neid lahtreid on mugav esitada kahemõõtmelise massiivi abil.

Selles näites jätkame tööd pseudo_game programmiga ja kahemõõtmelise massiivi abil simuleerime kaarti, millel mängija saab liikuda. Seni kujutati "liikumist" x, y koordinaatide abil.

Esitame lahtreid sümbolitega. "Kaardi" suurus on 15x20. Viisteist kõrge, kakskümmend lai. Mängijat tähistame sümboliga T.

Esmalt lisage päisefail stdlib.h.

Täiustatud pseudo_mäng

Annan ainult koodilõigud. Soovitav on, et kogu programm oleks silme ees. Leiate selle jaotisest "Programmiloendid" - pseudo_game_0_2. See kompileerib ja töötab. Lihtsalt kopeerige see oma IDE redaktorisse ja järgige teksti.

Andmete lähtestamine:

C++ kood tegelase tegu; // muutuja kasutaja sisendi lugemiseks int ch; // muutuja muutuja vähendatud väärtuse salvestamiseks act int x = 0; // kaks muutujat mängija koordinaatide salvestamiseks int y = 0; tähekaart; // massiiv mängukaardi salvestamiseks // massiivi lähtestamine jaoks (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Siin on meie jaoks uus operaator kahemõõtmelise massiivi definitsioon. Kuid see ei erine peaaegu ühemõõtmelisest, lisades lihtsalt veel ühe nurksulgude paari. Esimestes sulgudes märkisime ridade arvu, teises - veergude arvu.

Pärast seda initsialiseerime kahes tsüklis iga massiivi elemendi väärtusega " ", mis on lihtsalt tühimärk. Esiteks, välimises silmuses läbime kõik read. Sisemise silmuse iga rea ​​jaoks "läbime" veerge.

Toon üksikasjaliku näite: pärast mitut välimise tsükli iteratsiooni on loendur i võrdne 9-ga. Välistsükli keha hakkab täitma: muutuja j (sisemise tsükli loendur) lähtestatakse nulliks, kontrollitakse tingimust ja käivitatakse sisemise tsükli keha: map = " ";, See tähendab, et kümnenda rea ​​esimesele märgile (indeks null) (ärge unustage, et loendus on nullist) määratakse tühik. Seejärel määratakse loendurile j 1, käivitatakse tsükli keha... ja nii edasi, kuni loendur j võrdub 20-ga - tingimus ei ole täidetud ja sisemisest tsüklist väljutakse. Seejärel suurendatakse välist loendurit. Nüüd on see võrdne 10-ga ja välimise tsükli keha täidetakse uuesti...

Pärast tühikutega lähtestamist asetame oma mängu tegelase esimese rea esimesse veergu.

Põhitsükli alguses kutsume välja süsteemi() funktsiooni, et kustutada ekraan eelmisest väljundist.

Seejärel on kaks initsialiseerimistsüklitega sarnast tsüklit. Neid kasutatakse massiivi elementide kuvamiseks ekraanil. Ainus oluline erinevus on reavahetuse märgi väljund esimese tsükli keha lõpus.

Noh, siis on hargnemine, milles määratakse, millist klahvi vajutatakse. Hargnevus ise on eelmisest korrast vähe muutunud, kuid plokkide sisus on erinevusi: esiteks määrame koordinaatidele ruumi, kus objekt asub. See tähendab, et kustutame eelmise koha. Seejärel muudame üht koordinaati. Ja siis uute indeksidega massiivielemendile omistame märgi "T".

Näide koodile "75" – liikumine vasakule:

C++ kood if else (ch == 75) ( kaart[x][y] = " "; y--; kaart[x][y] = "T"; )

Noh, see on põhimõtteliselt kõik. Hetkel on meil 15x20 kaart, millel saab nooltega liigutada tegelast – tähte "T". Pole paha kuuenda õppetunni kohta! Sellest rakendusest saab kõigi meie konsooliprogrammide alus. Graafilisi täiustusi ei tehta. Te lihtsalt ei saa DOS-konsoolist enamat ja me ei võta arvesse Windowsi konsooli. See säästab oluliselt aega ja vaeva.

Olen pseudo_game programmi üksikasjalikult kommenteerinud ja suure tõenäosusega saate sellest ilma raskusteta aru. Kui ei, siis lugege programmi loetelu uuesti läbi ja te ei saa sellest probleemist aru enne, kui olete sellest aru saanud :). Harjutused aitavad teil materjali kinnistada. Harjutuste tegemine on kohustuslik. Kui midagi jääb arusaamatuks, kirjutage minu meilile - proovin aidata.

Harjutused:

1. Programmi täielikus loendis kasutasin lülitite hargnemist. Siin kuvatakse ka ühe if haruploki kood. Lisage ülejäänud kui-plokid.

2. Nüüd saab programm kirjutada olematutele massiivi elementidele. Kontrollige kaardipiirangutest lahkumist.

3. Harjutamiseks koosta programm, mis joonistab ekraanile kaks välja merelahingu jaoks. Esimene on mängija jaoks, teine ​​​​vaenlase jaoks. Teine väli peaks asuma esimesest paremal.
Täitke sisemised lahtrid tühikutega. Piiri joonistamiseks kasutage miinust ja sirget eraldusjoont: -, | ja nurkade jaoks - räsi #. Igast väljast vasakul on numbrite virn; peal on tähed.
Kogu välja lähtestamiseks võib kuluda mitu tsüklit. Kood võib teisel väljal oleva numbriveeru täitmiseks välja näha järgmine:

C++ kood int string; // ridu esindav muutuja int veerus; // veerge esindav muutuja char map; veerg = 15; jaoks (string = 2; string< 12; string++) { map = string - 1; }

Mis on massiivid C-s?

Kuidas deklareerida massiive C-s?

Kuidas lähtestada massiive C-s?

Massiivid C-s mannekeenide jaoks.

Massiivid C-s

Massiiv C-s on sama tüüpi elementide kogum, millele pääseb juurde indeksiga. Massiivide elemendid C-s paiknevad üksteise järel arvuti mälus.

Lihtne näide massiivi loomisest ja täitmisest C-s:

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

Saame:

Näites deklareerime massiivi, mis sisaldab int tüüpi elemente:

siin on massiivi nimi nArr, massiivi elementide arv on kolm, massiivi elemendi tüüp on int.

Massiiv on elementide kogum. Igale massiivi elemendile saab viidata selle numbri järgi. Seda numbrit nimetatakse tavaliselt indeksiks. Massiivi elemendid nummerdatakse alates nullist. Määrame massiivi esimesele elemendile väärtuse ja esimese elemendi indeks on null:

Määrame massiivi teisele elemendile väärtuse ja teisel elemendil on indeks üks:

Määrame massiivi kolmandale elemendile väärtuse ja kolmandal elemendil on indeks kaks:

Kui kuvame ekraanil massiivi elemente, saame nende väärtused. Nagu nii:

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

Massiivi elemendi saamiseks peate määrama massiivi nime ja elemendi indeksi:

See on massiivi esimene element, kuna esimesel elemendil on indeks null.

Määrame massiivi kolmanda elemendi väärtuse muutujale int a:

massiivi kolmanda elemendi indeks on kaks, kuna indekseid loetakse nullist.

Nüüd C-s massiivide deklareerimise üldreegel: massiivi deklareerimisel peate märkima selle nime, elementide tüübi ja elementide arvu. Elementide arv on naturaalarv, s.t. tervik on positiivne. Null ei saa olla elementide arv. Te ei saa määrata muutuvat arvu massiivi elemente. Siin on näited massiivi deklaratsioonidest C-s:

int nArr; // Massiivile on kuulutatud sada täisarvu;
float farr; // Deklareeritud on massiiv, mis on ette nähtud 5 ujukarvu salvestamiseks;
char cArr; // Massiiv on deklareeritud kahe märgi salvestamiseks;

Oleks viga deklareerida massiivi muutuva arvu elementidega:

Int varElem;
int nArr; // Viga! Elementide arvu ei saa määrata muutujaks;

Kuid elementide arvu saate määrata konstantse väärtusega: kas otsene positiivne täisarv 1, 2, 3... või konstant:

Const int arrayLength = 3;
int nArr;

Massiivi deklareerimisel C-s saate selle kohe initsialiseerida:

int nMassiv = (1, 2, 3);

Kui kõik massiivi elemendid on lähtestatud, võite nurksulgudes olevate massiivi elementide arvu ära jätta:

int nMassiv = (1, 2, 3);

elementide arv määratakse sel juhul automaatselt.

Deklareerimisel saate määratleda ainult osa massiivi elementidest:

int nMassiv = (1, 2);

selles näites on massiivi kaks esimest elementi lähtestatud, kuid kolmas on määratlemata.

Märkide massiivi näide:

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

Massiivi deklareerimisel ei saa määrata muutuja elementide arvu. Kuid massiivielementidele juurdepääsul saate kasutada muutujaid:

Int ind = 0;
char cr = cArr;

Seda kasutatakse silmustega töötamisel. Näide:

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

Näites täidame esimeses tsüklis massiivi int tüüpi elementidega ja teises tsüklis kuvame need elemendid ekraanil.

Massiivi deklareerimine C-s
Massiiv on sekundaarne andmetüüp. Massiiv C-s on kindlat tüüpi selge suurusega elementide kogum. see tähendab, et erinevalt Ruby massiividest on C massiivid sama tüüpi (nad salvestavad ainult ühte tüüpi andmeid) ja neil on etteantud pikkus (suurus).

C-s saab massiive jämedalt jagada kahte tüüpi: numbrite massiivi ja märkide massiivi. Muidugi on selline jaotus täiesti meelevaldne, sest sümbolid on samuti täisarvud. Tähemärkide massiividel on ka veidi erinev süntaks. Allpool on näited massiivi deklaratsioonidest:

Int arr; int a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); char ch = ("R", "u", "b", "y", "D", "e", "v",","r", "u"); char ch2 = "sait";

Esimesel juhul deklareerime täisarvude massiivi (4 baiti arvu kohta), mille suurus on 100. Täpsemalt reserveerime mälu 100 int tüüpi elemendi salvestamiseks.

Teisel juhul määratleme 10 täisarvu elemendist koosneva massiivi ja määrame massiivi elementidele kohe väärtused.

Kolmandal juhul määratleme märkide massiivi. C-s ei ole stringe, kuid on tähemassiivid, mis asendavad stringe.

Viimasel juhul deklareerime ka märkide massiivi, kasutades spetsiaalset, täpsemat süntaksit. Massiivid ch ja ch2 on peaaegu identsed, kuid neil on üks erinevus. Kui kasutame massiivi loomisel stringi konstantset süntaksit, lisatakse standardse massiivi deklaratsiooni süntaksi kasutamisel märgimassiivi lõppu automaatselt märk \0, peame ise lisama märgimassiivi viimase elemendina \0. Märki \0 (null) kasutatakse rea lõpu tuvastamiseks. Strikedest räägime üksikasjalikumalt eraldi artiklis.

Juurdepääs massiivi elementidele C-s

C-s on massiivi elementidele ligipääs üsna triviaalne ja sarnaneb enamiku teiste programmeerimiskeeltega. Massiivile viitava muutuja nime järel märgime nurksulgudes elemendi indeksi (nimetatakse ka võtmeks). Allolev näide näitab, kuidas pääseme juurde massiivi esimesele elemendile:

#kaasa int main() ( int arr; int a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); char ch = ("R","u","b"," y","D","e","v",","r","u") ; char ch2 = "sait"; printf("%d\n", arr); printf(" %c\n", ch);)

Kood printf("%d\n", a); prindib 2, mitte 1, sest massiivide indekseerimine algab 0-st ja teine ​​kinnitus sellele on rida printf("%c\n", ch); , mis prindib tähe "R" - massiivi ch nullelemendi.

Üldiselt on massiivi deklaratsioonil järgmine süntaks:

andmetüübi muutuja_nimi[<количество_элементов>] = <список, элементов, массива>

Massiivi elementide arv ja elementide loend on massiivi deklaratsiooni kohustuslikud atribuudid, millest üks on kohustuslik, kuid mitte mõlemad korraga.

Massiivide struktuuri mõistmiseks peate tutvuma C-i osutite mõistega.

Osutajad C-s
Andmetüübid on vajalikud selleks, et oleks võimalik eraldada teatud suurusega mälujupp andmete salvestamiseks ja määrata, mis tüüpi andmed need on, sest ilma selge definitsioonita pole selge, kas nullide ja ühtede hulk on arv, sümbol või midagi muud. Sel juhul on muutuja viide teatud suuruse ja tüüpi mälutükile, näiteks int muutuja viitab konkreetsele 4-baidilisele mälupiirkonnale, kuhu on salvestatud täisarv, ja char muutuja viitab 1-baidine mäluala, kuhu on salvestatud märk (märgikood ).

Aadressi saamiseks, millele muutuja viitab, kasutame spetsiaalset operaatorit & - aadressi operaatorit, näide:

#kaasa int main() ( int arr; int a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); char ch = ("R","u","b"," y","D","e","v",","r","u") ; char ch2 = "sait"; int arv = 100500; printf("%p\n", &arr ;)

Line printf("%p\n", &arr); prindib 0xbfbbe068. 0xbfbbe068 on mäluaadressi kuueteistkümnendkujutis, kuhu on salvestatud number 100500.

Osutajad on eritüüpi muutujad, mis ei salvesta mällu tavalisi väärtusi, vaid nende aadresse.

#kaasa int main() ( int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); )

$./programm
V: 0xbfe32008
B: 0xbfe3200c

Ülaltoodud näites omistame muutujatele a ja b sama väärtuse - arvu 10, kuid muutujad a ja b viitavad kahele erinevale mälupiirkonnale ehk salvestame numbri 10 mällu kaks korda. Kui muudame muutuja b väärtust, ei mõjuta see muutujat a ja vastupidi. See erineb sellest, kuidas me Ruby muutujatega töötame, kus muutujad on viited mällu salvestatud objektidele ja määramisel stiilis a = b = 10 saame ühe objekti - numbri 10 ja kaks viidet sellele.

#kaasa int main() ( int a = 10; int * b = printf("A:\n\taadress: %p\n\tvalue: %d\n",&a, a); printf("B:\n\ siisdress: %p\n\tvalue: %d\n",b, *b); )

Täitmise tulemus:

$./programm
V:
aadress: 0xbfed0fa8
väärtus: 10
B:
aadress: 0xbfed0fa8
väärtus: 10

Osutajad ja massiivid

Tegelikult pole C-l massiive paljudele inimestele tuttavas mõttes. Iga massiiv C-s on lihtsalt viide massiivi nullelemendile. Näide:

#kaasa int main() ( int a = (10,20,30); printf("a-aadress:%p\n", &a); printf("a-aadress:%p\n", &a); printf( "a-Väärtus:%d\n", a); printf("a-Size:%d\n", suurus(a));

Tulemus:

$./programm
a-Aadress: 0xbfc029b4
a-Aadress: 0xbfc029b4
a-Väärtus:10
a-suurus: 12

Nagu näete, ma ei petnud teid, massiivi viitav muutuja viitab tegelikult ainult selle nullelemendile, see tähendab, et see viitab esimese elemendi salvestusaadressile.

Kui käivitame programmi, varustab operatsioonisüsteem programmi kahe spetsiaalse mälumahuga – pinu ja hunniku. Meie programm kasutab ainult virna. Virn salvestab väärtused järjestatud viisil. Massiivi loomisel loome tegelikult kursori elementide kogumi nullelemendile ja jätame mälu N arvu elementide jaoks. Ülaltoodud näites lõime 3 elemendist koosneva kollektsiooni tüübiga int, st. Iga element võtab enda alla 4 baiti mälu. Kui kasutasime funktsiooni sizeof(), mis tagastab talle edastatud argumendi suuruse baitides, saime väärtuseks 12, st. massiiv võtab enda alla 12 baiti mälu: 3 elementi * 4 baiti. Kuna kollektsiooni elementide salvestamiseks kasutatakse virna, siis salvestatakse elemendid järjekorras, see tähendab, et nad hõivavad virna külgnevad alad, mis tähendab, et saame kogus navigeerida teades elemendi asukohta ja suurust. kollektsioon. Näide:

#kaasa int main() ( int a = (10,20,30,40,10), i; for(i = 0; i<= sizeof(a)/sizeof(int); i++) printf("a[%d] has %d in %p\n", i, a[i], &a[i]); }

Tulemus:

$./programm
a-s on 0xbfbeda88-s 10
a-s on 0xbfbeda8c-s 20
a-l on 30 0xbfbeda90-s
a-l on 0xbfbeda94-s 40
a-l on 0xbfbeda98-s 10
a-l on 5 in 0xbfbeda9c

Programm printis meile teabe 5 elemendi massiivi kohta: elemendi number, väärtus ja mäluaadress. Pöörake tähelepanu elementide aadressidele - sellest ma teile rääkisin. Aadressid on reas ja iga järgmine on eelmisest 4 võrra suurem. Kogu 5. element, mida me tegelikult ei deklareerinud, salvestab kogu elementide koguarvu. Kõige huvitavam on see, et samamoodi saame kasutada viiteid massiivi läbimiseks. Näide:

#kaasa int main() ( int a = (10,20,30,40,10), i; int * b = a; for(i = 0; i<= sizeof(a)/sizeof(int); i++) printf("a[%d] has %d in %p\n", i, *(b + i), b + i); }

Märkmed

1. Pange tähele, et me määrame osutile b mitte massiivi a aadressi, vaid muutuja a väärtuse enda, kuna a on tegelikult osuti.

2. Massiivielementide indekseid tähistavate nurksulgude kasutamine on süntaktiline suhkur C-s, et kogumiselementidele oleks mugavam ja arusaadavam juurdepääs.

3. Nagu ma juba ütlesin, pole C-s traditsioonilisi massiive, seega nimetan neid kogumikeks, et rõhutada C-i seda omadust.

4. Massiivielemendi aadress 1 on seda tüüpi elemendi salvestamiseks eraldatud mälu mahu võrra suurem kui massiivi elemendi aadress 0. Töötame int tüüpi elementidega, millest igaüks kasutab salvestamiseks 4 baiti. Mälus oleva massiivi elemendi ja üldiselt kõigi andmete aadress on selle salvestamiseks eraldatud mälu esimese baidi aadress.

5. Arusaadavuse hõlbustamiseks kujutage ette, et arvuti mälu on tohutu kinosaal, kus istmed on nummerdatud 0-st, oletame, et 1_073_741_824. Char-tüüpi andmetel on normaalse suurusega tagumik ja need mahuvad ühele toolile (mahutavad ühe baidi) ning pika topelttüübi paksudel külastajatel on suured tagumik ja igaüks neist mahub ainult 10-le istmele. Kui paksudelt kinokülastajatelt küsida istekoha numbrit, ütlevad nad vaid esimese istekoha numbri ning kõigi teiste istekohtade arvu ja numbreid saab külastaja kehaehituse (andmetüübi) põhjal lihtsalt välja arvutada. Massiive saab kujutada sama tüüpi kinokülastajate gruppidena, näiteks 10-liikmeline õhukeste char tüüpi baleriinide rühm võtab 10 istekohta, sest söe mahub ühele toolile, ja õllesõprade grupp, mis koosneb 5 inimesest. type long int võtab 40 baiti.

6. Operaatoritel & ja * on mitu populaarset nime, kuid võite neid nimetada Vasjaks ja Petjaks. Peamine asi, mida meeles pidada, on:

& — näitab kinokülastaja esimese istekoha numbrit. See tähendab, et esimese hõivatud baidi aadress.

* — võimaldab pöörduda kindlas kohas istuva külastaja poole. See tähendab, et see võimaldab teil saada väärtuse, mis on salvestatud mällu kindlale aadressile.

Sellega artikkel lõpetatakse, kuid massiivide ja osutite teema pole veel lõppenud, veel vähem kogu C-keele uurimine.

Vastused

1. anonüümne ütleb:
   

   Kontrollige, kas need kaks massiivi on tõesti samad:
   char ch = ('R', u', b', y', D', e', v','.', r', u');
   char ch2 = "sait";
   Teisel juhul sisaldab massiiv veel üht elementi /0, mida kasutatakse printimisel, stringide kopeerimisel jne eraldajana.

2. admin ütleb:
   

   Tegelikult sisaldavad mõlemad massiivid 10. elemendina märki \0, seega on need tegelikult samad, kuid märgist \0 räägin ma eraldi artiklis, mis on pühendatud märgimassiividele ja stringidele.

3. anonüümne ütleb:
   

   Jah, sul oli õigus, ma kirjutasin selle kommentaari enne, kui kontrollisin seda koodi ise GCC-s:
   #kaasa
   #kaasa

   int main(tühine)
   {
   char ch = ('R', u', b', 'y', 'D', 'e', ​​'v', '.', 'r', 'u');
   char ch2 = "sait";

   printf("%x\n", ch[ strlen(ch) ]);

   tagasi 0;
   }
   Prindib nulli.

4. admin ütleb:
   

   Kõige huvitavam on see, et kui usute ANSI C spetsifikatsiooni, siis on teil õigus, sest see ei ütle midagi nullmärgi automaatse lisamise kohta massiivide jaoks standardsel viisil loodud märkide massiivi lõppu (ja K&R-is see on selgesõnaliselt tehtud mõlemas versioonis). Ma arvan, et see on kas C99 või kompilaatori erinevus, kuna kompilaatorite tootjad rakendavad C99 võimalusi enamasti osaliselt ja mõned lisavad midagi omaette. Nüüd on selge, miks on kompilaatori valik nii oluline. Pean selle probleemiga hiljem tegelema ja kirjutama artikli C-kompilaatorite erinevustest, nende C99 toest ning ANSI C ja C 99 erinevustest.

5. admin ütleb:
   

   Viisin läbi juurdluse, kuid teavitasin teid ikkagi valesti. Traditsioonilises süntaksis \0 ei lisata, see on lihtsalt juhus, et virna järgmine märk on \0, kuid see ei kuulu märgimassiivi. Kui kasutate strlen(), näete selgelt 1 märgi erinevust traditsioonilise massiivi loomise süntaksi vahel. kus märgid on lihtsalt loetletud ja kasutades stringikonstanti. Nullmärk lisatakse automaatselt ainult stringikonstandi abil loodud märgimassiivi lõppu.

6. andr ütleb:
   

   Palju eksitavaid väiteid. Sellised artiklid rikuvad ainult algajaid programmeerijaid. :)
   Näiteks "Kogu 5. element, mida me tegelikult ei deklareerinud, salvestab kogu elementide koguarvu - need on enneolematud jutud." C-keel ei salvesta massiivide pikkust kuhugi. Selles näites on massiiv 'a' piiridest väljas, sest massiivi 5 elemendi puhul on viimane indeks == 4 ja te indekseerite selle väärtusega 5. Seega pääsete ligi muutuja i aadressile, mille kompilaator paigutas mällu kohe pärast massiivi, nii et viimases tsüklis (kui i == 5) saate tulemuseks 5.

   "Nagu ma ütlesin, pole C-s traditsioonilisi massiive, seega nimetan neid kogumikeks, et rõhutada C seda omadust." - see on midagi täiesti arusaamatut. Mis on "traditsioonilised massiivid"? Kollektsioonid, muide, on laiem mõiste. Massiivid, loendid, maatriksid, virnad ja isegi räsitabelid sobivad kogude määratlusega. Miks tutvustada sobimatuid termineid ja eksitada lugejaid?

7. admin ütleb:
   

   tänan märkuse eest andr. Hakkasin alles hiljuti C-d õppima ja need olid minu oletused. C on minu jaoks mõnevõrra ebatavaline, mistõttu ma saan selliseid vigu. Ma parandan selle varsti.

8. faustman ütleb:
   

   Hästi öeldud kõhnade baleriinide ja õllesõprade grupi kohta!))

9. Minu nimi ütleb:
   

   Ja mul on gcc a, mis, nagu te ütlete, salvestab elementide arvu, annab väärtuse 32767.

Massiivid on C++-s äärmiselt oluline teema. Neid kasutatakse programmides väga sageli ja sellest teemast on vaja põhjalikult aru saada. Ma valmistan teid kohe õnnelikuks - massiivide mõistmine ja nende kasutamise õppimine on isegi algaja jaoks üsna lihtne.

Miks on massiive vaja ja mis need on? Nüüdseks olete hästi teadlik, et programmi andmed on salvestatud . Kuid juhtub, et programm peab salvestama sadu (või isegi rohkem) sama tüüpi andmete muutujaid ja ka nendega töötama - määrama väärtusi, muutma neid jne.

Näiteks peate salvestama ridade seerianumbrid. Nõus – kedagi hirmutaks mõte luua viissada muutujat tüübiga int, anda igaühele kordumatu nimi ja määrata väärtus vahemikus 1 kuni 500. (Ma juba kardan :) Sel juhul massiivid meid lihtsalt päästavad.

Märgime põhipunktid ja liigume edasi praktilise näite juurde:

• C++ massiiv on teatud arvu sama tüüpi muutujate kogum, millel on sama nimi. Nt, int massiiv ;. See kirje tähendab, et oleme deklareerinud massiivi nimega massiivi, mis sisaldab 3 tüüpi muutujad int ;
• massiivi muutujaid nimetatakse elementideks;
• Igal elemendil on oma kordumatu indeks – oma seerianumber. Indeksi abil saame juurdepääsu konkreetsele elemendile. TÄHTIS – massiivi elementide indekseerimine algab 0-st . Nii et massiivi int massiiv esimesel elemendil on indeks 0 , ja viimane on 2 . Näiteks massiivi nullelemendile juurdepääsu saamiseks ja selle väärtuse muutmiseks peate määrama massiivi nime ja märkima nurksulgudes elemendi indeksi - massiiv = 33 .

Vaatame näidet:

C++ massiivid

// selles programmis loome massiivi suuruse suurusega, // tsükliga for sisestame andmed massiivi kõikidesse lahtritesse // ja kuvame nende sisu ekraanil #include kasutades nimeruumi std; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //deklareerige konstant int firstArray; //deklareerige massiiv elementide arvuga 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; }

// selles programmis loome massiivi suurusega, // kasutage tsüklit for andmete sisestamiseks kõikidesse lahtritesse // massiivi ja kuvada nende sisu ekraanil #kaasa kasutades nimeruumi std ; int main() setlocale(LC_ALL, "rus"); const int SUURUS = 10 ; //konstandi deklareerimine int esimeneMassiiv[SUURUS]; //deklareerib massiivi elementide arvuga SIZE jaoks (int i = 0 ; i< SIZE ; i ++ ) //täitke ja kuvage väärtused ekraanil esimeneMassiiv[i] = i+1; // määrake tsükli esimeses etapis firstArray 1 (0 + 1) cout<< i << "-th lahter salvestab numbri"<< firstArray [ i ] << endl ; cout<< endl ; tagasi 0 ;

Real 12 määratleme täisarvu konstandi SUURUS, mis salvestab massiivi suuruse (meie poolt määratud, selle elementide arvu). Real 13 deklareerime massiivi: märgime massiivi lahtritesse salvestatavate andmete tüübi, anname nime ja märgime suuruse nurksulgudes.

On oluline, et saaksime nurksulgudesse kirjutada ainult konstantsed täisarvud. Massiivi deklareerimisel tuleb kas kohe sisestada nurksulgudesse täisarv ( int firstArray;) või määrake enne massiivi deklareerimist täisarvuline konstant ja sisestage selle konstandi nimi nurksulgudesse (nagu meie näites).

Teist meetodit on eelistatav kasutada, kui programmi käigus peate massiivile mitu korda tsükli kaudu juurde pääsema. Seda seletatakse asjaoluga, et tsükli deklareerimisel saame selles määrata tingimuse loenduri muutmiseks väärtusele SUURUS .

Kujutage vaid ette, et peame muutma massiivi suurust 10 elemendilt 200-le. Sel juhul peame muutma vaid täisarvu konstandi väärtust ja seega asendame mõlemad failis automaatselt uued suuruse väärtused. massiivi ja kõigis programmi tsüklites.

Meie näites võite proovida konstandile lisada mis tahes muu arvu SUURUS. Ja näete, et programm töötab suurepäraselt - see loob massiivi, milles on nii palju elemente, kui olete määranud, sisestage andmed ja kuvab need ekraanil.

Ja kui massiiv on väga väike, näiteks 5 elemendiga, saate selle kohe deklareerimisel lähtestada:

Nii et element indeksiga 0 – firstArray– määratakse väärtus 11 , ja massiivi viimane element firstArray- tähendus 1 5 . On selline trikk - te ei saa massiivi suurust nurksulgudes märkida ja kirjutada seda:

Eelmine kirje on samaväärne selle kirjega. Ainult teisel juhul arvutab kompilaator automaatselt massiivi suuruse, lähtudes lokkis sulgudes olevate andmete hulgast.

Samuti on massiivi elementide esialgse lähtestamise ajal, kui massiiv tuleb puhastada "prügist" (mälus olevate teiste programmide jääkandmed), on parem kõigile elementidele kohe väärtus määrata. 0 . See näeb välja selline:

Tuleb meeles pidada, et selline lähtestamine on võimalik ainult nullidega täitmisel. Kui teil on vaja massiivi elemente täita mõne muu numbriga, on parem kasutada silmust. Keeles C++11 (kodeerimisstandard), kui kasutate loendi lähtestamist (initsialiseerimine lokkis sulgudega), võite isegi märgist loobuda = .

Tahaksin massiivi loomisel näidata veel üht initsialiseerimistehnikat. Näiteks 30 elemendist koosneva massiivi jaoks peame sisestama väärtused 33 Ja 44 ainult indeksiga lahtritele 0 Ja 1 vastavalt ja täitke ülejäänud nullidega. Siis teeme nii:

need andmed sisestatakse nulli ja esimesse lahtrisse ning ülejäänud võtavad väärtuse automaatselt 0 .

Massiivi täitmist saab korraldada ka operaatori abil cin:

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

jaoks (int i = 0 ; i< size ; i ++ ) //täitke ja kuvage väärtused ekraanil