Mokykimės C++ pagrindų. Šiame straipsnyje apžvelgsime masyvus.

Masyvai leidžia saugoti didelius duomenų kiekius patogiu formatu. Faktiškai, masyvas yra kintamasis, kuriame vienu pavadinimu saugomos kelios reikšmės, tačiau kiekvienai reikšmei priskiriamas atskiras indeksas. yra reikšmių, kurioms pasiekti naudojami indeksai, sąrašas.

Įvadas į Arrays

Galite vizualizuoti masyvą taip:

Tai kai kurių reikšmių, kurios saugomos viena po kitos vienu pavadinimu, rinkinys. Norint gauti šias reikšmes, nereikia kurti naujų kintamųjų, tereikia nurodyti indeksą, pagal kurį reikšmė saugoma masyve. Pavyzdžiui, jums reikia išdalyti penkių lošimo kortų rinkinį pokeriui, galite laikyti šias kortas masyve ir pakeisti tik indekso numerį, kad pasirinktumėte naują kortą, o ne naudoti naują kintamąjį. Tai leis naudoti tą patį kodą, kad inicijuotų visas korteles ir neberašytumėte taip:

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

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

Dabar įsivaizduokite skirtumą, jei yra 100 kintamųjų!

Sintaksė

Norėdami deklaruoti masyvą, turite nurodyti du dalykus (be pavadinimo): masyvo tipą ir dydį:

Int mano_masyvas[6];

Ši eilutė deklaruoja šešių sveikųjų skaičių masyvą. Atminkite, kad po masyvo pavadinimo masyvo dydis yra laužtiniuose skliaustuose.

Norėdami pasiekti masyvo elementus, naudojate laužtinius skliaustus, tačiau šį kartą nurodote elemento, kurį norite pasiekti, indeksą:

Mano_masyvas[3];

Šį procesą galite įsivaizduoti taip:

mano_masyvas nurodo visą masyvą, o mano_masyvas nurodo tik pirmąjį elementą, mano_masyvas nurodo ketvirtą. Prisimink tai indeksavimas masyvo elementai prasideda nuo 0. Taigi prieiga prie masyvo elementų visada bus su poslinkiu, pavyzdžiui:

Int mano_masyvas[4]; // masyvo deklaracija mano_masyvas[ 2 ] = 2; // nustatykite trečiojo (būtent trečiojo!) reikšmę į 2

Daugiamačių masyvų deklaravimas C++ kalba

Masyvai taip pat gali būti naudojami daugiamačiams duomenims pavaizduoti, pvz., šachmatų lentai arba „tic-tac-toe“ lentai. Naudojant daugiamačius duomenis, norint pasiekti masyvo elementus bus naudojami keli indeksai.

Norėdami deklaruoti dvimatį masyvą, turite nurodyti dviejų matmenų matmenis:

Int tic_tac_toe_board;

Masyvo vizualizacija su jo elementų indeksais:

Norint pasiekti tokio masyvo elementus, reikės dviejų indeksų – vieno eilutei, o kito – stulpeliui. Paveikslėlyje rodomi būtini indeksai, norint pasiekti kiekvieną elementą.

Masyvų naudojimas

Naudodami masyvus neapsieisite be . Norėdami pereiti per kilpą, tiesiog inicijuokite kintamąjį iki nulio ir padidinkite jį tol, kol jis viršys masyvo dydį – tai ciklas tinkamas modelis.

Šioje programoje demonstruojamas ciklo naudojimas daugybos lentelei sukurti ir rezultatui išsaugoti dvimačiame masyve:

#įtraukti naudojant vardų erdvę std; int main() ( int masyvas; // Paskelbkite masyvą, kuris atrodo kaip šachmatų lenta (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"; } } }

Masyvų perdavimas funkcijoms

Kaip matote, skirtingi C++ kalbos elementai sąveikauja tarpusavyje. Kaip ir kilpų atveju, masyvai gali būti naudojami kartu su .

Norėdami perduoti masyvą funkcijai, tiesiog nurodykite jos pavadinimą:

Int reikšmės[10]; suma_masyvas(vertes);

O deklaruodami funkciją nurodykite masyvą kaip argumentą:

Int sum_masyvas(int reikšmės);

Atkreipkite dėmesį, kad funkcijos argumentuose nenurodome masyvo matmens, tai yra normalu vienmačiams masyvams matmens nurodyti nereikia. Dydis turi būti nurodytas kada deklaruojant masyvus , nes Kompiliatorius turi žinoti, kiek atminties skirti. Pereinant prie funkcijos, mes tiesiog perduodame esamą masyvą, nereikia nurodyti dydžio, nes Naujo nekuriame. Nes funkcijai perduodame masyvą, funkcijos viduje galime pakeisti, skirtingai nei paprasti kintamieji, kurie perduodami pagal vertę, ir šios reikšmės pakeitimas funkcijoje neturės jokios įtakos pradiniam kintamajam.

Kadangi mes nežinome funkcijos viduje esančio masyvo dydžio, turime perduoti matmenį kaip antrą argumentą:

Int sumArray(int reikšmės, int dydis) ( int suma = 0; for (int i = 0; i< size; i++) { sum += values[ i ]; } return sum; }

Kai perduodame daugiamačius masyvus, turime nurodyti visus matmenis, išskyrus pirmąjį:

Int check_tic_tac_toe(int lenta);

Žinoma, galite nurodyti pirmąjį matmenį, bet jis bus ignoruojamas.

Ši tema bus išsamiau aptarta straipsnyje apie nuorodas.

Kol kas parašykime funkciją, kuri apskaičiuoja masyvo elementų sumą:

#įtraukti naudojant vardų erdvę std; int sumArray(int reikšmės, int dydis) ( int suma = 0; // ciklas sustos, kai i == dydis, nes paskutinio elemento indeksas = dydis - 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 "<< aš <<": "; cin >> reikšmės[i]; ) cout<< sumArray(values, 10) << endl; }

Rūšiuoti masyvą

Išspręskime vartotojo įvestų 100 skaičių masyvo rūšiavimo problemą:

#įtraukti naudojant vardų erdvę std; int main() ( int reikšmės[ 100 ]; for (int i = 0; i< 100; i++) { cout << "Enter value "<< aš <<": "; cin >> reikšmės[ i ]; ) )

Atlikta, belieka surūšiuoti šį masyvą :) Kaip žmonės dažniausiai rūšiuoja masyvus? Jie ieško jame mažiausio elemento ir pateikia jį sąrašo viršuje. Tada jie ieško kitos minimalios vertės ir deda ją iškart po pirmosios ir pan.

Visa tai atrodo kaip kilpa: mes pereiname per masyvą, pradėdami nuo pirmojo elemento, likusioje dalyje ieškome minimalios reikšmės ir sukeičiame šiuos elementus. Pradėkime nuo kodo, kad atliktume šias operacijas:

Tuščias rūšiavimas(int masyvas, int dydis) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

Dabar galite pagalvoti apie dviejų pagalbinių metodų diegimą: findSmallestRemainingElement ir swap. Metodas findSmallestRemainingElement turi kartoti masyvą ir rasti mažiausią elementą, pradedant nuo indekso i:

Int findMallestRemainingElement(int masyvas, int dydis, int indeksas) ( int index_of_mallest_value = indeksas; for (int i = indeksas + 1; i< size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = I; } } return index_of_smallest_value; }

Galiausiai turime įgyvendinti apsikeitimo funkciją. Kadangi funkcija pakeis pradinį masyvą, mes tiesiog turime pakeisti reikšmes naudodami laikinąjį kintamąjį:

Void swap(int masyvas, int pirmasis_indeksas, int antrasis_indeksas) ( int temp = masyvas[ pirmasis_indeksas ]; masyvas[ pirmasis_indeksas ] = masyvas[ antrasis_indeksas ]; masyvas[ antrasis_indeksas ] = temp; )

Norėdami patikrinti algoritmą, užpildykite masyvą atsitiktiniais skaičiais ir surūšiuokite. Visas programos kodas:

#įtraukti #įtraukti #įtraukti naudojant vardų erdvę std; int findMallestRemainingElement(int masyvas, int dydis, int indeksas); void swap(int masyvas, int pirmas_indeksas, int antras_indeksas); void sort(int masyvas, int dydis) ( 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"; }

Rūšiavimo algoritmas, kurį ką tik pažiūrėjome, vadinamas įterpimo rūšiavimas , tai nėra greičiausias algoritmas, tačiau jį lengva suprasti ir įgyvendinti. Jei reikia rūšiuoti didelius duomenų kiekius, geriau naudoti sudėtingesnius ir greitesnius algoritmus.

Masyvas yra duomenų struktūra, vaizduojama kaip to paties tipo langelių grupė, sujungta vienu pavadinimu. Masyvai naudojami dideliems to paties tipo duomenų kiekiams apdoroti. Masyvo pavadinimas yra tai, kas yra rodyklės, aš jums pasakysiu šiek tiek vėliau. Atskiras masyvo duomenų langelis vadinamas masyvo elementu. Masyvo elementai gali būti bet kokio tipo duomenys. Masyvai gali turėti vieną arba daugiau nei vieną dimensiją. Priklausomai nuo matmenų skaičiaus, masyvai skirstomi į vienmačius, dvimačius, trimačius ir t.t. iki n-mačio masyvo. Programavime dažniausiai naudojami vienmačiai ir dvimačiai masyvai, todėl nagrinėsime tik šiuos masyvus.

Vienmačiai masyvai C++ kalba

Vienmatis masyvas yra masyvas su vienu parametru, apibūdinančiu vienmačio masyvo elementų skaičių. Tiesą sakant, vienmatis masyvas yra masyvas, kuriame gali būti tik viena eilutė ir n stulpelių skaičius. Vienmačio masyvo stulpeliai yra masyvo elementai. 1 paveiksle parodyta sveikojo skaičiaus vienmačio masyvo struktūra a. Šio masyvo dydis yra 16 langelių.

1 paveikslas – C++ masyvai

Atkreipkite dėmesį, kad didžiausias vienmačio masyvo indeksas a yra 15, bet masyvo dydis yra 16 langelių, nes masyvo langelių numeracija visada prasideda nuo 0. Ląstelių indeksas yra neneigiamas sveikasis skaičius, pagal kurį galite pasiekti kiekvieną masyvo langelį ir su ja atlikti bet kokius veiksmus ( ląstelė).

//sintaksė vienmačio masyvo deklaravimui C++: /*duomenų tipas*/ /*vienmačio masyvo pavadinimas*/; //1 pav. parodyto vienmačio masyvo deklaravimo pavyzdys: int a;

kur int yra sveikas skaičius;

A yra vienmačio masyvo pavadinimas;
16 yra vienmačio masyvo dydis, 16 langelių.

Visada iš karto po masyvo pavadinimo yra laužtiniai skliaustai, kuriuose nurodomas vienmačio masyvo dydis.

//dar vienas būdas deklaruoti vienmačius masyvus int mas, a;

Dvi vienmatės matricos mas ir a deklaruojamos atitinkamai 10 ir 16 dydžiais. Be to, taikant šį deklaravimo būdą, visi masyvai turės tą patį duomenų tipą, mūsų atveju - int.

// masyvus galima inicijuoti, kai jie deklaruojami: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // vienmačio masyvo inicijavimas

Vienmačio masyvo inicijavimas atliekamas sulenktuose skliaustuose po ženklo lygus, kiekvienas masyvo elementas nuo ankstesnio atskiriamas kableliu.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // masyvo inicijavimas nenustačius jo dydžio.

Tokiu atveju vienmačio masyvo dydį nustatys pats kompiliatorius. Masyvo dydį galima praleisti tik jį inicijuojant deklaruojant masyvą įprastai, reikia nurodyti masyvo dydį. Sukurkime paprastą programą, skirtą apdoroti vienmatį masyvą.

// array.cpp: apibrėžia konsolės programos įėjimo tašką. #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; }

// kodas Code::Blocks

// Dev-C++ kodas

// array.cpp: apibrėžia konsolės programos įėjimo tašką. #įtraukti naudojant vardų erdvę 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 10-11 eilutės Buvo deklaruotas ir inicijuotas sveikasis vienmatis masyvas, pavadintas masyvas1, kurio dydis yra 16 langelių, tai yra, tokiame masyve galima laikyti 16 skaičių. Bet koks masyvo apdorojimas galimas tik kartu su kilpomis. Kurią kilpą pasirinkti masyvo apdorojimui, galite nuspręsti patys. Bet tai geriausiai tinka šiai užduočiai. Norėdami pasiekti vienmačio masyvo masyvo1 elementus, naudosime skaitiklio kintamųjų skaitiklį. For ciklo tęsimo sąlygoje yra griežtas nelygybės ženklas, nes vienmačio masyvo masyve1 nėra šešioliktojo indekso. O kadangi langelių numeracija prasideda nuo nulio, tai masyve yra 16 elementų For ciklo korpuse operatorius cout atspausdina vienmačio masyvo elementus (žr. 2 pav.).

Obrabotka massiva indeksuoja elementą massiva masyvas1 5 masyvas1 -12 masyvas1 -12 masyvas1 9 masyvas1 10 masyvas1 0 masyvas1 -9 masyvas1 -12 masyvas1 -1 masyvas1 23 masyvas1 65 masyvas1 64 masyvas1 11 masyvas1 43 masyvas1, spauskite bet kurį klavišą 39. . .

2 paveikslas – C++ masyvai

Sukurkime kitą programą, skirtą vienmačio masyvo apdorojimui C++. Programa turi paeiliui nuskaityti dešimt įvestų skaičių iš klaviatūros. Visi įvesti skaičiai sumuojami, o rezultatas rodomas ekrane.

// array_sum.cpp: apibrėžia konsolės programos įėjimo tašką. #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; }

// kodas Code::Blocks

// Dev-C++ kodas

// array_sum.cpp: apibrėžia konsolės programos įėjimo tašką. #įtraukti naudojant vardų erdvę std; int main(int argc, char* argv) ( int masyvas1; // paskelbti sveikųjų skaičių masyvo cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>masyvas1; // skaityti skaičius, įvestas iš klaviatūros mygtuko<< "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; }

Prieš apdorojant masyvą, jis turi būti deklaruotas, o vienmačio masyvo dydis yra 10, nes tai numato užduoties sąlyga. Sumos kintamajame kaupsime vienmačio masyvo elementų sumą. Pirmoji for kilpa užpildo deklaruotą vienmatį masyvą skaičiais, įvestais iš klaviatūros, 12-13 eilutės. Skaitiklio kintamasis naudojamas nuosekliai pasiekti vienmačio masyvo1 elementus, pradedant nuo indekso 0 ir baigiant 9 imtinai. Antroji for kilpa rodo masyvo elementus, 15-16 eilutės. Trečiasis for ciklas nuosekliai skaito vienmačio masyvo elementus ir juos sumuoja, suma kaupiama sumos kintamajame. 17-18 eilutės. Programos rezultatas parodytas 3 pav.

Įveskite elementi massiva: 0 1 2 3 4 5 6 7 8 9 masyvas1 = (0 1 2 3 4 5 6 7 8 9 ) suma = 45 Norėdami tęsti, paspauskite bet kurį klavišą. . .

3 paveikslas – C++ masyvai

Pirmiausia iš eilės buvo įvedami visi 10 skaičių, po to buvo rodomas vienmatis masyvas ir atspausdinta masyve esančių skaičių suma.

Dvimačiai masyvai C++

Iki šiol mes svarstėme vienmačius masyvus, kurie ne visada gali apsiriboti. Tarkime, kad reikia apdoroti kai kuriuos duomenis iš lentelės. Lentelė turi dvi charakteristikas: eilučių skaičių ir stulpelių skaičių. Taip pat dvimačiame masyve, be masyvo elementų skaičiaus, yra tokios charakteristikos kaip dvimačio masyvo eilučių skaičius ir stulpelių skaičius. Tai yra, vizualiai, dvimatis masyvas yra įprasta lentelė su eilėmis ir stulpeliais. Tiesą sakant, dvimatis masyvas yra vienmatis vienmatis masyvas. Žemiau parodyta dvimačio masyvo, pavadinto a, kurio dydis yra m x n, struktūra (žr. 4 pav.).

4 pav. Masyvai C++

čia m yra dvimačio masyvo eilučių skaičius;
n yra dvimačio masyvo stulpelių skaičius;
m * n — masyvo elementų skaičius.

// sintaksė dvimačio masyvo deklaravimui /*duomenų tipas*/ /*masyvo pavadinimas*/;

Deklaruodami dvimatį masyvą, taip pat deklaruodami vienmatį masyvą, pirmiausia turite nurodyti:

• duomenų tipas;
• masyvo pavadinimas.

Po to pirmieji laužtiniai skliaustai nurodo dvimačio masyvo eilučių skaičių, o antrieji laužtiniai – dvimačio masyvo stulpelių skaičių. Dvimatis masyvas vizualiai atskiriamas nuo vienmačio masyvo antra laužtinių skliaustų pora. Pažvelkime į dvimačio masyvo deklaravimo pavyzdį. Tarkime, kad reikia deklaruoti dvimatį masyvą, kurio elementų skaičius lygus 15. Šiuo atveju dvimatis masyvas gali turėti tris eilutes ir penkis stulpelius arba penkias eilutes ir tris stulpelius.

// dvimačio masyvo deklaracijos pavyzdys: int a;

• a yra sveikųjų skaičių masyvo pavadinimas
• skaičius pirmuosiuose laužtiniuose skliaustuose nurodo dvimačio masyvo eilučių skaičių, šiuo atveju jų yra 5;
• skaičius antruose laužtiniuose skliaustuose nurodo dvimačio masyvo stulpelių skaičių, šiuo atveju jų yra 3.

// dvimačio masyvo inicijavimas: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Šis masyvas turi 5 eilutes, 3 stulpelius. po priskyrimo ženklo dedami bendrieji riestiniai skliaustai, kurių viduje dedama tiek porų garbanotųjų skliaustų, kiek turi būti eilučių dvimačiame masyve, ir šie skliaustai atskiriami kableliais. Kiekvienoje garbanotųjų skliaustų poroje parašykite dvimačio masyvo elementus, atskirtus kableliais. Visuose garbanotuose petnešose elementų skaičius turi būti vienodas. Kadangi masyve yra penkios eilutės, taip pat yra penkios vidinės skliaustų poros. Vidiniuose skliaustuose įrašyti trys elementai, nes stulpelių skaičius yra trys. Grafiškai mūsų masyvas atrodys kaip dvimatė lentelė (žr. 5 pav.).

5 paveikslas – C++ masyvai

Kiekvienoje dvimačio masyvo langelyje a rodoma reikšmė, šio langelio adresas rodomas apatiniame dešiniajame kampe. Dvimačio masyvo langelio adresas yra masyvo pavadinimas, eilutės numeris ir stulpelio numeris.

Sukurkime paprastą programą, skirtą apdoroti dvimatį masyvą, vadinamą „Labirintas“. Labirintas turi būti pastatytas dvimačio masyvo pagrindu. Labirinto dydį parinksime savo nuožiūra.

// array2.cpp: apibrėžia konsolės programos įėjimo tašką. #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); ) kitu atveju<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kodas Code::Blocks

// Dev-C++ kodas

// array2.cpp: apibrėžia konsolės programos įėjimo tašką. #įtraukti naudojant vardų sritį std; int main(int argc, char* argv) ( // 1 - sąlyginai "labirinto sienos" // 2 - "teisingas kelias, išėjimas iš labirinto" // 0 - "klaidingas kelias" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), // dvimačio masyvo inicijavimas ( 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) ); // dvi kilpos – vidinė ir išorinė, pasiekiančios kiekvieną masyvo elementą (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); ) kitu atveju<< " "; // вывести два пробела cout << endl; } return 0; }

Teisingi ir klaidingi keliai gali būti pažymėti tuo pačiu skaičiumi, pavyzdžiui, nuliu, bet aiškumo dėlei teisingas kelias žymimas skaičiumi 2. Masyvas inicijuotas rankiniu būdu, tik siekiant supaprastinti programą. Kadangi programa apdoroja dvimatį masyvą, norint perjungti dvimačio masyvo elementus, reikia dviejų kilpų. Pirmoji for loop perjungia dvimačio masyvo eilutes. Kadangi dvimačiame masyve yra 33 eilutės, skaitiklio kintamasis i padidinamas nuo 0 iki 33, 46 eilutė. Pirmosios kilpos viduje yra for kilpa, kuri sukasi per dvimačio masyvo eilutės elementus. Antrosios for ciklo korpuse viduje atliekama unarinio tipo duomenų konvertavimo operacija - static_cast<>() , kuris išspausdina simbolio numerį 176. Duomenų tipo konvertavimo operacija dubliuojama, kad būtų padidintas labirinto plotis. Programos rezultatas (žr. 6 pav.).

6 pav. Masyvai C++

Paskutinis atnaujinimas: 2017-09-17

Masyvas reiškia to paties tipo duomenų rinkinį. Formalus masyvo apibrėžimas yra toks:

Kintamojo_tipas masyvo_pavadinimas [masyvo_ilgis]

Po kintamojo tipo pateikiamas masyvo pavadinimas, o tada jo dydis laužtiniuose skliaustuose. Pavyzdžiui, apibrėžkime 4 skaičių masyvą:

Int skaičiai;

Šis masyvas turi keturis skaičius, tačiau visi šie skaičiai turi neapibrėžtą reikšmę. Tačiau mes galime atlikti inicijavimą ir priskirti kai kurias pradines reikšmes šiems skaičiams naudodami riestinius skliaustus:

Int skaičiai = (1,2,3,4);

Garbanotųjų skliaustų reikšmės taip pat vadinamos iniciatoriais. Jei inicializatorių yra mažiau nei elementų masyve, tada pirmiesiems elementams naudojami inicializatoriai. Jei masyve yra daugiau iniciatorių nei elementų, kompiliavimo metu įvyks klaida:

Int skaičiai = (1, 2, 3, 4, 5, 6);

Čia masyvo dydis yra 4, tačiau jam perduodamos 6 reikšmės.

Jei masyvo dydis nėra aiškiai nurodytas, jis nustatomas pagal iniciatorių skaičių:

Int skaičiai = (1, 2, 3, 4, 5, 6);

Šiuo atveju masyvas turi 6 elementus.

Simbolių masyvų inicijavimas turi savo ypatybes. Į simbolių masyvą galime perduoti ir iniciatorių rinkinį, ir eilutę:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "pasaulis";

Be to, antruoju atveju masyvas s2 turės ne 5 elementus, o 6, nes inicijuojant su eilute, į simbolių masyvą automatiškai pridedamas nulinis simbolis „\0“.

Šiuo atveju neleidžiama priskirti vieno masyvo kitam masyvui:

Int numeriai1 = (1,2,3,4,5); int numeriai2 = skaičiai1; // klaida numeriai2 = numeriai1; // klaida

Kai masyvas yra apibrėžtas, mes galime pasiekti atskirus jo elementus pagal indeksą. Indeksai prasideda nuo nulio, todėl norėdami pasiekti pirmąjį elementą turime naudoti indeksą 0. Pasiekę elementą pagal indeksą, galime gauti jo reikšmę arba pakeisti:

#įtraukti int main() ( int skaičiai = (1,2,3,4); int pirmasis_skaičius = skaičiai; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Masyvo elementų skaičių taip pat galima nustatyti naudojant konstantą:

Const int n = 4; int skaičiai[n] = (1,2,3,4);

Iteravimas per masyvus

Naudodami kilpas galite kartoti visą masyvą ir pasiekti jo elementus naudodami indeksus:

#įtraukti int main() ( int skaičiai = (1,2,3,4); int dydis = dydis(skaičiai) / dydis(skaičiai); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Norėdami pereiti per masyvą, pirmiausia turite rasti masyvo ilgį. Ilgiui nustatyti naudojamas operatorius sizeof. Iš esmės masyvo ilgis yra lygus bendram jo elementų ilgiui. Visi elementai yra to paties tipo ir užima tokio paties dydžio atmintyje. Todėl naudodamiesi išraiška sizeof(numbers) randame viso masyvo ilgį baitais, o naudodami sizeof(numbers) išraišką – vieno elemento ilgį baitais. Padalinę dvi reikšmes, galite gauti masyvo elementų skaičių. Ir tada, naudojant for kilpą, kartojame visus elementus, kol skaitiklis i tampa lygus masyvo ilgiui. Dėl to visi masyvo elementai bus rodomi konsolėje:

Tačiau yra ir kita for ciklo forma, sukurta specialiai darbui su kolekcijomis, įskaitant masyvus. Ši forma turi tokį formalų apibrėžimą:

For (kintamojo tipas: kolekcija) ( instrukcijos; )

Mes naudojame šią formą norėdami kartoti masyvą:

#įtraukti int main() ( int skaičiai = (1,2,3,4); for(int skaičius: skaičiai) std::cout<< number << std::endl; return 0; }

Iteruojant per masyvą, kiekvienas iteruotas elementas bus patalpintas į skaičiaus kintamąjį, kurio reikšmė konsolėje atspausdinama cikle.

Jei nežinome masyve esančių objektų tipo, tipui nustatyti galime naudoti automatinį specifikatorių:

For(automatinis numeris: skaičiai) std::cout<< number << std::endl;

Daugiamačiai masyvai

Be vienmačių masyvų, C++ turi ir daugiamačius. Tokių masyvų elementai savo ruožtu yra masyvai, kurių elementai taip pat gali būti masyvai. Pavyzdžiui, apibrėžkime dvimatę skaičių masyvą:

Int skaičiai;

Toks masyvas susideda iš trijų elementų, kurių kiekvienas reiškia dviejų elementų masyvą. Inicijuokime masyvą taip:

Int skaičiai = ( (1, 2), (4, 5), (7, 8) );

Įdėtos garbanotos skliaustai apibrėžia kiekvieno pogrupio elementus. Tokį masyvą taip pat galima pavaizduoti kaip lentelę:

1	2
4	5
7	8

Be to, inicijuodami galite praleisti garbanotas petnešas:

Int skaičiai = ( 1, 2, 4, 5, 7, 8 );

Taip pat galima inicijuoti ne visus elementus, o tik kai kuriuos:

Int skaičiai = ( (1, 2), (), (7) );

Ir norint pasiekti įdėto masyvo elementus, jums reikia dviejų indeksų:

Int skaičiai = ( (1, 2), (3, 4), (5, 6) ); std::cout<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Pakartokime dvimatį masyvą:

#įtraukti int main() ( const int eilutės = 3, stulpeliai = 2; int skaičiai = ( (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; }

Taip pat galite naudoti kitą for ciklo formą, kad galėtumėte kartoti daugiamačio masyvo elementus:

#įtraukti int main() ( const int eilutės = 3, stulpeliai = 2; int skaičiai = ( (1, 2), (3, 4), (5, 6) ); for(automatiniai &subnumers: numeriai) ( for(int number : ponumeriai) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Norint kartoti masyvus, kurie yra įtraukti į masyvą, naudojamos nuorodos. Tai reiškia, kad išoriniame cikle for(automatiniai &subnumeriai: skaičiai) &subnumers reiškia pogrupio nuorodą masyve. Vidinėje kilpoje for(int number: subnumbers) iš kiekvienos pogrupių poskyrio gauname atskirus elementus į skaičių kintamąjį ir išvedame jo reikšmę į konsolę.

Masyvai skirti saugoti kelias to paties tipo reikšmes. Pavyzdžiui, programoje pagal Farenheitą iki Celsijaus apskaičiavome vidutinę temperatūros reikšmę iš trijų. Jei yra ne trys reikšmės, o daug daugiau, tada čia reikia naudoti masyvus.

Prieš naudodami masyvą, turite jį apibrėžti. Masyvo apibrėžimas apima: masyve saugomų duomenų tipą, masyvo pavadinimą ir masyvo elementų skaičių laužtiniuose skliaustuose:

int masyvas;

Šiame kode mes apibrėžėme masyvą su identifikatoriumi (pavadinimu) masyvu iš dešimties elementų, kurių tipas yra int.
Šioje formoje visi masyvo elementai vis dar nėra inicijuoti. Norėdami juos inicijuoti, kai jie paskelbti, turite naudoti šią sintaksę:

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

Tokiu atveju pirmajam masyvo elementui priskiriama reikšmė 0, o paskutiniam - 9.
Galite naudoti kilpas, kad priskirtumėte reikšmes masyvo elementams. Tam tinkamiausia būtų for kilpa.

C++ kodas int masyvas; //masyvo apibrėžimas (int i = 0; i< 10; i++) { array[i] = i; }

Čia mes pasiekiame kiekvieną masyvo elementą per indeksą - skaičių laužtiniuose skliaustuose. Su kiekviena ciklo iteracija ji paima reikšmes nuo nulio iki 9.

Atminkite, kad indekso numeracija prasideda nuo nulio. Todėl indeksų skaičius visada yra vienu mažesnis nei masyvo elementų skaičius.

Išskyrus laužtinius skliaustus ir indeksą, masyvo elementas naudojamas kaip ir bet kuris kintamasis.

Stygos

Iki šiol eilutes galėjome saugoti tik konstantose: „Konstantinės eilutės pavyzdys“. Kintamuosiuose galėjome saugoti tik vieną simbolį – char tipo. C++ naudoja dviejų tipų eilutes: char ir str tipo elementų masyvą. Šiuo metu mes sutelksime dėmesį į pirmąjį variantą.

Norėdami išsaugoti eilutę, mums reikia masyvo. Tai atrodo maždaug taip:

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

Laimei, yra paprastesnis būdas :)

char string = "eilutė";

Tokiu atveju automatiškai bus sukurtas septynių elementų masyvas. Kodėl iš septynių? Esmė ta, kad kiekviena eilutė turi baigtis simbolių konstanta „\0“, kuri reiškia tuščią baitą.

Ankstesniuose pavyzdžiuose, jei į eilučių masyvą bandysime įvesti didesnę nei šešių simbolių eilutę, masyvas persipildys, nes Negalite pakeisti masyvo dydžio, kol programa veikia (nors ne visada):

anglies styga; // eilutėje gali būti šeši simboliai ir "\0"

string = "styga!"; // eilutėje yra septyni simboliai
Nerekomenduojama to daryti :)

Yra dar vienas dalykas, į kurį noriu atkreipti jūsų dėmesį. Kai vartotojas įveda eilutę, tarpai skaičiuojami kaip "\0". Mes kol kas neįvesime eilučių į savo programas, todėl šio atvejo išsamiai nepaaiškinsiu.

Masyvų masyvai (dvimačiai masyvai)

Na, pagaliau priėjome prie svarbiausio šio klausimo dalyko.

Žemėlapis strateginiuose (ir ne tik) žaidimuose (RTS) yra padalintas į langelius (anglų kalba - plytelė). Patogu šias ląsteles pavaizduoti naudojant dvimatį masyvą.

Šiame pavyzdyje toliau dirbsime su pseudo_game programa ir, naudodami dvimatį masyvą, imituosime žemėlapį, kuriame žaidėjas gali judėti. Iki šiol „judėjimas“ buvo vaizduojamas naudojant x, y koordinates.

Ląsteles pavaizduosime simboliais. "Atvirutės" dydis yra 15x20. Penkiolika aukščio, dvidešimties pločio. Žaidėją pavaizduosime simboliu T.

Pirmiausia pridėkite antraštės failą stdlib.h.

Patobulintas pseudo_game

Pateiksiu tik kodo dalis. Patartina, kad visa programa būtų prieš akis. Jį rasite skiltyje „Programų sąrašai“ – pseudo_game_0_2. Jis kompiliuoja ir veikia. Tiesiog nukopijuokite jį į savo IDE redaktorių ir sekite tekstą.

Duomenų inicijavimas:

C++ kodas charakterio aktas; // kintamasis vartotojo įvesties skaitymui int ch; // kintamasis, skirtas saugoti sumažintą kintamojo reikšmę act int x = 0; // du kintamieji žaidėjo koordinatėms saugoti int y = 0; char žemėlapis; // masyvas žaidimo kortelei saugoti // masyvo inicijavimas (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Čia mums naujas operatorius yra dvimačio masyvo apibrėžimas. Tačiau jis beveik nesiskiria nuo vienmačio, tiesiog pridedant dar vieną laužtinių skliaustų porą. Pirmuosiuose skliausteliuose nurodėme eilučių skaičių, antrajame - stulpelių skaičių.

Po to dviem kilpomis kiekvieną masyvo elementą inicijuojame reikšme „ “ – tai tik tarpo simbolis. Pirma, išorinėje kilpoje mes einame per visas eilutes. Kiekvienai vidinės kilpos eilutei „pervažiuojame“ stulpelius.

Pateiksiu išsamų pavyzdį: po kelių išorinės kilpos iteracijų skaitiklis i tampa lygus 9. Pradedamas vykdyti išorinės kilpos korpusas: kintamasis j (vidinės kilpos skaitiklis) inicijuojamas iki nulio, patikrinama sąlyga ir vykdomas vidinio ciklo turinys: map = " ";, Tai yra, pirmajam dešimtos eilutės simboliui (indeksui nuliui) (nepamirškite, kad atgalinis skaičiavimas yra nuo nulio) priskiriamas tarpas. Tada skaitikliui j priskiriamas 1, vykdomas ciklo korpusas... ir taip toliau, kol skaitiklis j tampa lygus 20 - sąlyga neįvykdyta ir vidinė kilpa išeina. Tada išorinis skaitiklis padidinamas. Dabar jis lygus 10 ir vėl vykdomas išorinės kilpos kūnas...

Po inicijavimo su tarpais savo žaidimo veikėją įdedame į pirmos eilutės pirmąjį stulpelį.

Pagrindinės ciklo pradžioje iškviečiame funkciją system(), kad išvalytume ankstesnės išvesties ekraną.

Tada yra du ciklai, panašūs į inicijavimo ciklus. Jie naudojami masyvo elementams rodyti ekrane. Vienintelis reikšmingas skirtumas yra naujos eilutės simbolio išvestis pirmosios kilpos korpuso pabaigoje.

Na, tada yra šaka, kurioje nustatoma, kuris klavišas yra paspaustas. Pats išsišakojimas nuo praėjusio karto mažai pasikeitė, tačiau yra skirtumų tarp blokų turinio: pirmiausia koordinatėms, kurioje yra objektas, priskiriame tarpą. Tai yra, išvalome ankstesnę vietą. Tada pakeičiame vieną iš koordinačių. Ir tada masyvo elementui su naujais indeksais priskiriame simbolį „T“.

Kodo „75“ pavyzdys – judėjimas į kairę:

C++ kodas if else (ch == 75) ( žemėlapis[x][y] = " "; y--; žemėlapis[x][y] = "T"; )

Na, tai viskas. Šiuo metu turime 15x20 žemėlapį, kuriame rodyklėmis galite perkelti simbolį – raidę „T“. Neblogai šešta pamoka! Ši programa taps visų mūsų konsolių programų pagrindu. Grafinių patobulinimų nebus. Jūs tiesiog negalite gauti daugiau naudos iš DOS konsolės, ir mes nesvarstysime apie Windows konsolę. Tai žymiai sutaupys laiko ir pastangų.

Aš išsamiai pakomentavau pseudo_game programą ir greičiausiai tai suprasite be vargo. Jei ne, perskaitykite programos sąrašą ir nesuprasite šios problemos, kol nesuprasite :). Pratimai padės sutvirtinti medžiagą. Pratimų atlikimas yra privalomas. Jei kas neaišku, rašykite į mano el.paštą – pasistengsiu padėti.

Pratimai:

1. Visame programos sąraše naudojau jungiklio šakojimą. Čia taip pat rodomas vienos if šakos bloko kodas. Pridėkite likusius jei blokus.

2. Dabar programa gali rašyti į neegzistuojančius masyvo elementus. Patikrinkite, ar nepaliekate žemėlapio ribų.

3. Praktikai sukurkite programą, kuri ekrane nubrėžia du laukus jūrų mūšiui. Pirmasis skirtas žaidėjui, antrasis - priešui. Antrasis laukas turi būti dešinėje nuo pirmojo.
Užpildykite vidines ląsteles tarpais. Norėdami nubrėžti kraštinę, naudokite minusą ir tiesią skiriamąją liniją: -, |, o kampams naudokite maišą #. Kiekvieno lauko kairėje yra skaičių krūva; viršuje yra raidės.
Norint inicijuoti visą lauką, gali prireikti kelių kilpų. Štai kaip gali atrodyti kodas, užpildantis skaičių stulpelį antrame lauke:

C++ kodas int eilutė; // kintamasis, vaizduojantis eilutes int column; // kintamasis, vaizduojantis stulpelius char map; stulpelis = 15; for (eilutė = 2; eilutė< 12; string++) { map = string - 1; }

Tarkime, kad turime dirbti su dideliu kiekiu to paties tipo duomenų. Pavyzdžiui, mes turime tūkstantį švytuoklės koordinačių matavimų su tam tikru laiko žingsniu. Sukurti 1000 kintamųjų visoms reikšmėms išsaugoti yra labai... sudėtinga. Vietoj to, daugelis to paties tipo duomenų gali būti sujungti vienu pavadinimu ir kiekvienas konkretus elementas gali būti pasiekiamas pagal jo serijos numerį.
Masyvas C apibrėžiamas taip
<тип> <имя массива>[<размер>];
Pavyzdžiui,
int a;
Gausime masyvą pavadinimu a, kuriame yra šimtas tipo elementų tarpt. Kaip ir kintamuosiuose, masyve yra šiukšlių.
Norėdami pasiekti pirmąjį elementą, laužtiniuose skliaustuose parašykite jo numerį (indeksą). Pavyzdžiui

#įtraukti #įtraukti void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Pirmasis elementas turi indekso numerį 0. Svarbu suprasti, kodėl. Toliau kompiuterio atmintį pavaizduosime kaip juostą. Masyvo pavadinimas yra rodyklė į atminties adresą, kuriame yra masyvo elementai.

Ryžiai. 1 Masyve saugomas pirmojo elemento adresas. i elemento indeksas yra i*sizeof(type) baitų poslinkis nuo pradžios

Masyvo indeksas rodo, kiek baitų reikia perkelti nuo masyvo pradžios, kad būtų pasiektas norimas elementas. Pavyzdžiui, jei masyvas A turi tipą tarpt, tada A reiškia, kad mes perkėlėme 10*sizeof(int) baitų, palyginti su pradžia. Pirmasis elementas yra pačioje pradžioje ir jo poslinkis yra 0*sizeof(int) .
C kalboje masyvas neišsaugo savo dydžio ir netikrina masyvo indekso teisingumo. Tai reiškia, kad galite išeiti už masyvo ribų ir pasiekti atmintį, kuri yra toliau nei paskutinis masyvo elementas (arba arčiau).

Pradinis masyvo inicijavimas.

Parašykime paprastą programą. Sukurkime masyvą ir raskime maksimalų jo elementą.

#įtraukti #įtraukti void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); nepasirašytas i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Pažiūrėkime į pavyzdį. Pirmiausia sukuriame masyvą ir inicijuojame jį sukūrę. Po to maksimaliam rastam elementui priskiriame pirmojo masyvo elemento reikšmę.

Max = a;

Tada einame per masyvą. Kadangi mes jau peržiūrėjome pirmąjį elementą (jo indeksas 1), nėra prasmės į jį žiūrėti dar kartą.
Tas pats pavyzdys, tik dabar vartotojas įveda reikšmes

#įtraukti #įtraukti void main() ( int a; nepasirašytas i; int max; printf ("Įveskite 10 skaičių\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("maksimalus elementas yra %d", max); getch(); )

Jei inicijavimo metu nurodoma mažiau reikšmių nei masyvo dydis, likę elementai užpildomi nuliais.

#įtraukti #įtraukti void main() ( int a = (1,2,3); nepasirašytas i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Jei reikia užpildyti visą masyvą nuliais, rašykite

Int a = (0);

Pavyzdžiui, jums nereikia aiškiai nurodyti masyvo dydžio

Int a = (1, 2, 3);

masyvas bus 3 dydžio

Masyvo dydis

C masyvas turi būti pastovaus dydžio. Tai reiškia, kad neįmanoma, pavyzdžiui, paprašyti vartotojo dydžio ir nustatyti šio dydžio masyvą.

Printf ("Įveskite masyvo ilgį"); scanf("%d", &ilgis); (plaukioti x;)

Dinaminių masyvų kūrimas bus toliau aptariamas dirbant su rodyklėmis ir atmintimi
Kai kuriais atvejais masyvo dydį galite sužinoti naudodami funkciją dydis.

#įtraukti #įtraukti void main() ( int A; //sizeof grąžina viso masyvo dydį baitais //Norėdami nustatyti elementų skaičių, //padalinkite masyvo dydį iš jo elemento dydžio int size = sizeof(A) / sizeof(int) printf("Masyvo dydis lygus %d", dydis();

Tačiau vargu ar tai bus naudinga. Perduodant masyvą kaip argumentą funkcijai, bus perduodama rodyklė, todėl masyvo dydis nebus žinomas.
Statiniai masyvai naudingi, kai elementų skaičius yra žinomas iš anksto. Jie suteikia greitą, bet nesaugią prieigą prie elementų.

Masyvo perpildymas

Tikėkimės, kad turite šį kodą

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

Čia yra kilpa dėl nurodyta su klaida. Kai kuriose senesnėse kompiliatorių versijose šis kodas būtų kilpinis. Esmė ta, kad kintamasis i buvo kompiliavimo metu iškart po masyvo A. Kai masyvas peržengė ribas, skaitiklis buvo nustatytas ties 1.
Masyvai yra nesaugūs, nes neteisingai dirbant su indeksu gali būti pasiekiama savavališka atminties dalis (Teoriškai. Šiuolaikiniai kompiliatoriai patys rūpinasi, kad nesigilintumėte į kažkieno atmintį).
Jei dirbate su masyvais, turite užtikrinti, kad skaitiklis neviršytų masyvo dydžio ir nebūtų neigiamas. Tam bent jau

• 1. Indeksavimui naudokite tipą size_t. Tai apsaugos jus nuo neigiamų verčių ir visada užteks bet kokio dydžio masyvai.
• 2. Atminkite, kad masyvas prasideda nuo nulio.
• 3. Paskutinis masyvo elementas turi indeksą (masyvo dydis yra 1)

Nėra visaverčių būdų patikrinti, ar neperžengėme masyvo ribų, ar ne. Todėl arba tiksliai žinome jo dydį, arba saugome jį kintamajame ir prireikus perskaitome.

Pavyzdžiai

Štai keletas tipiškų darbo su masyvais pavyzdžių
1. Apverskite masyvą.

#įtraukti #įtraukti //Tai makrokomanda. DYDIS kode bus pakeistas 10u #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); nepasirašytas i, j; // skaitikliai unsigned half // masyvo vidurys unsigned tmp //laikinas kintamasis, skirtas keistis reikšmėmis half = SIZE / 2 //Vienas skaitiklis eina iš kairės į dešinę, kitas (i = 0, j = DYDIS - 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(); }

Štai jums nepažįstamas dizainas

#define DYDIS 10u

makrokomandą. Per visą kodą išankstinis procesorius automatiškai pakeis visus DYDŽIO atvejus 10u.
2. Vartotojo pasirinkto elemento ištrynimas.

#įtraukti #įtraukti #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); nepasirašytas i; //skaitiklio int indeksas; //indeksas, kurį įvedė naudotojas //Išvesties masyvas, skirtas (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 && indeksas< 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(); }

Šiuo atveju, žinoma, elementas nėra ištrintas. Masyvas išlieka tokio pat dydžio kaip ir anksčiau. Mes tiesiog perrašome šalinamą elementą kitu ir išvedame SIZE-1 elementus.
3. Vartotojas įveda reikšmes į masyvą. Po to išspausdinkite visas skirtingas jo įvestas reikšmes.
Leiskite vartotojui įvesti baigtinį elementų skaičių, tarkime, 10. Tada iš anksto žinoma, kad iš viso nebus daugiau nei 10 skirtingų reikšmių Kiekvieną kartą, kai vartotojas įves skaičių, mes eisime per masyvą ir patikrinsime ar buvo įvestas toks skaičius.

#įtraukti #įtraukti #define SIZE 10u void main() ( int A = (0); nepasirašytas i, j; int skaitiklis = 1; //kiek skirtingų skaičių įvesta. Bent vienas. int įvestis; int nebuvo rasta; //pažymėkite, kad įvestas skaičius nerastas //Įveskite pirmąjį skaičių. 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. Vartotojas įveda skaičių – matavimų skaičių (nuo 2 iki 10). Po to įvedami visi matavimai. Programa rodo vidutinę reikšmę, dispersiją ir klaidą.

#įtraukti #įtraukti #įtraukti #define SIZE 20u void main() ( //Studento koeficientai prasideda nuo dviejų matmenų 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; besigned limit; float suma = .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. Burbulas kaip masyvas

#įtraukti #įtraukti #define DYDŽIO 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, char flag (i = 0;< 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; vėliavėlė = tiesa; ) ) ) while(flag == true); //Išvesti surūšiuotą masyvą (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Sumaišykite masyvą. Tam panaudokime algoritmą