Statinis masyvas: deklaravimas, pildymas, naudojimas. Vienmačiai masyvai Masyvo elementų surašymo būdai c

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ą ar 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 – tai ir išskiria masyvą iš visų kitų kintamųjų.

//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 dydis gali būti nenurodytas tik jį inicijuojant; įprastai deklaruojant masyvą, 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ų sritį 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šiolikto indekso. O kadangi langelių numeracija prasideda nuo nulio, tai masyve elementų yra 16. 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 pav. Masyvai C++

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ų sritį std; int main(int argc, char* argv) ( int masyvas1; // paskelbti sveikojo skaičiaus 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-uoju 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 – masyvai C++ kalboje

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++ kalba

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 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 pav. Masyvai C++

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

Teisingas ir klaidingas kelias gali būti žymimas 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++

Masyvai

Masyvas yra to paties tipo kintamųjų rinkinys su bendru pavadinimu, kuriuo jie nurodomi. C# kalboje masyvai gali būti vienmačiai arba daugiamačiai. Masyvai naudojami įvairiems tikslams, nes jie yra patogi priemonė sugrupuoti susijusius kintamuosius.

Masyvus C# galite naudoti taip pat, kaip ir kitose programavimo kalbose. Tačiau jie turi vieną ypatumą: jie įgyvendinami kaip objektai.

Masyvo naudojimas programoje reikalauja dviejų žingsnių procedūros, nes C# masyvus įgyvendina kaip objektus. Pirmiausia turite deklaruoti kintamąjį, kuris gali pasiekti masyvą. Antra, naudodami naują operatorių turite sukurti masyvo egzempliorių.

Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; vardų sritis ConsoleApplication1 ( class Program ( static void Main(string args)) ( // Paskelbkite masyvą int myArr = new int; // Rankiniu būdu inicijuokite kiekvieną masyvo elementą myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 ; foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); ) ) )

Atminkite, kad jei masyvas ką tik deklaruojamas, bet nėra aiškiai inicijuotas, kiekvienam elementui bus nustatyta numatytoji atitinkamo duomenų tipo reikšmė (pavyzdžiui, bool tipo masyvo elementai bus nustatyti į false, o elementų int tipo masyvas bus nustatytas į 0).

Masyvo inicijavimas

Be masyvo elemento užpildymo po elemento (kaip parodyta ankstesniame pavyzdyje), taip pat galite jį užpildyti naudodami specialią masyvo inicijavimo sintaksę. Norėdami tai padaryti, į masyvą įtrauktus elementus turite surašyti skliausteliuose ( ). Ši sintaksė naudinga kuriant žinomo dydžio masyvą ir norint greitai nustatyti jo pradines reikšmes:

// Sintaksė masyvo inicijavimui naudojant // raktinį žodį new int myArr = new int (10,20,30,40,50); // Sintaksė masyvo inicijavimui nenaudojant // raktinio žodžio new string info = ( "Pavardė", "Vardas", "Patronimas" ); // Naudokite naują raktinį žodį ir norimo dydžio char simbolį = new char ( "X", "Y", "Z", "M" );

Atminkite, kad naudojant garbanotųjų skliaustų sintaksę, nereikia nurodyti masyvo dydžio (kaip matyti kuriant myArr kintamąjį), nes dydis automatiškai apskaičiuojamas pagal elementų skaičių riestiniuose skliaustuose. Taip pat naudokite raktinį žodį naujas neprivaloma (kaip kuriant informacijos masyvą).

Raktinis žodis var leidžia apibrėžti kintamąjį, kad kompiliatorius nustatytų jo tipą. Taip pat panašiu būdu galite apibrėžti netiesiogiai įvestus vietinius masyvus. Naudodami šį metodą, galite apibrėžti naują masyvo kintamąjį nenurodydami masyve esančių elementų tipo. Pažiūrėkime į pavyzdį:

Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; vardų sritis ConsoleApplication1 ( klasė Programa ( statinė void Main (string args) ( var arr1 = new ( 1, 2, 3 ); ); Console.WriteLine ("Masyvo tipas arr1 yra (0)", arr1.GetType()); var arr2 = new ( "One", "Two", "Three" ); Console.WriteLine("Masyvo tipas arr2 - (0)",arr2.GetType()); Console.ReadLine(; ) ) )

Žinoma, kaip ir kuriant masyvą naudojant aiškią C# sintaksę, masyvo inicijavimo sąraše nurodyti elementai turi būti to paties pagrindinio tipo (ty jie visi turi būti int, string arba MyCar).

Objektų masyvo apibrėžimas

Daugeliu atvejų, apibrėžiant masyvą, masyve esančio elemento tipas yra aiškiai nurodytas. Nors iš pirmo žvilgsnio tai atrodo gana paprasta, yra viena svarbi savybė. Visų tipų .NET tipo sistemoje (įskaitant pagrindinius duomenų tipus) esmė yra pagrindinė klasė System.Object. Rezultatas yra tas, kad jei apibrėžiate objektų masyvą, jame esantys elementai gali būti bet kokie:

Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; vardų sritis ConsoleApplication1 ( class Program ( static void Main(string args)) ( // Deklaruoti ir inicijuoti objektų masyvą object arrByObject = ( true, 10, "Hello", 13.7m ); // Atspausdinkite kiekvieno masyvo nario tipą į konsolės foreach (objektas mane arrByObject) Console.WriteLine("Tipas (0) - (1)",me,me.GetType()); Console.ReadLine(; ) ) )

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); getch(); )

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 nepasirašytą pusę; //masyvo vidurys unsigned tmp; //laikinas kintamasis, skirtas keistis reikšmėmis half = SIZE / 2; //Vienas skaitiklis eina iš kairės į dešinę, kitas iš dešinės į kairę (i = 0, j = DYDIS – 1; i< 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 neištrinamas. 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 skirtingų reikšmių iš viso nebus daugiau nei 10. Kiekvieną kartą, kai vartotojas įves skaičių, pereisime 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 numeris nerastas //Įveskite pirmąjį skaičių. Jis dar nerastas. printf("0. "); scanf("%d", &A); for (i = 1; i< 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 tmp; float suma = .0f; float mean; float disp; float absError; float relError; do ( printf("Įveskite matavimų skaičių "); scanf("%u", &limit); if (riba > 1 && limit< 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. Masyvo burbulų rūšiavimas

#į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; nepasirašytas i, j; simbolio vėliavėlė; //Išvesti masyvą, skirtą (i = 0; i< 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ą

Kas yra masyvai C?

Kaip deklaruoti masyvus C?

Kaip inicijuoti masyvus C?

Masyvai C manekenams.

Masyvai C

C masyvas yra to paties tipo elementų, kuriuos galima pasiekti naudojant indeksą, rinkinys. C masyvų elementai yra vienas po kito kompiuterio atmintyje.

Paprastas pavyzdys, kaip sukurti ir užpildyti masyvą C:

// @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); grįžti 0 ;)

Mes gauname:

Pavyzdyje deklaruojame masyvą, kuriame yra int tipo elementai:

čia masyvo pavadinimas yra nArr, masyvo elementų skaičius yra trys, masyvo elemento tipas yra int.

Masyvas yra elementų rinkinys. Kiekvienas masyvo elementas gali būti nurodytas jo numeriu. Skaičius paprastai vadinamas indeksu. Masyvo elementai numeruojami pradedant nuo nulio. Pirmajam masyvo elementui priskirkime reikšmę, o pirmojo elemento indeksas nulis:

Antram masyvo elementui priskirkime reikšmę, o antrasis elementas turi vieną indeksą:

Trečiajam masyvo elementui priskirkime reikšmę, o trečiasis elementas turi antrą indeksą:

Kai ekrane rodome masyvo elementus, gauname jų reikšmes. Kaip šitas:

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

Norėdami gauti masyvo elementą, turite nurodyti masyvo pavadinimą ir elemento indeksą:

Tai pirmasis masyvo elementas, nes pirmojo elemento indeksas yra nulis.

Kintamajam int a priskirkime trečiojo masyvo elemento reikšmę:

trečiojo masyvo elemento indeksas yra lygus dviem, nes indeksai skaičiuojami nuo nulio.

Dabar bendroji masyvų deklaravimo taisyklė C: deklaruodami masyvą, turite nurodyti jo pavadinimą, elementų tipą ir elementų skaičių. Elementų skaičius yra natūralusis skaičius, t.y. visuma teigiama. Nulis negali būti elementų skaičius. Negalite nurodyti kintamo masyvo elementų skaičiaus. Čia yra C masyvo deklaracijų pavyzdžiai:

int nArr; // Masyvas paskelbtas turintis šimtą sveikųjų skaičių;
plaukioti toli; // Deklaruotas masyvas, skirtas saugoti 5 plaukiojančius skaičius;
char carr; // Deklaruota, kad masyvas saugo du simbolius;

Būtų klaida deklaruoti masyvą su kintamu elementų skaičiumi:

Int varElem;
int nArr; // Klaida! Elementų skaičiaus negalima nustatyti į kintamąjį;

Bet jūs galite nustatyti elementų skaičių su pastovia verte: tiesioginiu teigiamu sveikuoju skaičiumi 1, 2, 3... arba konstanta:

Const int masyvoIlgis = 3;
int nArr;

Deklaruodami masyvą C, galite iš karto jį inicijuoti:

int nMasyvumas = (1, 2, 3);

Galite praleisti masyvo elementų skaičių laužtiniuose skliaustuose, jei visi masyvo elementai yra inicijuoti:

int nMasyvumas = (1, 2, 3);

elementų skaičius tokiu atveju bus nustatytas automatiškai.

Deklaruodami galite apibrėžti tik dalį masyvo elementų:

int nMasyvumas = (1, 2);

šiame pavyzdyje pirmieji du masyvo elementai inicijuojami, bet trečiasis neapibrėžtas.

Simbolių masyvo pavyzdys:

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

Deklaruodami masyvą negalite nurodyti kintamojo elementų skaičiaus. Bet jūs galite naudoti kintamuosius, kai pasiekiate masyvo elementus:

Int ind = 0;
char cr = cArr;

Tai naudojama dirbant su kilpomis. Pavyzdys:

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

Pavyzdyje pirmoje kilpoje užpildome masyvą int tipo elementais, o antroje kilpoje šiuos elementus rodome ekrane.