Gəlin C++ dilinin əsaslarını öyrənməyə davam edək. Bu yazıda massivlərə baxacağıq.

Massivlər böyük həcmdə verilənləri rahat formatda saxlamağa imkan verir. Faktiki olaraq, massiv bir ad altında birdən çox dəyəri saxlayan dəyişəndir, lakin hər bir dəyərə öz indeksi verilir. indekslərin daxil olmaq üçün istifadə etdiyi dəyərlərin siyahısıdır.

Massivlərə giriş

Massivi belə təsəvvür edə bilərsiniz:

Bu, bir ad altında bir-birinin ardınca saxlanılan bəzi dəyərlər toplusudur. Bu dəyərləri əldə etmək üçün yeni dəyişənlər yaratmağa ehtiyac yoxdur, sadəcə dəyərin massivdə saxlandığı indeksi göstərmək lazımdır. Məsələn, siz poker üçün beş oyun kartı dəstini almalısınız, siz bu kartları massivdə saxlaya və yeni dəyişəndən istifadə etmək əvəzinə, yeni kart seçmək üçün yalnız indeks nömrəsini dəyişə bilərsiniz. Bu, bütün kartları işə salmaq üçün eyni kodu istifadə etməyə və bu şəkildə yazmağa imkan verəcək:

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

Üçün (int i = 0; i< 5; i++) { card[i] = getRandomCard(); }

İndi 100 dəyişən varsa fərqi təsəvvür edin!

Sintaksis

Massivi elan etmək üçün iki şeyi (addan başqa) göstərməlisiniz: massivin növü və ölçüsü:

Int my_array[ 6 ];

Bu sətir altı tam dəyərdən ibarət massiv elan edir. Diqqət yetirin ki, massiv ölçüsü massivin adından sonra kvadrat mötərizə içərisindədir.

Massiv elementlərinə daxil olmaq üçün kvadrat mötərizələrdən istifadə edirsiniz, lakin bu dəfə daxil olmaq istədiyiniz elementin indeksini təyin edirsiniz:

My_massivim[ 3 ];

Bu prosesi belə təsəvvür edə bilərsiniz:

my_massiv bütün massivə aiddir, my_array yalnız birinci elementə, my_array dördüncü elementə aiddir. qeyd edin ki indeksləşdirmə massivdəki elementlər 0-dan başlayır. Beləliklə, massiv elementlərinə daxil olmaq həmişə ofsetlə baş verəcək, məsələn:

Int my_array[ 4 ]; // massiv elanı my_array[ 2 ] = 2; // üçüncü (yəni üçüncü!) dəyərini 2-yə təyin edin

C++ dilində çoxölçülü massivlərin elan edilməsi

Massivlər həmçinin şahmat taxtası və ya tic-tac-toe lövhəsi kimi çoxölçülü məlumatları təmsil etmək üçün istifadə edilə bilər. Çoxölçülü verilənlərdən istifadə edərkən massiv elementlərinə daxil olmaq üçün çoxlu indekslərdən istifadə olunacaq.

İki ölçülü massivi elan etmək üçün iki ölçüsün ölçüsünü təyin etməlisiniz:

Int tic_tac_toe_board;

Massivin elementlərinin indeksləri ilə vizuallaşdırılması:

Belə massivin elementlərinə daxil olmaq üçün sizə iki indeks lazımdır - biri sətir, digəri isə sütun üçün. Şəkildə elementlərin hər birinə daxil olmaq üçün lazımi indekslər göstərilir.

Massivlərdən istifadə

Massivlərdən istifadə edərkən onsuz edə bilməzsiniz. Döngüdən keçmək üçün siz sadəcə olaraq dəyişəni sıfıra endirin və onu massivin ölçüsünü keçənə qədər artırın - bu, döngə üçün düzgün nümunədir.

Aşağıdakı proqram vurma cədvəli yaratmaq və nəticəni iki ölçülü massivdə saxlamaq üçün döngədən istifadəni nümayiş etdirir:

#daxildir ad sahəsi std istifadə edərək; int main() ( int massivi; // (int i = 0; i) üçün şahmat taxtası kimi görünən massiv elan edin< 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"; } } }

Massivlərin funksiyalara ötürülməsi

Göründüyü kimi, C++ dilinin müxtəlif elementləri bir-biri ilə qarşılıqlı əlaqədədir. Döngələrdə olduğu kimi, massivlər ilə birlikdə istifadə edilə bilər.

Massivi funksiyaya ötürmək üçün sadəcə onun adını qeyd edin:

Int dəyərləri[ 10 ]; cəm_massiv(dəyərlər);

Və funksiyanı elan edərkən, arqument kimi bir massiv göstərin:

Int sum_array(int dəyərlər);

Nəzərə alın ki, biz funksiya arqumentlərində massivin ölçüsünü göstərmirik, bu, birölçülü massivlər üçün ölçünün göstərilməsinə ehtiyac yoxdur; Ölçü nə vaxt göstərilməlidir massivlərin elan edilməsi , çünki Kompilyator nə qədər yaddaşın ayrılacağını bilməlidir. Funksiyaya keçərkən biz sadəcə olaraq mövcud massivdən keçirik, çünki ölçüsünü təyin etməyə ehtiyac yoxdur; Biz yenisini yaratmırıq. Çünki massivi funksiyaya ötürə bilərik, funksiya daxilində edə bilərik dəyişmək, dəyəri ilə ötürülən sadə dəyişənlərdən fərqli olaraq və bu dəyəri funksiya daxilində dəyişdirmək orijinal dəyişənə heç bir şəkildə təsir etməyəcək.

Funksiya daxilində massivin ölçüsünü bilmədiyimiz üçün ölçüsünü ikinci arqument kimi ötürməliyik:

Int sumArray(int dəyərlər, int ölçüsü) ( int sum = 0; for (int i = 0; i)< size; i++) { sum += values[ i ]; } return sum; }

Çoxölçülü massivləri keçəndə birincidən başqa bütün ölçüləri göstərməliyik:

Int check_tic_tac_toe(int board);

Siz, əlbəttə ki, birinci ölçüsü təyin edə bilərsiniz, lakin nəzərə alınmayacaq.

Bu mövzu göstəricilər haqqında məqalədə daha ətraflı müzakirə olunacaq.

Hələlik, massiv elementlərinin cəmini hesablayan funksiya yazaq:

#daxildir ad sahəsi std istifadə edərək; int sumArray(int dəyərləri, int ölçüsü) ( int sum = 0; // i == ölçüsü olduqda dövrə dayanacaq, çünki sonuncu elementin indeksi = size - 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 "<< mən <<": "; cin >> dəyərlər[i]; ) cout<< sumArray(values, 10) << endl; }

Massivi çeşidləyin

İstifadəçinin daxil etdiyi 100 ədəddən ibarət massivin çeşidlənməsi məsələsini həll edək:

#daxildir ad sahəsi std istifadə edərək; int main() ( int dəyərlər[ 100 ]; üçün (int i = 0; i)< 100; i++) { cout << "Enter value "<< mən <<": "; cin >> dəyərlər[ i ]; ) )

Bitdi, qalan bu massivi çeşidləməkdir :) İnsanlar adətən massivləri necə çeşidləyirlər? Onlar içindəki ən kiçik elementi axtarır və onu siyahının başına qoyurlar. Sonra onlar növbəti minimum dəyəri axtarır və onu birincidən dərhal sonra qoyurlar və s.

Bütün bunlar bir dövrə bənzəyir: biz birinci elementdən başlayaraq massivdən keçirik və qalan hissədə minimum dəyəri axtarırıq və bu elementləri dəyişdiririk. Bu əməliyyatları yerinə yetirmək üçün kodu yazmaqla başlayaq:

Etibarsız çeşidləmə (int massivi, int ölçüsü) ( üçün (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

İndi siz iki köməkçi metodun tətbiqi haqqında düşünə bilərsiniz, findSmallestRemainingElement və swap. findSmallestRemainingElement metodu massivdə təkrarlanmalı və i indeksindən başlayaraq ən kiçik elementi tapmalıdır:

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

Nəhayət, dəyişdirmə funksiyasını həyata keçirməliyik. Funksiya orijinal massivi dəyişdirəcəyi üçün sadəcə müvəqqəti dəyişəndən istifadə edərək dəyərləri dəyişdirməliyik:

Etibarsız dəyişdirmə (int massivi, int birinci_index, int ikinci_index) ( int temp = massiv[ birinci_indeks ]; massiv[ birinci_index ] = massiv[ ikinci_index ]; massiv[ ikinci_index ] = temp; )

Alqoritmi yoxlamaq üçün massivi təsadüfi ədədlərlə doldurun və çeşidləyin. Bütün proqram kodu:

#daxildir #daxildir #daxildir ad sahəsi std istifadə edərək; int findSmallestRemainingElement(int massivi, int ölçüsü, int indeksi); etibarsız mübadilə (int massivi, int birinci_index, int ikinci_index); boş çeşidləmə (int massivi, int ölçüsü) ( üçün (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"; }

Bayaq baxdığımız çeşidləmə alqoritmi adlanır daxil etmə növü , bu ən sürətli alqoritm deyil, lakin onu başa düşmək və həyata keçirmək asandır. Böyük həcmdə məlumatları çeşidləmək məcburiyyətindəsinizsə, daha mürəkkəb və daha sürətli alqoritmlərdən istifadə etmək daha yaxşıdır.

Massiv bir ad altında birləşmiş eyni tipli hüceyrələr qrupu kimi təmsil olunan məlumat strukturudur. Massivlər eyni tipli böyük həcmli verilənləri emal etmək üçün istifadə olunur. Massivin adı göstəricilərdir, sizə bir az sonra deyəcəyəm. Massivin fərdi məlumat xanasına massiv elementi deyilir. Massivin elementləri istənilən növ verilənlər ola bilər. Massivlər bir və ya birdən çox ölçüyə malik ola bilər. Ölçülərin sayından asılı olaraq massivlər birölçülü massivlərə, ikiölçülü massivlərə, üçölçülü massivlərə və s. n ölçülü massivə qədər bölünür. Proqramlaşdırmada ən çox birölçülü və ikiölçülü massivlərdən istifadə olunur, ona görə də biz yalnız bu massivləri nəzərdən keçirəcəyik.

C++ dilində birölçülü massivlər

Birölçülü massiv birölçülü massivin elementlərinin sayını xarakterizə edən bir parametrə malik massivdir. Əslində, bir ölçülü massiv yalnız bir sıra və n sayda sütuna malik ola bilən massivdir. Birölçülü massivdəki sütunlar massivin elementləridir. Şəkil 1 tam ədədli birölçülü massivin strukturunu göstərir a. Bu massivin ölçüsü 16 xanadır.

Şəkil 1 - C++ dilində massivlər

Qeyd edək ki, birölçülü massivin maksimum indeksi a 15-dir, lakin massivin ölçüsü 16 xanadır, çünki massiv xanalarının nömrələnməsi həmişə 0-dan başlayır. Hüceyrə indeksi qeyri-mənfi tam ədəddir, onun vasitəsilə siz massivin hər bir xanasına daxil ola və onun üzərində istənilən hərəkəti edə bilərsiniz ( hüceyrə).

//C++-da birölçülü massivi elan etmək üçün sintaksis: /*məlumat növü*/ /*birölçülü massivin adı*/; //Şəkil 1-də göstərilən birölçülü massivin elan edilməsi nümunəsi: int a;

burada, int tam ədəddir;

A birölçülü massivin adıdır;
16 bir ölçülü massivin ölçüsüdür, 16 xana.

Həmişə massiv adından dərhal sonra birölçülü massivin ölçüsünün göstərildiyi kvadrat mötərizələr olur;

//birölçülü massivləri elan etməyin başqa yolu int mas, a;

İki birölçülü mas və a massivləri müvafiq olaraq 10 və 16 ölçüləri ilə elan edilir. Üstəlik, bu bəyanetmə metodunda bütün massivlər eyni məlumat tipinə malik olacaq, bizim vəziyyətimizdə - int.

// massivlər elan edildikdə işə salına bilər: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // birölçülü massivin inisializasiyası

Birölçülü massivin inisiallaşdırılması işarədən sonra əyri mötərizələrdə yerinə yetirilir bərabərdir, massivin hər bir elementi əvvəlkindən vergüllə ayrılır.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // massivin ölçüsünü təyin etmədən işə salınması.

Bu halda kompilyator özü birölçülü massivin ölçüsünü təyin edəcək. Massivin ölçüsü yalnız onu inisiallaşdırarkən buraxıla bilər, massiv normal elan edildikdə, massivin ölçüsü göstərilməlidir; Bir ölçülü massivi emal etmək üçün sadə proqram hazırlayaq.

// array.cpp: Konsol tətbiqi üçün giriş nöqtəsini təyin edir. #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++ kodu

// array.cpp: Konsol tətbiqi üçün giriş nöqtəsini təyin edir. #daxildir ad sahəsi std istifadə edərək; 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 sətirlər 10 - 11 array1 adlı tam ədədli birölçülü massiv elan edilib və inisiallaşdırılıb, onun ölçüsü 16 xanadır, yəni belə massiv 16 ədədi saxlaya bilir. İstənilən massiv emalı yalnız döngələrlə birlikdə mümkündür. Massivi emal etmək üçün hansı döngəni seçmək sizin ixtiyarınızdadır. Ancaq bu vəzifə üçün ən uyğundur. Birölçülü massiv1 massivinin elementlərinə daxil olmaq üçün sayğac dəyişən sayğacından istifadə edəcəyik. Birölçülü massiv1-də on altıncı indeks olmadığı üçün for dövrəsinin davam şərti ciddi bərabərsizlik işarəsini ehtiva edir. Hüceyrələrin nömrələnməsi sıfırdan başladığı üçün massivdə 16 element var for loopunun gövdəsində cout operatoru birölçülü massivin elementlərini çap edir (bax Şəkil 2).

Obrabotka massiva indeksləri 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 31array1 davam edin, istənilən düyməni basın. . .

Şəkil 2 - C++ dilində massivlər

C++ dilində birölçülü massivin emalı üçün başqa bir proqram hazırlayaq. Proqram ardıcıl olaraq klaviaturadan daxil edilmiş on ədədi oxumalıdır. Bütün daxil edilmiş nömrələr yekunlaşdırılır və nəticə ekranda göstərilir.

// array_sum.cpp: Konsol tətbiqi üçün giriş nöqtəsini təyin edir. #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++ kodu

// array_sum.cpp: Konsol tətbiqi üçün giriş nöqtəsini təyin edir. #daxildir ad sahəsi std istifadə edərək; int main(int argc, char* argv) ( int array1; // cout tam massivi elan edin<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> massiv1; // klaviaturadan daxil edilmiş nömrələri oxuyun<< "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; }

Massivi emal etməzdən əvvəl onu elan etmək lazımdır və birölçülü massivin ölçüsü 10-dur, çünki bu, tapşırığın şərti ilə şərtlənir. Sum dəyişənində biz birölçülü massivin elementlərinin cəmini toplayacağıq. Birinci for döngüsü elan edilmiş birölçülü massivi klaviaturadan daxil edilmiş nömrələrlə doldurur, sətirlər 12 - 13. Sayğac dəyişəni 0-dan başlayaraq 9-cu indeksə qədər birölçülü massivin1 elementlərinə ardıcıl daxil olmaq üçün istifadə olunur. İkinci for döngüsü massivin elementlərini göstərir, sətirlər 15 - 16. Üçüncü for döngəsi ardıcıl olaraq birölçülü massivin elementlərini oxuyur və onları cəmləşdirir, cəmi sum dəyişənində toplanır. sətirlər 17 - 18. Proqramın nəticəsi Şəkil 3-də göstərilmişdir.

Elementi massiva daxil edin: 0 1 2 3 4 5 6 7 8 9 massiv1 = (0 1 2 3 4 5 6 7 8 9 ) cəmi = 45 Davam etmək üçün istənilən düyməni basın. . .

Şəkil 3 - C++ dilində massivlər

Əvvəlcə bütün 10 rəqəm ardıcıl olaraq daxil edildi, bundan sonra bir ölçülü massiv göstərildi və massivdəki nömrələrin cəmi çap edildi.

C++ dilində ikiölçülü massivlər

Bu nöqtəyə qədər biz həmişə məhdudlaşa bilməyən birölçülü massivləri nəzərdən keçirdik. Tutaq ki, cədvəldən bəzi məlumatları emal etməlisiniz. Cədvəlin iki xüsusiyyəti var: sətirlərin sayı və sütunların sayı. Həmçinin ikiölçülü massivdə massiv elementlərinin sayından əlavə ikiölçülü massivin sətirlərinin sayı və sütunlarının sayı kimi xüsusiyyətlər də mövcuddur. Yəni vizual olaraq ikiölçülü massiv sətir və sütunlardan ibarət adi cədvəldir. Əslində ikiölçülü massiv birölçülü massivlərin birölçülü massividir. Ölçüsü m x n olan a adlı ikiölçülü massivin strukturu aşağıda göstərilmişdir (Şəkil 4-ə bax).

Şəkil 4 - C++ dilində massivlər

burada, m ikiölçülü massivin sətirlərinin sayıdır;
n - ikiölçülü massivin sütunlarının sayı;
m * n — massiv elementlərinin sayı.

// ikiölçülü massivi elan etmək üçün sintaksis /*məlumat növü*/ /*massiv adı*/;

İkiölçülü massivi elan edərkən, eləcə də birölçülü massivi elan edərkən ilk növbədə aşağıdakıları göstərməlisiniz:

• məlumat növü;
• massiv adı.

Bundan sonra birinci kvadrat mötərizələr ikiölçülü massivin sətirlərinin sayını, ikinci kvadrat mötərizələr isə ikiölçülü massivin sütunlarının sayını göstərir. İki ölçülü massiv vizual olaraq bir ölçülü massivdən ikinci kvadrat mötərizə ilə fərqlənir. İkiölçülü massivin elan edilməsi nümunəsinə baxaq. Tutaq ki, elementlərinin sayı 15-ə bərabər olan ikiölçülü massiv elan etməliyik. Bu halda ikiölçülü massiv üç sıra və beş sütun və ya beş sətir və üç sütun ola bilər.

// ikiölçülü massivin bəyannaməsi nümunəsi: int a;

• a tam ədəd massivinin adıdır
• birinci kvadrat mötərizədə olan rəqəm ikiölçülü massivin cərgələrinin sayını göstərir, bu halda 5-dir;
• ikinci kvadrat mötərizədə olan rəqəm ikiölçülü massivin sütunlarının sayını göstərir, bu halda 3-dür.

// ikiölçülü massivin işə salınması: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Bu massivdə 5 sıra, 3 sütun var. təyin işarəsindən sonra ümumi qıvrımlı mötərizələr yerləşdirilir, onların içərisində ikiölçülü massivdə nə qədər sətir olmalıdırsa, o qədər cüt buruq mötərizə yerləşdirilir və bu mötərizələr vergüllə ayrılır. Buruq mötərizələrin hər bir cütünə vergüllə ayrılmış iki ölçülü massivin elementlərini yazın. Bütün buruq mötərizələrdə elementlərin sayı eyni olmalıdır. Massivdə beş sətir olduğundan, beş daxili cüt mötərizə də var. Sütunların sayı üç olduğu üçün daxili mötərizədə üç element yazılır. Qrafik olaraq, massivimiz ikiölçülü cədvələ bənzəyəcək (Şəkil 5-ə baxın).

Şəkil 5 - C++ dilində massivlər

İki ölçülü massivin hər xanasında a dəyər göstərilir, bu xananın ünvanı aşağı sağ küncdə göstərilir. İki ölçülü massivin xana ünvanı massivin adı, sıra nömrəsi və sütun nömrəsidir.

Gəlin “Labirint” adlı ikiölçülü massivin emalı üçün sadə proqram hazırlayaq. Labirint ikiölçülü massiv əsasında qurulmalıdır. Labirint ölçüsünü öz mülahizəmizlə seçəcəyik.

// array2.cpp: Konsol tətbiqi üçün giriş nöqtəsini təyin edir. #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); ) başqa cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kod Kod::Bloklar

// Dev-C++ kodu

// array2.cpp: Konsol tətbiqi üçün giriş nöqtəsini təyin edir. #daxildir ad sahəsi std istifadə edərək; int main(int argc, char* argv) ( // 1-şərti olaraq “labirint divarları” // 2-“düzgün yol, labirintdən çıxış” // 0-“yanlış yol” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // ikiölçülü massivin işə salınması ( 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,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,) ); // iki döngə - daxili və xarici, serialın hər bir elementinə daxil olmaq üçün (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); ) başqa cout<< " "; // вывести два пробела cout << endl; } return 0; }

Düzgün və yanlış yollar eyni rəqəmlə, məsələn, sıfırla işarələnə bilərdi, lakin aydınlıq üçün düzgün yol 2 rəqəmi ilə işarələnir. Massiv yalnız proqramı sadələşdirmək üçün əl ilə işə salınıb. Proqram ikiölçülü massivi emal etdiyi üçün ikiölçülü massivin elementləri arasında keçid etmək üçün iki dövrə lazımdır. Birinci for loop ikiölçülü massivin sətirləri arasında keçid edir. İkiölçülü massivdə 33 sıra olduğundan, sayğac dəyişəni i 0-dan 33-ə qədər artırılır, 46-cı sətir. Birinci döngənin içərisində iki ölçülü massivin sıra elementləri arasında dövr edən for döngəsi var. İkinci for döngəsinin gövdəsində daxili məlumat tipinə vahid çevrilmə əməliyyatı həyata keçirilir - static_cast<>() , 176 simvol nömrəsini çap edir. Labirentin enini artırmaq üçün məlumat növünün çevrilməsi əməliyyatı təkrarlanır. Proqramın nəticəsi (bax Şəkil 6).

Şəkil 6 - C++ dilində massivlər

Son yeniləmə: 17/09/2017

Massiv eyni tipli verilənlər toplusunu təmsil edir. Massivin formal tərifi aşağıdakı kimidir:

Dəyişən_növ massiv_adı [massiv_uzunluğu]

Dəyişənin tipindən sonra massivin adı, sonra isə kvadrat mötərizədə onun ölçüsü gəlir. Məsələn, 4 ədəddən ibarət massiv müəyyən edək:

Int nömrələri;

Bu massivdə dörd ədəd var, lakin bu nömrələrin hamısının qeyri-müəyyən dəyəri var. Bununla belə, biz başlatma həyata keçirə və buruq mötərizələr vasitəsilə bu nömrələrə bəzi ilkin dəyərlər təyin edə bilərik:

Int ədədləri = (1,2,3,4);

Qıvrımlı mötərizələrdəki dəyərlərə başlatıcılar da deyilir. Əgər massivdəki elementlərdən daha az başlatıcı varsa, ilk elementlər üçün başlatıcılardan istifadə olunur. Əgər massivdə elementlərdən daha çox başlatıcı varsa, kompilyasiya zamanı xəta baş verəcək:

Int ədədləri = (1, 2, 3, 4, 5, 6);

Burada massiv 4 ölçüsünə malikdir, lakin ona 6 dəyər ötürülür.

Əgər massivin ölçüsü açıq şəkildə göstərilməyibsə, o, başlatıcıların sayından nəticə çıxarır:

Int ədədləri = (1, 2, 3, 4, 5, 6);

Bu halda massiv 6 elementə malikdir.

Simvol massivlərinin inisiallaşdırılması öz xüsusiyyətlərinə malikdir. Biz həm başlatıcı dəsti, həm də sətri simvol massivinə ötürə bilərik:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "dünya";

Üstəlik, ikinci halda, s2 massivində 5 deyil, 6 element olacaq, çünki sətirlə işə salındıqda, sıfır simvolu “\0” avtomatik olaraq simvol massivinə əlavə olunur.

Bu halda bir massivi digər massivə təyin etməyə icazə verilmir:

Int ədədləri1 = (1,2,3,4,5); int ədədlər2 = ədədlər1; // xəta ədədləri2 = ədədlər1; // xəta

Massiv müəyyən edildikdən sonra biz onun fərdi elementlərinə indekslə daxil ola bilərik. İndekslər sıfırdan başlayır, ona görə də birinci elementə daxil olmaq üçün indeks 0-dan istifadə etməliyik. Elementə indeks üzrə daxil olmaqla, onun dəyərini əldə edə və ya dəyişdirə bilərik:

#daxildir int main() ( int ədədlər = (1,2,3,4); int birinci_sayı = ədədlər; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Massiv elementlərinin sayı sabit vasitəsilə də müəyyən edilə bilər:

Const int n = 4; int ədədləri[n] = (1,2,3,4);

Massivlər üzərində təkrarlama

Döngələrdən istifadə edərək siz bütün massivi təkrarlaya və onun elementlərinə indekslər vasitəsilə daxil ola bilərsiniz:

#daxildir int main() ( int ədədlər = (1,2,3,4); int ölçüsü = sizeof(nömrələr)/sizeof(nömrələr); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Massivdə dövrə vurmaq üçün əvvəlcə massivin uzunluğunu tapmaq lazımdır. Uzunluğu tapmaq üçün sizeof operatorundan istifadə olunur. Əsasən, massivin uzunluğu onun elementlərinin ümumi uzunluğuna bərabərdir. Bütün elementlər eyni növü təmsil edir və yaddaşda eyni ölçü tutur. Buna görə də sizeof(nömrələr) ifadəsindən istifadə edərək bütün massivin uzunluğunu baytla, sizeof(nömrələr) ifadəsindən istifadə edərək bir elementin baytla uzunluğunu tapırıq. İki dəyəri bölməklə, massivdəki elementlərin sayını əldə edə bilərsiniz. Sonra for loopundan istifadə edərək, sayğac i massivin uzunluğuna bərabər olana qədər bütün elementləri təkrarlayırıq. Nəticədə, massivin bütün elementləri konsola çıxarılacaq:

Lakin for loopunun başqa forması da var ki, o, xüsusi olaraq massivlər də daxil olmaqla kolleksiyalarla işləmək üçün nəzərdə tutulmuşdur. Bu forma aşağıdakı formal tərifə malikdir:

Üçün (dəyişən növü: kolleksiya) ( təlimat; )

Massiv vasitəsilə təkrarlamaq üçün bu formadan istifadə edirik:

#daxildir int main() ( int ədədlər = (1,2,3,4); for(int sayı: ədədlər) std::cout<< number << std::endl; return 0; }

Massiv vasitəsilə təkrarlanan zaman, təkrarlanan hər bir element, dəyəri dövrədə konsolda çap olunan ədəd dəyişəninə yerləşdiriləcək.

Massivdəki obyektlərin tipini bilmiriksə, növü müəyyən etmək üçün avtomatik təyinedicidən istifadə edə bilərik:

Üçün (avtomatik nömrə: nömrələr) std::cout<< number << std::endl;

Çoxölçülü massivlər

Birölçülü massivlərə əlavə olaraq, C++ çoxölçülü massivlərə malikdir. Belə massivlərin elementləri öz növbəsində massivlərdir ki, onların elementləri də massivlər ola bilər. Məsələn, iki ölçülü ədədlər massivini təyin edək:

Int nömrələri;

Belə massiv üç elementdən ibarətdir, hər bir element iki elementdən ibarət massivi təmsil edir. Belə bir massivi işə salaq:

Int ədədlər = ( (1, 2), (4, 5), (7, 8) );

İç-içə əyilmiş mötərizələr hər bir alt massiv üçün elementləri təsvir edir. Belə bir massiv cədvəl şəklində də təqdim edilə bilər:

1	2
4	5
7	8

Siz həmçinin başlatma zamanı buruq mötərizələri buraxa bilərsiniz:

Int ədədlər = ( 1, 2, 4, 5, 7, 8 );

Bütün elementləri deyil, yalnız bəzilərini işə salmaq da mümkündür:

Int ədədlər = ( (1, 2), (), (7) );

İçəri daxil edilmiş massivin elementlərinə daxil olmaq üçün sizə iki indeks lazımdır:

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

İki ölçülü massiv üzərində təkrarlayaq:

#daxildir int main() ( const int sətirlər = 3, sütunlar = 2; int ədədlər = ( (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; }

Çoxölçülü massivin elementləri arasında təkrarlamaq üçün for döngəsinin başqa formasından da istifadə edə bilərsiniz:

#daxildir int main() ( const int sətirlər = 3, sütunlar = 2; int ədədlər = ( (1, 2), (3, 4), (5, 6) ); for(avtomatik və alt nömrələr: ədədlər) ( for(int sayı) : alt nömrələr) ( std :: cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Massivə daxil olan massivləri təkrarlamaq üçün istinadlardan istifadə olunur. Yəni, xarici döngədə for(avtomatik &alt nömrələr: ədədlər) &alt nömrələr massivdə altmasviv istinadını təmsil edir. Daxili döngədə for(int number: subnumbers) altnömrələrdəki hər bir alt massivdən onun fərdi elementlərini ədəd dəyişəninə alırıq və dəyərini konsola çıxarırıq.

Massivlər eyni tipli bir neçə dəyəri saxlamaq üçün nəzərdə tutulmuşdur. Məsələn, Fahrenheit to Celsius proqramında üçdən orta temperatur dəyərini hesabladıq. Əgər üç deyil, daha çox dəyər varsa, massivlərdən istifadə etməli olduğunuz yer budur.

Massivdən istifadə etməzdən əvvəl onu müəyyən etməlisiniz. Massivin tərifinə aşağıdakılar daxildir: massivdə saxlanılan verilənlərin növü, massivin adı və kvadrat mötərizədə massiv elementlərinin sayı:

int massivi;

Bu kodda biz int tipli on elementdən ibarət identifikator (ad) massivi ilə massiv müəyyən etdik.
Bu formada massivin bütün elementləri hələ də işə salınmayıb. Elan edildikdə onları işə salmaq üçün aşağıdakı sintaksisdən istifadə etməlisiniz:

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

Bu halda massivin birinci elementinə 0, sonuncuya isə 9 qiyməti təyin edilir.
Massiv elementlərinə dəyərlər təyin etmək üçün döngələrdən istifadə edə bilərsiniz. Bunun üçün ən uyğun for loop olardı.

C++ kodu int massivi; // üçün massiv tərifi (int i = 0; i< 10; i++) { array[i] = i; }

Burada massivin hər bir elementinə bir indeks vasitəsilə daxil oluruq - kvadrat mötərizədəki rəqəm. Döngənin hər iterasiyası ilə sıfırdan 9-a qədər dəyərlər alır.

Qeyd edək ki, indekslərin nömrələnməsi sıfırdan başlayır. Buna görə də indekslərin sayı həmişə massiv elementlərinin sayından bir azdır.

Kvadrat mötərizələr və alt işarələr istisna olmaqla, massiv elementi hər hansı dəyişən kimi istifadə olunur.

Simlər

İndiyə qədər biz yalnız sətirləri sabitlərdə saxlaya bilirdik: “Sabit sətir nümunəsi”. Biz dəyişənlərdə yalnız bir simvol saxlaya bildik - char tipində. C++ iki növ sətirdən istifadə edir: char tipli elementlər massivi və str tipli. Hələlik birinci varianta diqqət yetirəcəyik.

Bir sətri saxlamaq üçün bizə bir massiv lazımdır. Bu kimi bir şey görünür:

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

Xoşbəxtlikdən daha asan bir yol var :)

char string = "string";

Bu halda avtomatik olaraq yeddi elementdən ibarət massiv yaradılacaq. Niyə yeddidən? Məsələ ondadır ki, hər bir sətir boş baytı təmsil edən “\0” simvol sabiti ilə bitməlidir.

Əvvəlki misallarda əgər sətir massivinə altı simvoldan çox sətir daxil etməyə çalışsaq, massiv daşacaq, çünki Proqram işləyərkən massivin ölçüsünü dəyişə bilməzsiniz (həmişə olmasa da):

char sətri; // sətir altı simvol və "\0" saxlaya bilər

string = "string!"; // sətir yeddi simvoldan ibarətdir
Bunu etmək tövsiyə edilmir :)

Diqqətinizi çəkmək istədiyim daha bir məqam var. İstifadəçi sətirə daxil olduqda, boşluqlar "\0" kimi sayılır. Hələlik proqramlarımıza sətirlər daxil etməyəcəyik, ona görə də bu işi ətraflı izah etməyəcəm.

Massivlərin massivləri (iki ölçülü massivlər)

Yaxşı, nəhayət, bu məsələdə ən vacib şeyə gəldik.

Strategiya (və təkcə deyil) oyunlarında (RTS) xəritə hüceyrələrə bölünür (ingilis dilində - kafel). Bu hüceyrələri iki ölçülü massivdən istifadə etməklə təmsil etmək rahatdır.

Bu nümunədə biz pseudo_game proqramı ilə işləməyə davam edəcəyik və iki ölçülü massivdən istifadə edərək, oyunçunun hərəkət edə biləcəyi xəritəni simulyasiya edəcəyik. İndiyədək “hərəkət” x, y koordinatlarından istifadə etməklə təmsil olunurdu.

Hüceyrələri simvollarla təmsil edəcəyik. "Kart"ın ölçüsü 15x20-dir. Hündür on beş, eni iyirmi. Biz oyunçunu T simvolu ilə təmsil edəcəyik.

Əvvəlcə başlıq faylını əlavə edin stdlib.h.

Təkmilləşdirilmiş psevdo_oyun

Mən yalnız kod parçaları verəcəyəm. Tam proqramın gözünüzün qabağında olması məsləhətdir. Siz onu "proqram siyahıları" bölməsində tapa bilərsiniz - pseudo_game_0_2. O, tərtib edir və işləyir. Sadəcə onu IDE redaktorunuza köçürün və mətnə ​​əməl edin.

Məlumatın işə salınması:

C++ kodu xarakter aktı; // istifadəçi daxiletməsini oxumaq üçün dəyişən int ch; // dəyişənin azaldılmış dəyərini saxlamaq üçün dəyişən akt int x = 0; // oyunçunun koordinatlarını saxlamaq üçün iki dəyişən int y = 0; char xəritəsi; // oyun kartının saxlanması üçün massiv // serialın işə salınması (int i = 0; i)< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Burada bizim üçün yeni operator ikiölçülü massivin tərifidir. Ancaq bir ölçülü olandan demək olar ki, heç bir fərqi yoxdur, sadəcə başqa bir cüt kvadrat mötərizə əlavə olunur. Birinci mötərizədə satırların sayını, ikincisində - sütunların sayını göstərdik.

Bundan sonra iki döngədə massivin hər bir elementini " " dəyəri ilə inisiallaşdırırıq - bu sadəcə boşluq simvoludur. Birincisi, xarici döngədə bütün cərgələrdən keçirik. Daxili döngədə hər bir sıra üçün biz sütunları "keçdik".

Ətraflı misal verim: xarici döngənin bir neçə təkrarlanmasından sonra sayğac i 9-a bərabər olur. Xarici dövrənin gövdəsi icra olunmağa başlayır: j dəyişəni (daxili döngənin sayğacı) sıfıra inisiallaşdırılır, şərt yoxlanılır və daxili döngənin gövdəsi yerinə yetirilir: map = " ";, Yəni onuncu sətirin birinci simvoluna (indeks sıfır) (geri sayımın sıfırdan olduğunu unutmayın) boşluq verilir. Sonra j sayğacına 1 təyin edilir, dövrənin gövdəsi yerinə yetirilir... və s. sayğac j 20-yə bərabər olana qədər - şərt yerinə yetirilmir və daxili dövrədən çıxır. Sonra xarici sayğac artır. İndi 10-a bərabərdir və xarici döngənin gövdəsi yenidən icra olunur...

Boşluqlarla işə saldıqdan sonra oyunumuzun xarakterini birinci sıranın birinci sütununa yerləşdiririk.

Əsas dövrənin əvvəlində əvvəlki çıxışın ekranını təmizləmək üçün system() funksiyasını çağırırıq.

Sonra başlatma dövrlərinə bənzər iki dövr var. Onlar massiv elementlərini ekranda göstərmək üçün istifadə olunur. Yeganə əhəmiyyətli fərq, birinci döngənin gövdəsinin sonundakı yeni sətir simvolunun çıxışıdır.

Yaxşı, sonra hansı düymənin basıldığını müəyyən edən bir dallanma var. Budaqlanmanın özü keçən dəfədən çox az dəyişdi, lakin blokların məzmununda fərqlər var: birincisi, obyektin yerləşdiyi koordinatlara boşluq təyin edirik. Yəni əvvəlki yeri təmizləyirik. Sonra koordinatlardan birini dəyişdiririk. Və sonra, yeni indeksləri olan massiv elementinə "T" simvolunu təyin edirik.

"75" kodu üçün nümunə - sola hərəkət:

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

Yaxşı, hamısı budur. Hal-hazırda 15x20 ölçülü bir xəritəmiz var, onun üzərində simvolu hərəkət etdirmək üçün oxlardan istifadə edə bilərsiniz - "T" hərfi. Altıncı dərs üçün pis deyil! Bu proqram bütün konsol proqramlarımız üçün əsas olacaqdır. Qrafik təkmilləşdirmələr olmayacaq. Siz sadəcə DOS konsolundan daha çox yararlana bilməzsiniz və biz Windows konsolunu nəzərdən keçirməyəcəyik. Bu, vaxt və səylərə əhəmiyyətli dərəcədə qənaət edəcəkdir.

Pseudo_game proqramını ətraflı şərh etdim və çox güman ki, çətinlik çəkmədən başa düşəcəksiniz. Əgər yoxsa, proqram siyahısını yenidən oxuyun və başa düşməyincə bu məsələni başa düşməyəcəksiniz :). Məşqlər materialı birləşdirməyə kömək edəcəkdir. Təlimləri yerinə yetirmək məcburidir. Bir şey aydın deyilsə, e-poçtuma yazın - kömək etməyə çalışacağam.

Məşqlər:

1. Proqramın tam siyahısında mən keçid budaqlanmasından istifadə etdim. Bir if filial blokunun kodu da burada göstərilir. Qalan if bloklarını əlavə edin.

2. İndi proqram mövcud olmayan massiv elementlərinə yaza bilər. Xəritə limitlərini tərk edib-etmədiyinizi yoxlayın.

3. Təcrübə üçün ekranda dəniz döyüşü üçün iki sahə çəkən bir proqram yaradın. Birincisi oyunçu üçün, ikincisi düşmən üçündür. İkinci sahə birincinin sağında yerləşməlidir.
Daxili xanaları boşluqlarla doldurun. Haşiyə çəkmək üçün mənfi və düz bölmə xəttindən istifadə edin: -, |, künclər üçün isə # hash istifadə edin. Hər sahənin solunda nömrələr yığını var; yuxarıda hərflər var.
Bütün sahəni işə salmaq üçün sizə bir neçə döngə lazım ola bilər. İkinci sahədəki rəqəmlər sütununu doldurmaq üçün kodun necə görünə biləcəyi budur:

C++ kodu int sətri; // sətirləri təmsil edən dəyişən int sütunu; // sütunları təmsil edən dəyişən char xəritəsi; sütun = 15; üçün (sətir = 2; sətir< 12; string++) { map = string - 1; }

Deyək ki, eyni tipli çoxlu məlumatlarla işləmək lazımdır. Məsələn, bizdə müəyyən zaman addımı olan sarkacın koordinatlarının min ölçüləri var. Bütün dəyərləri saxlamaq üçün 1000 dəyişən yaratmaq çox... çətin işdir. Bunun əvəzinə, eyni tipli məlumatların çoxu bir ad altında birləşdirilə bilər və hər bir xüsusi elementə onun seriya nömrəsi ilə daxil olmaq olar.
C-də massiv aşağıdakı kimi müəyyən edilir
<тип> <имя массива>[<размер>];
Misal üçün,
int a;
adlı bir massiv alacağıq a yüz tip elementi ehtiva edən int. Dəyişənlərdə olduğu kimi, massiv də zibil ehtiva edir.
Birinci elementə giriş əldə etmək üçün onun nömrəsini (indeksini) kvadrat mötərizədə yazın. Misal üçün

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

Birinci elementin indeks nömrəsi 0 var. Bunun səbəbini anlamaq vacibdir. Bundan sonra kompüter yaddaşını lent kimi təqdim edəcəyik. Massivin adı massiv elementlərinin yerləşdiyi yaddaş ünvanının göstəricisidir.

düyü. 1 Massiv birinci elementin ünvanını saxlayır. i elementinin indeksi əvvəldən i*sizeof(tip) baytların yerdəyişməsidir

Massiv indeksi istənilən elementə daxil olmaq üçün massivin əvvəlindən neçə baytın dəyişdirilməsi lazım olduğunu göstərir. Məsələn, əgər massiv A növü var int, onda A o deməkdir ki, biz başlanğıca nisbətən 10*sizeof(int) baytı köçürdük. Birinci element ən başlanğıcdadır və 0*sizeof(int) ofsetinə malikdir.
C-də massiv öz ölçüsünü saxlamır və massiv indeksinin düzgünlüyünü yoxlamır. Bu o deməkdir ki, siz massivdən kənara çıxa və massivin sonuncu elementindən (və ya daha yaxın) uzaqda olan yaddaşa daxil ola bilərsiniz.

Massivin ilkin işə salınması.

Sadə bir proqram yazaq. Bir massiv yaradaq və sonra onun maksimum elementini tapaq.

#daxildir #daxildir void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); işarəsiz i; int maks; max = a; üçün (i = 1; i)<10; i++) { if (a[i] >

Bir nümunəyə baxaq. Əvvəlcə massivi yaradırıq və yaratdıqdan sonra onu işə salırıq. Bundan sonra tapılan maksimum elementə massivin birinci elementinin qiymətini təyin edirik.

Maks = a;

Sonra massivdən keçirik. Biz artıq birinci elementə baxdığımızdan (onun indeksi 1-ə malikdir), ona yenidən baxmağın mənası yoxdur.
Eyni nümunə, yalnız indi istifadəçi dəyərləri daxil edir

#daxildir #daxildir void main() ( int a; imzasız i; int max; printf("10 ədəd daxil edin\n"); üçün (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("maksimum element %d", maks); getch(); )

İnsializasiya zamanı massivin ölçüsündən daha az dəyər göstərilibsə, qalan elementlər sıfırlarla doldurulur.

#daxildir #daxildir void main() ( int a = (1,2,3); işarəsiz i; üçün (i = 0; i)<10; i++) { printf("%d ", a[i]); } getch(); }

Bütün massivi sıfırlarla doldurmaq lazımdırsa, yazırıq

Int a = (0);

Məsələn, massivin ölçüsünü açıq şəkildə təyin etmək lazım deyil

Int a = (1, 2, 3);

massivin ölçüsü 3 olacaq

Massiv ölçüsü

C-də massiv sabit ölçüyə malik olmalıdır. Bu o deməkdir ki, məsələn, istifadəçidən ölçü istəmək və sonra bu ölçüsü massivə təyin etmək mümkün deyil.

Printf("Massivin uzunluğunu daxil edin"); scanf("%d", &uzunluq); (flat x;)

Dinamik massivlərin yaradılması göstəricilər və yaddaşla işləyərkən daha sonra müzakirə olunacaq
Bəzi hallarda, funksiyadan istifadə edərək massivin ölçüsünü öyrənə bilərsiniz sizeof.

#daxildir #daxildir void main() ( int A; //sizeof bütün massivin ölçüsünü baytla qaytarır //Elementlərin sayını müəyyən etmək üçün //massivin ölçüsünü onun elementinin ölçüsünə bölün int size = sizeof(A) / sizeof(int);

Ancaq bunun faydalı olacağı ehtimalı azdır. Massivi funksiyaya arqument kimi ötürərkən göstərici ötürüləcək, ona görə də massivin ölçüsü məlum olmayacaq.
Statik massivlər elementlərin sayı əvvəlcədən məlum olduqda faydalıdır. Onlar elementlərə sürətli, lakin etibarsız girişi təmin edir.

Massiv daşması

Ümid edək ki, sizdə bu kod var

Haqqımızda Şirkətin Adı: Int A; int i; üçün (i=0; i<=10; i++) { A[i] = 1; }

Budur bir döngə üçün xəta ilə müəyyən edilmişdir. Kompilyatorların bəzi köhnə versiyalarında bu kod dönərdi. Məsələ ondadır ki, dəyişən i kompilyasiya zamanı massivdən dərhal sonra yerləşirdi A. Massiv sərhədləri aşdıqda, sayğac 1-ə təyin edildi.
Massivlər təhlükəlidir, çünki indekslə düzgün işləmək yaddaşın ixtiyari hissəsinə daxil olmağa səbəb ola bilər (Nəzəri olaraq. Müasir tərtibçilər özləri başqasının yaddaşına daxil olmamağınıza diqqət yetirirlər).
Massivlərlə işləyirsinizsə, sayğacın massivin ölçüsünü aşmamasını və mənfi olmadığını təmin etməlisiniz. Bunun üçün ən azı

• 1. İndeksləmə üçün size_t növündən istifadə edin. Sizi mənfi dəyərlərdən qoruyacaq və hər zaman istənilən ölçülü massiv üçün kifayət edəcəkdir.
• 2. Massivin sıfırdan başladığını unutmayın.
• 3. Massivin sonuncu elementi indeksə malikdir (massivin ölçüsü 1-dir)

Massivdən kənara çıxıb-çıxmadığımızı yoxlamaq üçün tam hüquqlu yollar yoxdur. Ona görə də ya onun ölçüsünü dəqiq bilirik, ya da onu dəyişəndə ​​saxlayaraq lazım olanda oxuyuruq.

Nümunələr

İndi burada massivlərlə işləməyin bəzi tipik nümunələri var
1. Massivi tərsinə çevirin.

#daxildir #daxildir //Bu makrodur. Koddakı SIZE 10u ilə əvəz olunacaq #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); imzasız i, j; // sayğaclar işarəsiz yarısı //massivin ortası unsigned tmp //müvəqqəti dəyişən yarım = SIZE / 2 //Bir sayğac soldan sağa, digəri isə sağdan sola (i = 0,); j = ÖLÇÜ - 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(); }

Budur sizə tanış olmayan dizayn

#10u ölçüsünü təyin edin

makro. Kod boyu preprosessor avtomatik olaraq SIZE-nin bütün hadisələrini 10u ilə əvəz edəcək.
2. İstifadəçi tərəfindən seçilmiş elementin silinməsi.

#daxildir #daxildir #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //counter int index; //istifadəçi tərəfindən daxil edilmiş indeks / /Çıxış 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(); }

Bu halda, təbii ki, element silinmir. Massiv əvvəlki kimi eyni ölçüdə qalır. Biz sadəcə olaraq silinən elementin üzərinə növbəti elementi yazırıq və SIZE-1 elementlərini çıxarırıq.
3. İstifadəçi dəyərləri massivə daxil edir. Bundan sonra, daxil etdiyi bütün fərqli dəyərləri çap edin.
İstifadəçiyə sonlu sayda element daxil etsin, deyək ki, 10. Onda əvvəlcədən məlum olur ki, istifadəçi hər dəfə bir nömrə daxil etdikdə, massivdən keçib yoxlayacağıq belə bir nömrənin daxil olub-olmaması.

#daxildir #daxildir #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //neçə fərqli rəqəm daxil edilib. Ən azı bir. int input; int wasntFound; //bayraqlayın daxil edilmiş nömrə tapılmadı //Birinci nömrəni daxil edin 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. İstifadəçi bir nömrə daxil edir - ölçmələrin sayı (2-dən 10-a qədər). Bundan sonra bütün ölçmələr daxil edilir. Proqram orta dəyəri, fərqi və səhvi göstərir.

#daxildir #daxildir #daxildir #define SIZE 20u void main() ( //Tələbə əmsalları iki ölçüdən başlayır const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float sum = .0f; float relError do (printf("Ölçülərin sayını daxil edin"); scanf("%u", &limit); if (limit > 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. Massiv qabarcıq sıralaması

#daxildir #daxildir #ÖLÇÜSÜ 10-u müəyyən edin #yanlış 0-u təyin edin #doğru təyin edin!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); işarəsiz i, j //Çıxış massivi; 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; bayraq = doğru; ) ) ) while(bayraq == doğru); //(i = 0; i.) üçün çeşidlənmiş massivi çıxarın< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Massivi qarışdırın. Bunun üçün alqoritmdən istifadə edək