Keling, C++ asoslarini o'rganishni davom ettiraylik. Ushbu maqolada biz massivlarni ko'rib chiqamiz.

Massivlar katta hajmdagi ma’lumotlarni qulay formatda saqlash imkonini beradi. Aslida, massiv bir nechta qiymatlarni bitta nom ostida saqlaydigan o'zgaruvchidir, lekin har bir qiymat o'z indeksiga ega. indekslar kirish uchun ishlatiladigan qiymatlar ro'yxati.

Massivlarga kirish

Siz massivni shunday tasavvur qilishingiz mumkin:

Bu birin-ketin, bir nom ostida saqlanadigan ba'zi qiymatlar to'plami. Ushbu qiymatlarni olish uchun siz yangi o'zgaruvchilar yaratishingiz shart emas, faqat qiymat massivda saqlanadigan indeksni ko'rsatishingiz kerak. Misol uchun, siz poker uchun beshta o'yin kartalari to'plamini hal qilishingiz kerak, siz ushbu kartalarni massivda saqlashingiz va yangi o'zgaruvchini ishlatish o'rniga yangi kartani tanlash uchun faqat indeks raqamini o'zgartirishingiz mumkin. Bu sizga barcha kartalarni ishga tushirish uchun bir xil koddan foydalanishga imkon beradi va quyidagi tarzda yozishni davom ettiradi:

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

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

Endi 100 ta o'zgaruvchi bo'lsa, farqni tasavvur qiling!

Sintaksis

Massivni e'lon qilish uchun siz ikkita narsani ko'rsatishingiz kerak (nomdan tashqari): massivning turi va o'lchami:

Int my_array[ 6 ];

Bu qator oltita butun qiymatdan iborat massivni e'lon qiladi. E'tibor bering, massiv o'lchami massiv nomidan keyin kvadrat qavs ichiga olinadi.

Massiv elementlariga kirish uchun kvadrat qavslardan foydalanasiz, lekin bu safar siz kirishni istagan element indeksini belgilaysiz:

My_massiv [ 3 ];

Ushbu jarayonni quyidagicha tasavvur qilishingiz mumkin:

my_array butun massivga ishora qiladi, my_array esa faqat birinchi elementga, my_array to'rtinchi elementga ishora qiladi. shu esta tutilsinki indekslash massivdagi elementlar 0 dan boshlanadi. Shunday qilib, massiv elementlariga kirish har doim ofset bilan sodir bo'ladi, masalan:

Int my_array[ 4 ]; // massiv deklaratsiyasi my_array[ 2 ] = 2; // uchinchi (ya'ni uchinchi!) qiymatini 2 ga qo'ying

C++ da ko'p o'lchovli massivlarni e'lon qilish

Massivlar shaxmat taxtasi yoki tic-tac-toe kabi ko'p o'lchovli ma'lumotlarni ko'rsatish uchun ham ishlatilishi mumkin. Ko'p o'lchovli ma'lumotlardan foydalanganda massiv elementlariga kirish uchun bir nechta indekslardan foydalaniladi.

Ikki o'lchovli massivni e'lon qilish uchun siz ikki o'lchamning o'lchamini belgilashingiz kerak:

Int tic_tac_toe_board;

Massivni uning elementlari indekslari bilan ko'rish:

Bunday massivning elementlariga kirish uchun sizga ikkita indeks kerak bo'ladi - biri satr uchun, ikkinchisi ustun uchun. Rasmda elementlarning har biriga kirish uchun kerakli indekslar ko'rsatilgan.

Massivlardan foydalanish

Massivlardan foydalanganda, sizsiz qilolmaysiz. Bir tsiklni o'tkazish uchun siz shunchaki o'zgaruvchini nolga keltiring va uni massiv hajmidan oshguncha oshiring - bu tsikl uchun mos naqsh.

Quyidagi dastur ko'paytirish jadvalini yaratish va natijani ikki o'lchovli massivda saqlash uchun tsikldan foydalanishni ko'rsatadi:

#o'z ichiga oladi std nom maydonidan foydalanish; int main() ( int array; // (int i = 0; i) uchun shaxmat taxtasiga o'xshash massivni e'lon qilish< 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"; } } }

Massivlarni funksiyalarga o‘tkazish

Ko'rib turganingizdek, C++ tilining turli elementlari bir-biri bilan o'zaro ta'sir qiladi. Looplarda bo'lgani kabi, massivlar bilan birgalikda ishlatilishi mumkin.

Massivni funktsiyaga o'tkazish uchun uning nomini ko'rsatish kifoya:

Int qiymatlari [ 10 ]; yig'indisi_massiv(qiymatlar);

Va funktsiyani e'lon qilganda, argument sifatida massivni ko'rsating:

Int sum_massiv (int qiymatlari);

E'tibor bering, biz funktsiya argumentlarida massivning o'lchamini ko'rsatmaymiz, bu bir o'lchovli massivlar uchun o'lchamni ko'rsatishga hojat yo'q; O'lcham qachon ko'rsatilishi kerak massivlarni e'lon qilish , chunki Kompilyator qancha xotira ajratish kerakligini bilishi kerak. Funktsiyaga o'tishda biz shunchaki mavjud massivni o'tkazamiz, chunki hajmini ko'rsatishning hojati yo'q; Biz yangisini yaratmayapmiz. Chunki biz funktsiyaga massivni o'tkazamiz, funksiya ichida biz mumkin o'zgartirish, qiymat bo'yicha uzatiladigan oddiy o'zgaruvchilardan farqli o'laroq va bu qiymatni funktsiya ichida o'zgartirish asl o'zgaruvchiga hech qanday ta'sir qilmaydi.

Funktsiya ichidagi massivning o'lchamini bilmaganimiz uchun biz ikkinchi argument sifatida o'lchamni o'tkazishimiz kerak:

Int sumArray(int qiymatlari, int hajmi) ( int sum = 0; for (int i = 0; i)< size; i++) { sum += values[ i ]; } return sum; }

Ko'p o'lchovli massivlarni o'tkazganimizda, birinchisidan tashqari barcha o'lchamlarni ko'rsatishimiz kerak:

Int check_tic_tac_toe(int board);

Siz, albatta, birinchi o'lchamni belgilashingiz mumkin, ammo u e'tiborga olinmaydi.

Ushbu mavzu ko'rsatgichlar haqidagi maqolada batafsilroq muhokama qilinadi.

Hozircha massiv elementlari yig‘indisini hisoblaydigan funksiya yozamiz:

#o'z ichiga oladi std nom maydonidan foydalanish; int sumArray(int qiymatlari, int size) ( int sum = 0; // i == o'lchamda sikl to'xtaydi, chunki oxirgi element indeksi = o'lcham - 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 "<< men <<": "; cin >> qiymatlar[i]; ) cout<< sumArray(values, 10) << endl; }

Massivni tartiblash

Keling, foydalanuvchi tomonidan kiritilgan 100 ta raqamdan iborat massivni saralash masalasini hal qilaylik:

#o'z ichiga oladi std nom maydonidan foydalanish; int main() ( int qiymatlari [ 100 ]; uchun (int i = 0; i)< 100; i++) { cout << "Enter value "<< men <<": "; cin >> qiymatlar [ i ]; ))

Bajarildi, bu massivni saralashgina qoldi :) Odamlar odatda massivlarni qanday saralaydi? Ular undagi eng kichik elementni qidiradi va uni ro'yxatning yuqori qismiga qo'yadi. Keyin ular keyingi minimal qiymatni qidiradilar va uni birinchisidan keyin qo'yadilar va hokazo.

Bularning barchasi tsiklga o'xshaydi: biz birinchi elementdan boshlab massiv bo'ylab yuguramiz va qolgan qismdan minimal qiymatni qidiramiz va bu elementlarni almashtiramiz. Ushbu operatsiyalarni bajarish uchun kodni yozishdan boshlaylik:

Void sort(int array, int size) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

Endi siz ikkita yordamchi usulni, findSmallestRemainingElement va almashtirishni amalga oshirish haqida o'ylashingiz mumkin. findSmallestRemainingElement usuli massivda takrorlanishi va i indeksidan boshlab eng kichik elementni topishi kerak:

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

Nihoyat, biz almashtirish funktsiyasini amalga oshirishimiz kerak. Funktsiya asl massivni o'zgartirganligi sababli, biz vaqtinchalik o'zgaruvchidan foydalanib, qiymatlarni almashtirishimiz kerak:

Void almashish (int massivi, int birinchi_indeks, int ikkinchi_indeks) ( int temp = massiv[ birinchi_indeks ]; massiv[ birinchi_index ] = massiv[ ikkinchi_indeks ]; massiv[ ikkinchi_indeks ] = temp; )

Algoritmni sinab ko'rish uchun massivni tasodifiy raqamlar bilan to'ldiring va uni tartiblang. Barcha dastur kodi:

#o'z ichiga oladi #o'z ichiga oladi #o'z ichiga oladi std nom maydonidan foydalanish; int findSmallestRemainingElement(int massivi, int hajmi, int indeksi); bekor almashtirish (int massivi, int birinchi_indeks, int ikkinchi_indeks); void sort(int array, int size) ( for (int i = 0; i).< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } } int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = i; } } return index_of_smallest_value; } void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; } // вспомогательная функция для вывода массива void displayArray(int array, int size) { cout << "{"; for (int i = 0; i < size; i++) { // если элемент не первый выведем запятую if (i != 0) { cout << ", "; } cout << array[ i ]; } cout << "}"; } int main() { int array[ 10 ]; srand(time(NULL)); for (int i = 0; i < 10; i++) { array[ i ] = rand() % 100; } cout << "Original array: "; displayArray(array, 10); cout << "\n"; sort(array, 10); cout << "Sorted array: "; displayArray(array, 10); cout << "\n"; }

Biz ko'rib chiqqan saralash algoritmi deyiladi kiritish tartibi , bu eng tezkor algoritm emas, lekin uni tushunish va amalga oshirish oson. Agar siz katta hajmdagi ma'lumotlarni saralashingiz kerak bo'lsa, yanada murakkab va tezroq algoritmlardan foydalangan ma'qul.

Massiv - bu bitta nom ostida birlashtirilgan bir xil turdagi hujayralar guruhi sifatida taqdim etilgan ma'lumotlar strukturasi. Massivlar bir xil turdagi katta hajmdagi ma'lumotlarni qayta ishlash uchun ishlatiladi. Massivning nomi - bu ko'rsatkichlar, men sizga keyinroq aytib beraman. Massivning alohida ma’lumotlar katakchasi massiv elementi deyiladi. Massivning elementlari har qanday turdagi ma'lumotlar bo'lishi mumkin. Massivlar bir yoki bir nechta o'lchamlarga ega bo'lishi mumkin. Oʻlchovlar soniga qarab massivlar bir oʻlchovli massivlarga, ikki oʻlchovli massivlarga, uch oʻlchovli massivlarga va hokazolarga n oʻlchovli massivgacha boʻlinadi. Bir o'lchovli va ikki o'lchovli massivlar ko'pincha dasturlashda qo'llaniladi, shuning uchun biz faqat shu massivlarni ko'rib chiqamiz.

C++ tilida bir o'lchovli massivlar

Bir o'lchovli massiv - bir o'lchovli massivning elementlari sonini tavsiflovchi bitta parametrga ega massiv. Aslida, bir o'lchovli massiv faqat bitta satr va n ta ustunga ega bo'lishi mumkin bo'lgan massivdir. Bir o'lchovli massivdagi ustunlar massivning elementlari hisoblanadi. 1-rasmda butun sonli bir o'lchovli massivning tuzilishi ko'rsatilgan a. Ushbu massivning o'lchami 16 hujayradan iborat.

1-rasm - C++ tilidagi massivlar

E'tibor bering, bir o'lchovli massivning maksimal indeksi a 15, lekin massivning oʻlchami 16 yacheyka, chunki massiv yacheykalarini raqamlash har doim 0 dan boshlanadi. Hujayra indeksi manfiy boʻlmagan butun son boʻlib, uning yordamida massivning har bir yacheykasiga kirish va unda istalgan amallarni bajarish mumkin ( hujayra).

//C++ da bir o'lchovli massivni e'lon qilish sintaksisi: /*ma'lumotlar turi*/ /*bir o'lchovli massiv nomi*/; //1-rasmda ko'rsatilgan bir o'lchovli massivni e'lon qilish misoli: int a;

bu yerda int butun son;

A - bir o'lchovli massivning nomi;
16 - bir o'lchovli massivning o'lchami, 16 hujayra.

Har doim massiv nomidan keyin bir o'lchovli massivning o'lchami ko'rsatilgan kvadrat qavslar mavjud; bu massivni boshqa barcha o'zgaruvchilardan ajratib turadi;

//bir o'lchovli massivlarni e'lon qilishning yana bir usuli int mas, a;

Ikkita bir o'lchovli mas va a massivlari mos ravishda 10 va 16 o'lchamlari bilan e'lon qilinadi. Bundan tashqari, ushbu deklaratsiya usulida barcha massivlar bir xil ma'lumotlar turiga ega bo'ladi, bizning holatlarimizda - int.

// massivlar e'lon qilinganda ishga tushirilishi mumkin: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // bir o'lchovli massivni ishga tushirish

Bir o'lchovli massivni ishga tushirish belgidan keyin jingalak qavslarda amalga oshiriladi teng, massivning har bir elementi oldingisidan vergul bilan ajratiladi.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // massivni hajmini aniqlamasdan ishga tushirish.

Bunday holda, kompilyatorning o'zi bir o'lchovli massivning hajmini aniqlaydi. Massivning o'lchamini faqat uni initsializatsiya qilishda olib tashlash mumkin, massivni normal e'lon qilishda massivning o'lchami ko'rsatilishi kerak; Bir o'lchovli massivni qayta ishlash uchun oddiy dastur ishlab chiqamiz.

// array.cpp: Konsol ilovasi uchun kirish nuqtasini belgilaydi. #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; }

// kod Kod:: Bloklar

// Dev-C++ kodi

// array.cpp: Konsol ilovasi uchun kirish nuqtasini belgilaydi. #o'z ichiga oladi std nom maydonidan foydalanish; 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 qatorlar array1 nomli butun sonli bir oʻlchovli massiv eʼlon qilindi va ishga tushirildi, uning oʻlchami 16 yacheyka, yaʼni bunday massiv 16 ta raqamni saqlashi mumkin. Har qanday massivni qayta ishlash faqat tsikllar bilan birgalikda mumkin. Massivni qayta ishlash uchun qaysi tsiklni tanlashni o'zingiz hal qilasiz. Ammo bu vazifa uchun eng mos keladi. Bir o'lchovli massiv1 ning elementlariga kirish uchun hisoblagich o'zgaruvchisidan foydalanamiz. For tsiklining davom etish sharti qat'iy tengsizlik belgisini o'z ichiga oladi, chunki bir o'lchovli massiv1da o'n oltinchi indeks mavjud emas. Va hujayralarni raqamlash noldan boshlanganligi sababli, massivda 16 ta element mavjud bo'lib, for siklining tanasida cout operatori bir o'lchovli massivning elementlarini chop etadi (2-rasmga qarang).

Obrabotka massiva indekslari element massiva massivi1 5 massiv1 -12 massiv1 -12 massiv1 9 massiv1 10 massiv1 0 massiv1 -9 massiv1 -12 massiv1 -1 massiv1 23 massiv1 65 massiv1 614 massiv1 4 massiv1 davom eting, istalgan tugmani bosing. . .

2-rasm - C++ tilidagi massivlar

C++ tilida bir o'lchovli massivni qayta ishlash uchun yana bir dastur ishlab chiqamiz. Dastur klaviaturadan kiritilgan o'nta raqamni ketma-ket o'qishi kerak. Barcha kiritilgan raqamlar jamlanadi va natija ekranda ko'rsatiladi.

// array_sum.cpp: Konsol ilovasi uchun kirish nuqtasini belgilaydi. #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; }

// kod Kod:: Bloklar

// Dev-C++ kodi

// array_sum.cpp: Konsol ilovasi uchun kirish nuqtasini belgilaydi. #o'z ichiga oladi std nom maydonidan foydalanish; int main(int argc, char* argv) ( int array1; // butun son massivini e'lon qilish cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> massiv1; // klaviaturadan kiritilgan raqamlarni o'qish<< "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; }

Massivni qayta ishlashdan oldin uni e'lon qilish kerak va bir o'lchovli massivning o'lchami 10 ga teng, chunki bu vazifaning sharti bilan belgilanadi. Sum o'zgaruvchisida biz bir o'lchovli massivning elementlari yig'indisini to'playmiz. Birinchi for tsikli e'lon qilingan bir o'lchovli massivni klaviaturadan kiritilgan raqamlar bilan to'ldiradi, 12 - 13 qatorlar. Hisoblagich o'zgaruvchisi bir o'lchovli massiv1 ning elementlariga ketma-ket kirish uchun ishlatiladi, indeks 0 dan 9 gacha va shu jumladan. Ikkinchi for tsikli massivning elementlarini ko'rsatadi, 15-16 qatorlar. Uchinchi for tsikli bir o'lchovli massivning elementlarini ketma-ket o'qiydi va ularni jamlaydi, summa sum o'zgaruvchisida to'planadi. 17 - 18 qatorlar. Dasturning natijasi 3-rasmda ko'rsatilgan.

Elementi massiva kiriting: 0 1 2 3 4 5 6 7 8 9 massiv1 = (0 1 2 3 4 5 6 7 8 9 ) summa = 45 Davom etish uchun istalgan tugmani bosing. . .

3-rasm - C++ tilidagi massivlar

Birinchidan, barcha 10 ta raqam ketma-ket kiritildi, shundan so'ng bir o'lchovli massiv ko'rsatildi va massivdagi raqamlar yig'indisi chop etildi.

C++ da ikki o'lchovli massivlar

Shu paytgacha biz bir o'lchovli massivlarni ko'rib chiqdik, ular bilan har doim ham cheklanib bo'lmaydi. Aytaylik, siz jadvaldagi ba'zi ma'lumotlarni qayta ishlashingiz kerak. Jadval ikkita xususiyatga ega: qatorlar soni va ustunlar soni. Shuningdek, ikki o'lchovli massivda massiv elementlari soniga qo'shimcha ravishda ikki o'lchovli massivning qatorlar soni va ustunlar soni kabi xarakteristikalar mavjud. Ya'ni, vizual ravishda ikki o'lchovli massiv oddiy jadval bo'lib, qatorlar va ustunlar mavjud. Aslida, ikki o'lchovli massiv bir o'lchovli massivlarning bir o'lchovli massividir. m dan n gacha kattalikdagi a deb nomlangan ikki o‘lchovli massivning tuzilishi quyida ko‘rsatilgan (4-rasmga qarang).

4-rasm - C++ tilidagi massivlar

bu yerda, m – ikki o‘lchovli massivning qatorlar soni;
n - ikki o'lchovli massivning ustunlar soni;
m * n — massiv elementlari soni.

// ikki o'lchovli massivni e'lon qilish sintaksisi /*ma'lumotlar turi*/ /*massiv nomi*/;

Ikki o'lchovli massivni e'lon qilishda, shuningdek, bir o'lchovli massivni e'lon qilishda, birinchi navbatda, quyidagilarni ko'rsatishingiz kerak:

• ma'lumotlar turi;
• massiv nomi.

Shundan so'ng, birinchi kvadrat qavslar ikki o'lchovli massivning qatorlar sonini, ikkinchi kvadrat qavslar esa ikki o'lchovli massivning ustunlar sonini ko'rsatadi. Ikki o'lchovli massiv bir o'lchovli massivdan ikkinchi kvadrat qavs yordamida vizual tarzda ajralib turadi. Ikki o'lchovli massivni e'lon qilish misolini ko'rib chiqamiz. Aytaylik, elementlar soni 15 ga teng bo'lgan ikki o'lchovli massivni e'lon qilishimiz kerak. Bunday holda, ikki o'lchovli massiv uchta qator va beshta ustun yoki besh qator va uchta ustunga ega bo'lishi mumkin.

// ikki o'lchovli massivni e'lon qilish misoli: int a;

• a - butun sonli massivning nomi
• birinchi kvadrat qavsdagi raqam ikki o'lchovli massivning qatorlar sonini ko'rsatadi, bu holda 5 ta;
• ikkinchi kvadrat qavsdagi raqam ikki o'lchovli massivning ustunlari sonini ko'rsatadi, bu holda 3 ta bo'ladi.

// ikki o'lchovli massivni ishga tushirish: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Bu massivda 5 ta satr, 3 ta ustun mavjud. tayinlash belgisidan keyin umumiy jingalak qavslar joylashtiriladi, ularning ichiga ikki o'lchovli massivda qancha chiziqlar bo'lishi kerak bo'lsa, shuncha juft jingalak qavslar joylashtiriladi va bu qavslar vergul bilan ajratiladi. Har bir jingalak qavsga ikki o'lchovli massivning elementlarini vergul bilan ajrating. Barcha jingalak qavslarda elementlar soni bir xil bo'lishi kerak. Massivda beshta qator borligi sababli, beshta ichki qavs juftlari ham mavjud. Ichki qavslarda uchta element yoziladi, chunki ustunlar soni uchtadir. Grafik jihatdan bizning massivimiz ikki o'lchovli jadvalga o'xshaydi (5-rasmga qarang).

5-rasm - C++ tilidagi massivlar

Ikki o'lchovli massivning har bir katagida a qiymat ko'rsatiladi, bu katakning manzili pastki o'ng burchakda ko'rsatiladi. Ikki o'lchovli massivning katak manzili massiv nomi, satr va ustun raqamidir.

Keling, ikki o'lchovli massivni qayta ishlash uchun "Labirint" deb nomlangan oddiy dastur ishlab chiqaylik. Labirint ikki o'lchovli massiv asosida qurilishi kerak. Biz labirintning o'lchamini o'z xohishimiz bilan tanlaymiz.

// array2.cpp: Konsol ilovasi uchun kirish nuqtasini belgilaydi. #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); ) aks holda kutaman<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kod Kod:: Bloklar

// Dev-C++ kodi

// array2.cpp: Konsol ilovasi uchun kirish nuqtasini belgilaydi. #o'z ichiga oladi std nom maydonidan foydalanish; int main(int argc, char* argv) ( // 1-shartli ravishda “labirint devorlari” // 2-“toʻgʻri yoʻl, labirintdan chiqish” // 0-“notoʻgʻri yoʻl” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // ikki oʻlchovli massivni ishga tushirish ( 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,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,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,) ); // ikkita tsikl - ichki va tashqi, massivning har bir elementiga kirish uchun (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); ) aks holda kutaman<< " "; // вывести два пробела cout << endl; } return 0; }

To'g'ri va noto'g'ri yo'llar bir xil raqam bilan belgilanishi mumkin, masalan, nol, lekin aniqlik uchun, to'g'ri yo'l 2 raqami bilan belgilanadi. Massiv faqat dasturni soddalashtirish uchun qo'lda ishga tushirildi. Dastur ikki o'lchovli massivni qayta ishlaganligi sababli, ikki o'lchovli massivning elementlari o'rtasida almashish uchun ikkita tsikl kerak bo'ladi. Birinchi for tsikli ikki o'lchovli massivning qatorlari o'rtasida almashinadi. Ikki o'lchovli massivda 33 ta qator bo'lganligi sababli, hisoblagich o'zgaruvchisi i 0 dan 33 gacha oshiriladi, 46-qator. Birinchi sikl ichida ikki o‘lchovli massivning qator elementlari bo‘ylab aylanib turuvchi for tsikli joylashgan. Ikkinchi for tsiklining tanasida ma'lumotlar turini bir xil konvertatsiya qilish operatsiyasi - static_cast ichida amalga oshiriladi.<>() , 176-raqamli belgini chop etadi. Ma'lumotlar turini o'zgartirish operatsiyasi labirintning kengligini oshirish uchun takrorlanadi. Dasturning natijasi (6-rasmga qarang).

6-rasm - C++ tilidagi massivlar

Oxirgi yangilanish: 17.09.2017

Massiv bir xil turdagi ma'lumotlar to'plamini ifodalaydi. Massivning rasmiy ta'rifi quyidagicha:

O'zgaruvchan_turi massiv_nomi [massiv_uzunligi]

O'zgaruvchining turidan keyin massiv nomi, keyin esa kvadrat qavs ichida uning o'lchami keladi. Masalan, 4 ta raqamdan iborat massivni aniqlaymiz:

Int raqamlari;

Ushbu massivda to'rtta raqam mavjud, ammo bu raqamlarning barchasi aniqlanmagan qiymatga ega. Biroq, biz ishga tushirishni amalga oshirishimiz va jingalak qavslar orqali ushbu raqamlarga ba'zi boshlang'ich qiymatlarni belgilashimiz mumkin:

Int raqamlari = (1,2,3,4);

Jingalak qavslardagi qiymatlar boshlang'ich deb ham ataladi. Agar massivdagi elementlarga qaraganda initsializatorlar kamroq bo'lsa, unda birinchi elementlar uchun initsializatorlar qo'llaniladi. Agar massivdagi elementlardan ko'proq initsializatorlar bo'lsa, kompilyatsiya paytida xatolik yuzaga keladi:

Int raqamlari = (1, 2, 3, 4, 5, 6);

Bu erda massiv 4 o'lchamga ega, ammo unga 6 ta qiymat beriladi.

Agar massiv o'lchami aniq ko'rsatilmagan bo'lsa, u initsializatorlar sonidan kelib chiqadi:

Int raqamlari = (1, 2, 3, 4, 5, 6);

Bu holda massiv 6 ta elementga ega.

Belgilar massivlarini ishga tushirish o'ziga xos xususiyatlarga ega. Biz belgilar massiviga initsializator to'plamini ham, satrni ham o'tkazishimiz mumkin:

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

Bundan tashqari, ikkinchi holatda, s2 massivida 5 ta element emas, balki 6 ta element bo'ladi, chunki satr bilan ishga tushirilganda, "\0" null belgisi avtomatik ravishda belgilar qatoriga qo'shiladi.

Bunday holda, bitta massivni boshqa massivga belgilashga ruxsat berilmaydi:

Int raqamlari1 = (1,2,3,4,5); int nums2 = nums1; // xato raqamlar2 = nums1; // xato

Massiv aniqlangandan so'ng, biz uning alohida elementlariga indeks bo'yicha kirishimiz mumkin. Indekslar noldan boshlanadi, shuning uchun birinchi elementga kirish uchun biz 0 indeksidan foydalanishimiz kerak. Indeks bo'yicha elementga kirish orqali biz uning qiymatini olishimiz yoki uni o'zgartirishimiz mumkin:

#o'z ichiga oladi int main() ( int raqamlar = (1,2,3,4); int birinchi_raqam = raqamlar; std :: cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Massiv elementlarining sonini konstanta orqali ham aniqlash mumkin:

Const int n = 4; int raqamlari[n] = (1,2,3,4);

Massivlar ustida takrorlash

Looplardan foydalanib, siz butun massivni takrorlashingiz va uning elementlariga indekslar orqali kirishingiz mumkin:

#o'z ichiga oladi int main() ( int raqamlari = (1,2,3,4); int hajmi = sizeof(raqamlar)/sizeof(raqamlar); for(int i=0; i)< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Massivda aylanish uchun avvalo massiv uzunligini topishingiz kerak. Uzunlikni topish uchun sizeof operatori ishlatiladi. Asosan, massiv uzunligi uning elementlarining umumiy uzunligiga teng. Barcha elementlar bir xil tipni ifodalaydi va xotirada bir xil hajmni egallaydi. Shuning uchun sizeof(raqamlar) ifodasidan foydalanib biz butun massivning baytdagi uzunligini, sizeof(raqamlar) ifodasidan foydalanib, baytdagi bir elementning uzunligini topamiz. Ikki qiymatni bo'lish orqali siz massivdagi elementlar sonini olishingiz mumkin. Va keyin, for tsiklidan foydalanib, i hisoblagichi massiv uzunligiga teng bo'lguncha barcha elementlarni takrorlaymiz. Natijada, massivning barcha elementlari konsolga chiqariladi:

Ammo for tsiklining yana bir shakli mavjud bo'lib, u maxsus to'plamlar, jumladan massivlar bilan ishlash uchun mo'ljallangan. Ushbu shakl quyidagi rasmiy ta'rifga ega:

For (o'zgaruvchi turi: to'plam) ( ko'rsatmalar; )

Massivni takrorlash uchun biz ushbu shakldan foydalanamiz:

#o'z ichiga oladi int main() ( int raqamlari = (1,2,3,4); for(int raqami: raqamlar) std::cout<< number << std::endl; return 0; }

Massiv orqali takrorlanganda, takrorlangan har bir element raqam o'zgaruvchisiga joylashtiriladi, uning qiymati tsiklda konsolga chop etiladi.

Agar biz massivdagi ob'ektlarning turini bilmasak, turini aniqlash uchun avtomatik spetsifikatsiyadan foydalanishimiz mumkin:

For(avtomatik raqam: raqamlar) std::cout<< number << std::endl;

Ko'p o'lchovli massivlar

Bir o'lchovli massivlardan tashqari, C++ da ko'p o'lchovli massivlar mavjud. Bunday massivlarning elementlari o'z navbatida massivlar bo'lib, ulardagi elementlar massiv ham bo'lishi mumkin. Masalan, ikki o'lchovli raqamlar qatorini aniqlaymiz:

Int raqamlari;

Bunday massiv uchta elementdan iborat bo'lib, har bir element ikkita elementdan iborat massivni ifodalaydi. Quyidagi kabi massivni ishga tushiramiz:

Int raqamlari = ( (1, 2), (4, 5), (7, 8) );

O'rnatilgan jingalak qavslar har bir pastki qator uchun elementlarni belgilaydi. Bunday massivni jadval sifatida ham ko'rsatish mumkin:

1	2
4	5
7	8

Siz ishga tushirish vaqtida jingalak qavslarni ham o'tkazib yuborishingiz mumkin:

Int raqamlari = ( 1, 2, 4, 5, 7, 8 );

Bundan tashqari, barcha elementlarni emas, balki faqat ba'zilarini ishga tushirish mumkin:

Int raqamlari = ( (1, 2), (), (7) );

Va ichki o'rnatilgan massivning elementlariga kirish uchun sizga ikkita indeks kerak bo'ladi:

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

Keling, ikki o'lchovli massivni takrorlaymiz:

#o'z ichiga oladi int main() ( const int satr = 3, ustunlar = 2; int raqamlari = ( (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; }

Ko'p o'lchovli massiv elementlarini takrorlash uchun for tsiklining boshqa shaklidan ham foydalanishingiz mumkin:

#o'z ichiga oladi int main() ( const int satr = 3, ustunlar = 2; int raqamlari = ( (1, 2), (3, 4), (5, 6) ); for(avtomatik va pastki raqamlar: raqamlar) ( for(int raqam) : pastki raqamlar) ( std :: cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Massivga kiritilgan massivlarni takrorlash uchun havolalardan foydalaniladi. Ya'ni, tashqi siklda for(avto &subraqamlar:raqamlar) &pastki raqamlar massivdagi pastki massiv havolasini ifodalaydi. Ichki tsiklda for(int number: subnumbers) pastki raqamlardagi har bir kichik massivdan biz uning alohida elementlarini raqam o'zgaruvchisiga olamiz va uning qiymatini konsolga chiqaramiz.

Massivlar bir xil turdagi bir nechta qiymatlarni saqlash uchun mo'ljallangan. Misol uchun, Farengeytdan Selsiyga o'tish dasturida biz uchtadan o'rtacha harorat qiymatini hisoblab chiqdik. Agar uchta qiymat bo'lmasa, lekin undan ko'p bo'lsa, bu erda siz massivlardan foydalanishingiz kerak.

Massivdan foydalanishdan oldin uni aniqlash kerak. Massiv ta'rifi quyidagilarni o'z ichiga oladi: massivda saqlanadigan ma'lumotlar turi, massiv nomi va kvadrat qavs ichidagi massiv elementlari soni:

int massivi;

Ushbu kodda biz int tipidagi o'nta elementdan iborat identifikator (nom) massiviga ega massivni aniqladik.
Ushbu shaklda massivning barcha elementlari hali ham boshlang'ich emas. E'lon qilinganda ularni ishga tushirish uchun siz quyidagi sintaksisdan foydalanishingiz kerak:

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

Bunda massivning birinchi elementiga 0 qiymati, oxirgisiga esa 9 qiymati beriladi.
Massiv elementlariga qiymatlarni belgilash uchun tsikllardan foydalanishingiz mumkin. Buning uchun eng mos bo'lgan for loop bo'ladi.

C++ kodi int massivi; // uchun massiv ta'rifi (int i = 0; i< 10; i++) { array[i] = i; }

Bu erda biz massivning har bir elementiga indeks - kvadrat qavs ichidagi raqam orqali kiramiz. Loopning har bir iteratsiyasi bilan u noldan 9 gacha qiymatlarni oladi.

E'tibor bering, indekslarni raqamlash noldan boshlanadi. Shuning uchun indekslar soni har doim massiv elementlari sonidan bitta kam bo'ladi.

Kvadrat qavslar va pastki belgilar bundan mustasno, massiv elementi har qanday o'zgaruvchi kabi ishlatiladi.

Satrlar

Hozirgacha biz satrlarni faqat konstantalarda saqlashimiz mumkin edi: “Doimiy satrga misol”. Biz faqat bitta belgini o'zgaruvchilarda - char turida saqlashimiz mumkin edi. C++ ikki turdagi satrlardan foydalanadi: char tipidagi elementlar massivi va str tipidagi. Hozircha biz birinchi variantga e'tibor qaratamiz.

Satrni saqlash uchun bizga massiv kerak. Bu shunday ko'rinadi:

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

Yaxshiyamki, osonroq yo'l bor :)

char string = "string";

Bunday holda, ettita elementdan iborat massiv avtomatik ravishda yaratiladi. Nega ettitadan? Gap shundaki, har bir satr bo'sh baytni ifodalovchi "\0" belgi konstantasi bilan tugashi kerak.

Oldingi misollarda, agar biz satr massiviga olti belgidan kattaroq satr kiritishga harakat qilsak, massiv to'lib ketadi, chunki Dastur ishlayotgan vaqtda massiv hajmini o'zgartira olmaysiz (har doim bo'lmasa ham):

char qatori; // satr oltita belgi va "\0" ni saqlashi mumkin

string = "string!"; // qator ettita belgidan iborat
Buni qilish tavsiya etilmaydi :)

Yana bir jihatga e’tiboringizni qaratmoqchiman. Foydalanuvchi qatorga kirganda, bo'shliqlar "\0" deb hisoblanadi. Biz hozircha dasturlarimizga satrlarni kiritmaymiz, shuning uchun men bu ishni batafsil tushuntirmayman.

Massivlar massivlari (ikki o'lchovli massivlar)

Va nihoyat, biz ushbu masalada eng muhim narsaga keldik.

Strategiya (va nafaqat) o'yinlaridagi xarita (RTS) hujayralarga bo'lingan (ingliz tilida - kafel). Bu hujayralarni ikki o'lchovli massiv yordamida tasvirlash qulay.

Ushbu misolda biz pseudo_game dasturi bilan ishlashni davom ettiramiz va ikki o'lchovli massivdan foydalanib, o'yinchi harakatlanishi mumkin bo'lgan xaritani simulyatsiya qilamiz. Shu paytgacha "harakat" x, y koordinatalari yordamida ifodalangan.

Biz hujayralarni belgilar bilan ifodalaymiz. "Karta" ning o'lchami 15x20. O'n besh balandlikda, yigirma kenglikda. Biz o'yinchini T belgisi bilan ifodalaymiz.

Avval sarlavha faylini qo'shing stdlib.h.

Pseudo_o'yin yaxshilandi

Men faqat kod qismlarini beraman. To'liq dastur sizning ko'zingiz oldida bo'lishi tavsiya etiladi. Siz uni "dastur ro'yxatlari" bo'limida topishingiz mumkin - pseudo_game_0_2. U kompilyatsiya qiladi va ishlaydi. Uni IDE muharririga nusxalash va matnga amal qilish kifoya.

Ma'lumotlarni ishga tushirish:

C++ kodi belgi akti; // foydalanuvchi kiritishini o'qish uchun o'zgaruvchi int ch; // o'zgaruvchining kamaytirilgan qiymatini saqlash uchun o'zgaruvchi akt int x = 0; // o'yinchining koordinatalarini saqlash uchun ikkita o'zgaruvchi int y = 0; char xaritasi; // o'yin kartasini saqlash uchun massiv // (int i = 0; i) uchun massivni ishga tushirish< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Bu erda biz uchun yangi operator ikki o'lchovli massivning ta'rifidir. Lekin u bir o'lchovlidan deyarli farq qilmaydi, shunchaki yana bir juft kvadrat qavs qo'shing. Birinchi qavslarda biz satrlar sonini, ikkinchisida - ustunlar sonini ko'rsatdik.

Shundan so'ng, ikkita tsiklda biz massivning har bir elementini "" qiymati bilan ishga tushiramiz - bu shunchaki bo'sh joy belgisidir. Birinchidan, tashqi pastadirda biz barcha qatorlardan o'tamiz. Ichki pastadirdagi har bir satr uchun biz ustunlarni "kesib o'tamiz".

Batafsil misol keltiraman: tashqi siklda bir necha marta takrorlangandan so'ng, hisoblagich i 9 ga teng bo'ladi. Tashqi siklning tanasi bajarila boshlaydi: j o'zgaruvchisi (ichki sikl hisoblagichi) nolga ishga tushiriladi, shart tekshiriladi va ichki halqaning tanasi bajariladi: map = " ";, Ya'ni o'ninchi qatorning birinchi belgisiga (indeks nol) bo'sh joy qo'yiladi (qayta sanash noldan ekanligini unutmang). Keyin j hisoblagichga 1 beriladi, sikl tanasi bajariladi... va shunga o'xshash j hisoblagich 20 ga teng bo'lguncha - shart bajarilmaydi va ichki sikl chiqariladi. Keyin tashqi hisoblagich oshiriladi. Endi u 10 ga teng va tashqi tsiklning tanasi yana bajariladi ...

Bo'shliqlar bilan ishga tushirilgandan so'ng, biz o'yinimizning xarakterini birinchi qatorning birinchi ustuniga joylashtiramiz.

Asosiy tsiklning boshida biz oldingi chiqish ekranini tozalash uchun system() funksiyasini chaqiramiz.

Keyin ishga tushirish davrlariga o'xshash ikkita tsikl mavjud. Ular massiv elementlarini ekranda aks ettirish uchun ishlatiladi. Yagona muhim farq - bu birinchi tsiklning tanasi oxiridagi yangi satr belgisining chiqishi.

Xo'sh, unda qaysi tugma bosilganligi aniqlanadigan dallanish mavjud. Tarmoqlanishning o'zi o'tgan vaqtdan beri ozgina o'zgargan, ammo bloklarning mazmunida farqlar mavjud: birinchi navbatda, ob'ekt joylashgan koordinatalarga bo'sh joy ajratamiz. Ya'ni, biz oldingi joyni tozalaymiz. Keyin koordinatalardan birini o'zgartiramiz. Va keyin, yangi indeksli massiv elementiga biz "T" belgisini beramiz.

"75" kodiga misol - chapga harakat:

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

Xo'sh, hammasi shu. Ayni paytda bizda 15x20 o'lchamdagi xarita mavjud, unda siz belgini ko'chirish uchun o'qlardan foydalanishingiz mumkin - "T" harfi. Oltinchi dars uchun yomon emas! Ushbu ilova barcha konsol dasturlarimiz uchun asos bo'ladi. Grafik yaxshilanishlar bo'lmaydi. Siz shunchaki DOS konsolidan ko'proq foydalana olmaysiz va biz Windows konsolini ko'rib chiqmaymiz. Bu vaqt va kuchni sezilarli darajada tejaydi.

Men pseudo_game dasturini batafsil izohladim va siz uni qiyinchiliksiz tushunasiz. Agar yo'q bo'lsa, dastur ro'yxatini qayta o'qing va siz tushunmaguningizcha bu muammoni tushunolmaysiz :). Mashqlar materialni mustahkamlashga yordam beradi. Mashqlarni bajarish majburiydir. Agar biror narsa tushunarsiz bo'lsa, mening elektron pochtamga yozing - men yordam berishga harakat qilaman.

Mashqlar:

1. Dasturning to'liq ro'yxatida men kommutatorning tarmoqlanishidan foydalandim. Bu yerda bitta if filiali blokining kodi ham ko'rsatilgan. Qolgan if bloklarini qo'shing.

2. Endi dastur massivning mavjud bo'lmagan elementlariga yozishi mumkin. Xarita chegaralarini tark etishni tekshiring.

3. Amaliyot uchun ekranda dengiz jangi uchun ikkita maydonni chizadigan dastur tuzing. Birinchisi o'yinchi uchun, ikkinchisi dushman uchun. Ikkinchi maydon birinchisining o'ng tomonida joylashgan bo'lishi kerak.
Ichki katakchalarni bo'sh joylar bilan to'ldiring. Chegarani chizish uchun minus va to'g'ri bo'linuvchi chiziqdan foydalaning: -, |, burchaklar uchun esa # xeshidan foydalaning. Har bir maydonning chap tomonida raqamlar to'plami joylashgan; tepasida harflar bor.
Butun maydonni ishga tushirish uchun sizga bir nechta tsikl kerak bo'lishi mumkin. Ikkinchi maydondagi raqamlar ustunini to'ldirish uchun kod quyidagicha ko'rinishi mumkin:

C++ kodi int string; // satrlarni ifodalovchi o'zgaruvchi int ustun; // ustunlarni ifodalovchi o'zgaruvchi char xaritasi; ustun = 15; uchun (string = 2; string< 12; string++) { map = string - 1; }

Aytaylik, biz bir xil turdagi ma'lumotlarning katta miqdori bilan ishlashimiz kerak. Misol uchun, bizda ma'lum vaqt qadamlari bilan mayatnik koordinatalarining minglab o'lchovlari mavjud. Barcha qiymatlarni saqlash uchun 1000 ta o'zgaruvchi yaratish juda... og'ir. Buning o'rniga, bir xil turdagi ma'lumotlarning ko'pchiligi bitta nom ostida birlashtirilishi mumkin va har bir alohida elementga uning seriya raqami orqali kirish mumkin.
C tilidagi massiv quyidagicha aniqlanadi
<тип> <имя массива>[<размер>];
Masalan,
int a;
Biz nomli massivni olamiz a, unda yuzta turdagi element mavjud int. O'zgaruvchilarda bo'lgani kabi, massiv ham axlatni o'z ichiga oladi.
Birinchi elementga kirish uchun uning raqamini (indeksini) kvadrat qavs ichiga yozing. Masalan

#o'z ichiga oladi #o'z ichiga oladi void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Birinchi element 0 indeks raqamiga ega. Buning sababini tushunish muhimdir. Quyida biz kompyuter xotirasini lenta sifatida tasvirlaymiz. Massiv nomi massiv elementlari joylashgan xotira manziliga ko‘rsatgich hisoblanadi.

Guruch. 1 Massiv birinchi elementning manzilini saqlaydi. i elementining indeksi i*sizeof(turi) baytlarining boshidan siljishidir.

Massiv indeksi kerakli elementga kirish uchun massiv boshidan qancha baytni siljitish kerakligini ko'rsatadi. Masalan, agar massiv A turiga ega int, keyin A biz boshiga nisbatan 10*sizeof(int) baytni ko'chirdik degan ma'noni anglatadi. Birinchi element eng boshida va 0*sizeof(int) ofsetiga ega.
C tilida massiv o'z hajmini saqlamaydi va massiv indeksining to'g'riligini tekshirmaydi. Bu siz massivdan tashqariga chiqishingiz va massivning oxirgi elementidan uzoqroqda joylashgan (yoki undan ham yaqinroq) xotiraga kirishingiz mumkinligini anglatadi.

Massivning dastlabki ishga tushirilishi.

Keling, oddiy dastur yozamiz. Massiv tuzamiz va keyin uning maksimal elementini topamiz.

#o'z ichiga oladi #o'z ichiga oladi void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); belgisiz i; int maks; max = a; uchun (i = 1; i)<10; i++) { if (a[i] >

Keling, bir misolni ko'rib chiqaylik. Biz birinchi navbatda massivni yaratamiz va yaratgandan so'ng uni ishga tushiramiz. Shundan so'ng biz topilgan maksimal elementga massivning birinchi elementining qiymatini beramiz.

Maks = a;

Keyin biz massivdan o'tamiz. Biz allaqachon birinchi elementni ko'rib chiqqanimiz uchun (uning indeksi 1), uni qayta ko'rib chiqishning ma'nosi yo'q.
Xuddi shu misol, faqat hozir foydalanuvchi qiymatlarni kiritadi

#o'z ichiga oladi #o'z ichiga oladi void main() ( int a; unsigned i; int max; printf("10 ta raqam kiriting\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("maksimal element %d", maks); getch(); )

Agar ishga tushirish vaqtida massiv o'lchamidan kamroq qiymatlar belgilansa, qolgan elementlar nol bilan to'ldiriladi.

#o'z ichiga oladi #o'z ichiga oladi void main() ( int a = (1,2,3); unsigned i; for (i = 0; i)<10; i++) { printf("%d ", a[i]); } getch(); }

Agar butun massivni nol bilan to'ldirish kerak bo'lsa, biz yozamiz

Int a = (0);

Masalan, massiv hajmini aniq belgilashingiz shart emas

Int a = (1, 2, 3);

massiv 3 o'lchamga ega bo'ladi

Massiv hajmi

C dagi massiv doimiy o'lchamga ega bo'lishi kerak. Bu shuni anglatadiki, masalan, foydalanuvchidan o'lchamni so'rash va keyin bu o'lchamni massivga o'rnatish mumkin emas.

Printf("Masiv uzunligini kiriting"); scanf("%d", &uzunlik); (float x;)

Dinamik massivlarni yaratish ko'rsatkichlar va xotira bilan ishlashda ko'proq muhokama qilinadi
Ba'zi hollarda siz massiv hajmini funktsiyadan foydalanib bilib olishingiz mumkin sizeof.

#o'z ichiga oladi #o'z ichiga oladi void main() ( int A; //sizeof butun massivning o‘lchamini baytlarda qaytaradi //Elementlar sonini aniqlash uchun //massiv o‘lchamini uning elementining o‘lchamiga bo‘ling int size = sizeof(A) / sizeof(int);

Ammo bu foydali bo'lishi dargumon. Massivni funktsiyaga argument sifatida o'tkazishda ko'rsatgich uzatiladi, shuning uchun massivning o'lchami ma'lum bo'lmaydi.
Statik massivlar elementlar soni oldindan ma'lum bo'lganda foydalidir. Ular elementlarga tez, ammo xavfsiz kirishni ta'minlaydi.

Massiv to‘lib toshgan

Umid qilamizki, sizda bu kod bor

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

Mana halqa uchun xato bilan belgilangan. Kompilyatorlarning ba'zi eski versiyalarida bu kod aylana bo'lardi. Gap shundaki, o'zgaruvchan i massivdan so'ng darhol kompilyatsiya paytida joylashgan edi A. Massiv chegaradan chiqib ketganda, hisoblagich 1 ga o'rnatildi.
Massivlar xavfsiz emas, chunki indeks bilan noto'g'ri ishlash xotiraning ixtiyoriy qismiga kirishga olib kelishi mumkin (Nazariy jihatdan. Zamonaviy kompilyatorlarning o'zlari siz birovning xotirasiga kirmasligingiz uchun g'amxo'rlik qiladi).
Agar siz massivlar bilan ishlasangiz, hisoblagich massivning o'lchamidan oshmasligi va salbiy bo'lmasligini ta'minlashingiz kerak. Buning uchun, hech bo'lmaganda,

• 1. Indekslash uchun size_t turidan foydalaning. Bu sizni salbiy qiymatlardan himoya qiladi va har doim har qanday o'lchamdagi massiv uchun etarli bo'ladi.
• 2. Massiv noldan boshlanishini unutmang.
• 3. Massivning oxirgi elementi indeksga ega (massiv hajmi 1 ga teng)

Biz massivdan tashqariga chiqdikmi yoki yo'qmi, tekshirishning to'liq usullari yo'q. Shuning uchun, biz uning hajmini aniq bilamiz yoki uni o'zgaruvchida saqlaymiz va kerak bo'lganda o'qiymiz.

Misollar

Endi massivlar bilan ishlashning bir necha tipik misollari
1. Massivni teskari aylantiring.

#o'z ichiga oladi #o'z ichiga oladi //Bu makro. Koddagi SIZE 10u bilan almashtiriladi #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); imzosiz i, j; // hisoblagichlar unsigned yarmi //massivning o'rtasi unsigned tmp; j = SIZE - 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(); }

Mana sizga notanish dizayn

#10u oʻlchamini aniqlang

makro. Kod davomida preprotsessor avtomatik ravishda SIZE ning barcha holatlarini 10u bilan almashtiradi.
2. Foydalanuvchi tomonidan tanlangan elementni o'chirish.

#o'z ichiga oladi #o'z ichiga oladi #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //counter int indeks; //foydalanuvchi tomonidan kiritilgan indeks / /Chiqish massivi (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 && indeksi< 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(); }

Bunday holda, albatta, element o'chirilmaydi. Massiv avvalgidek o'lchamda qoladi. Biz shunchaki o'chirilayotgan elementni keyingisiga yozamiz va SIZE-1 elementlarini chiqaramiz.
3. Foydalanuvchi qiymatlarni massivga kiritadi. Shundan so'ng, u kiritgan barcha turli qiymatlarni chop eting.
Foydalanuvchi chekli sonli elementlarni kiritsin, deylik, 10. Keyin jami 10 dan ortiq turli qiymatlar bo'lmasligi oldindan ma'lum bo'lib, foydalanuvchi har safar raqamni kiritganda, biz massivdan o'tamiz va tekshiramiz bunday raqam kiritilganmi yoki yo'qmi.

#o'z ichiga oladi #o'z ichiga oladi #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //qancha turli raqamlar kiritilgan. Kamida bitta. int kiritish; int wasntFound; //belgilash kiritilgan raqam topilmadi //Birinchi raqamni kiriting 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. Foydalanuvchi raqamni kiritadi - o'lchovlar soni (2 dan 10 gacha). Shundan so'ng, barcha o'lchovlarni kiriting. Dastur o'rtacha qiymatni, farqni va xatoni ko'rsatadi.

#o'z ichiga oladi #o'z ichiga oladi #o'z ichiga oladi #define SIZE 20u void main() ( //Talaba koeffitsientlari ikki o'lchovdan boshlanadi const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float sum = .0f; float disp;< 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. Massiv pufakchali tartiblash

#o'z ichiga oladi #o'z ichiga oladi #10 oʻlchamini aniqlang #notoʻgʻrini aniqlang 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; unsigned i, j;< 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; bayroq = rost; ) ) ) while(bayroq == rost); //(i = 0; i.) uchun tartiblangan massivni chiqaring< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Massivni aralashtiring. Buning uchun algoritmdan foydalanamiz