ერთგანზომილებიანი მასივის აღწერა ქ. პროგრამირება C-ში: მონაცემთა მასივების გამოყენება C-ში. პოინტერები. პროგრესი პრობლემის გადაჭრაში

მასივი არის მონაცემთა სტრუქტურა, რომელიც წარმოდგენილია იმავე ტიპის უჯრედების ჯგუფად, გაერთიანებული ერთი სახელის ქვეშ. მასივები გამოიყენება იმავე ტიპის დიდი რაოდენობით მონაცემების დასამუშავებლად. მასივის სახელი არის მაჩვენებლები, ცოტა მოგვიანებით გეტყვით. მასივის ცალკეულ მონაცემთა უჯრედს მასივის ელემენტი ეწოდება. მასივის ელემენტები შეიძლება იყოს ნებისმიერი ტიპის მონაცემები. მასივებს შეიძლება ჰქონდეს ერთი ან რამდენიმე განზომილება. განზომილებების რაოდენობის მიხედვით, მასივები იყოფა ერთგანზომილებიან მასივებად, ორგანზომილებიან მასივებად, სამგანზომილებიან მასივებად და ასე შემდეგ n-განზომილებიან მასივამდე. პროგრამირებაში ყველაზე ხშირად გამოიყენება ერთგანზომილებიანი და ორგანზომილებიანი მასივები, ამიტომ განვიხილავთ მხოლოდ ამ მასივებს.

ერთგანზომილებიანი მასივები C++-ში

ერთგანზომილებიანი მასივი არის მასივი ერთი პარამეტრით, რომელიც ახასიათებს ერთგანზომილებიანი მასივის ელემენტების რაოდენობას. სინამდვილეში, ერთგანზომილებიანი მასივი არის მასივი, რომელსაც შეიძლება ჰქონდეს მხოლოდ ერთი მწკრივი და n სვეტის რაოდენობა. ერთგანზომილებიანი მასივის სვეტები მასივის ელემენტებია. სურათი 1 გვიჩვენებს მთელი რიცხვის ერთგანზომილებიანი მასივის სტრუქტურას ა. ამ მასივის ზომაა 16 უჯრედი.

სურათი 1 - მასივები C++-ში

გაითვალისწინეთ, რომ ერთგანზომილებიანი მასივის მაქსიმალური ინდექსი აარის 15, მაგრამ მასივის ზომაა 16 უჯრედი, რადგან მასივის უჯრედების ნუმერაცია ყოველთვის იწყება 0-დან. უჯრედის ინდექსი არის არაუარყოფითი მთელი რიცხვი, რომლითაც შეგიძლიათ შეხვიდეთ მასივის თითოეულ უჯრედზე და შეასრულოთ მასზე ნებისმიერი მოქმედება ( უჯრედი).

//სინტაქსი C++-ში ერთგანზომილებიანი მასივის გამოცხადებისთვის: /*მონაცემთა ტიპი*/ /*ერთგანზომილებიანი მასივის სახელი*/; //სურათ 1-ზე ნაჩვენები ერთგანზომილებიანი მასივის გამოცხადების მაგალითი: int a;

სადაც, int არის მთელი რიცხვი;

A არის ერთგანზომილებიანი მასივის სახელი;
16 არის ერთგანზომილებიანი მასივის ზომა, 16 უჯრედი.

მასივის სახელის შემდეგ ყოველთვის არის კვადრატული ფრჩხილები, რომლებშიც მითითებულია ერთგანზომილებიანი მასივის ზომა, რაც განასხვავებს მასივს ყველა სხვა ცვლადისგან.

//ერთგანზომილებიანი მასივების გამოცხადების სხვა გზა int mas, a;

ორი ერთგანზომილებიანი მასივი mas და a გამოცხადებულია ზომით 10 და 16, შესაბამისად. უფრო მეტიც, დეკლარაციის ამ მეთოდში ყველა მასივს ექნება მონაცემთა ერთი და იგივე ტიპი, ჩვენს შემთხვევაში - int.

// მასივების ინიციალიზაცია შესაძლებელია გამოცხადებისას: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // ერთგანზომილებიანი მასივის ინიციალიზაცია

ერთგანზომილებიანი მასივის ინიციალიზაცია ხორციელდება ხვეული ბრეკეტებში ნიშნის შემდეგ უდრის, მასივის თითოეული ელემენტი გამოყოფილია წინასაგან მძიმით.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // მასივის ინიციალიზაცია მისი ზომის განსაზღვრის გარეშე.

ამ შემთხვევაში შემდგენელი თავად განსაზღვრავს ერთგანზომილებიანი მასივის ზომას. მასივის ზომა შეიძლება გამოტოვოთ მხოლოდ მასივის ინიციალიზაციისას, მასივის ზომა უნდა იყოს მითითებული. მოდით შევიმუშავოთ მარტივი პროგრამა ერთგანზომილებიანი მასივის დასამუშავებლად.

// array.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #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; }

// კოდი Code::Blocks

// Dev-C++ კოდი

// array.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #შეიცავს სახელთა სივრცის გამოყენებით std; int main(int argc, char* argv) (cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

IN 10-11 სტრიქონებიგამოცხადებულია და ინიციალიზებულია მთელი რიცხვი ერთგანზომილებიანი მასივი სახელად array1, რომლის ზომაა 16 უჯრედი, ანუ ასეთ მასივს შეუძლია შეინახოს 16 ნომერი. მასივის ნებისმიერი დამუშავება შესაძლებელია მხოლოდ მარყუჟებთან ერთად. რომელი მარყუჟი აირჩიოს მასივის დასამუშავებლად, თქვენი გადასაწყვეტია. მაგრამ ის საუკეთესოდ შეეფერება ამ ამოცანის შესრულებას. ჩვენ გამოვიყენებთ მრიცხველის ცვლადის მრიცხველს ერთგანზომილებიანი მასივის1 ელემენტებზე წვდომისთვის. for მარყუჟის გაგრძელების პირობა შეიცავს მკაცრ უთანასწორობის ნიშანს, ვინაიდან არ არის მეთექვსმეტე ინდექსი ერთგანზომილებიან მასივში1. და რადგან უჯრედების ნუმერაცია იწყება ნულიდან, მასივი არის 16 ელემენტი for loop-ის სხეულში, cout ოპერატორი ბეჭდავს ერთგანზომილებიანი მასივის ელემენტებს (იხ. სურათი 2).

Obrabotka massiva ინდექსებს ელემენტს massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 კლავიშის გასაგრძელებლად. . .

სურათი 2 - მასივები C++-ში

შევიმუშაოთ სხვა პროგრამა C++-ში ერთგანზომილებიანი მასივის დასამუშავებლად. პროგრამამ თანმიმდევრულად უნდა წაიკითხოს კლავიატურიდან ათი შეყვანილი რიცხვი. ყველა შეყვანილი რიცხვი შეჯამებულია და შედეგი გამოჩნდება ეკრანზე.

// array_sum.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #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; }

// კოდი Code::Blocks

// Dev-C++ კოდი

// array_sum.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #შეიცავს სახელთა სივრცის გამოყენებით std; int main(int argc, char* argv) ( int array1; // გამოაცხადეთ მთელი მასივი cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> მასივი1; // წაიკითხეთ კლავიატურიდან შეყვანილი რიცხვები<< "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; }

მასივის დამუშავებამდე ის უნდა იყოს დეკლარირებული და ერთგანზომილებიანი მასივის ზომაა 10, რადგან ეს გათვალისწინებულია ამოცანის პირობით. ჯამის ცვლადში დავაგროვებთ ერთგანზომილებიანი მასივის ელემენტების ჯამს. პირველი for loop ავსებს გამოცხადებულ ერთგანზომილებიან მასივს კლავიატურიდან შეყვანილი რიცხვებით, სტრიქონები 12 - 13. მრიცხველის ცვლადი გამოიყენება ერთგანზომილებიანი მასივის1 ელემენტების თანმიმდევრული წვდომისთვის, ინდექსი 0-დან და მე-9 ჩათვლით. მეორე for loop აჩვენებს მასივის ელემენტებს, სტრიქონები 15 - 16. მესამე for loop თანმიმდევრულად კითხულობს ერთგანზომილებიანი მასივის ელემენტებს და აჯამებს მათ, ჯამი გროვდება ჯამის ცვლადში. 17-18 სტრიქონები. პროგრამის შედეგი ნაჩვენებია სურათზე 3.

შეიყვანეთ elementi massiva: 0 1 2 3 4 5 6 7 8 9 მასივი1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 გასაგრძელებლად დააჭირეთ ნებისმიერ ღილაკს. . .

სურათი 3 - მასივები C++-ში

ჯერ 10-ვე რიცხვი თანმიმდევრულად შეიტანეს, რის შემდეგაც გამოისახა ერთგანზომილებიანი მასივი და დაიბეჭდა მასივის რიცხვების ჯამი.

ორგანზომილებიანი მასივები C++-ში

ამ მომენტამდე ჩვენ განვიხილეთ ერთგანზომილებიანი მასივები, რომლებიც ყოველთვის არ შეიძლება შემოიფარგლოს. დავუშვათ, რომ საჭიროა ცხრილიდან გარკვეული მონაცემების დამუშავება. ცხრილს აქვს ორი მახასიათებელი: სტრიქონების რაოდენობა და სვეტების რაოდენობა. ასევე ორგანზომილებიან მასივში, გარდა მასივის ელემენტების რაოდენობისა, არის ისეთი მახასიათებლები, როგორიცაა სტრიქონების რაოდენობა და ორგანზომილებიანი მასივის სვეტების რაოდენობა. ანუ, ვიზუალურად, ორგანზომილებიანი მასივი არის ჩვეულებრივი ცხრილი, სტრიქონებითა და სვეტებით. სინამდვილეში, ორგანზომილებიანი მასივი არის ერთგანზომილებიანი მასივის ერთგანზომილებიანი მასივი. ორგანზომილებიანი მასივის სტრუქტურა, სახელად a, ზომით m n-ზე ნაჩვენებია ქვემოთ (იხ. სურათი 4).

სურათი 4 - მასივები C++-ში

სადაც, m არის ორგანზომილებიანი მასივის რიგების რაოდენობა;
n არის ორგანზომილებიანი მასივის სვეტების რაოდენობა;
m * n — მასივის ელემენტების რაოდენობა.

// ორგანზომილებიანი მასივის გამოცხადების სინტაქსი /*მონაცემთა ტიპი*/ /*მასივის სახელი*/;

ორგანზომილებიანი მასივის გამოცხადებისას, ისევე როგორც ერთგანზომილებიანი მასივის გამოცხადებისას, პირველ რიგში, თქვენ უნდა მიუთითოთ:

• მონაცემთა ტიპი;
• მასივის სახელი.

ამის შემდეგ, პირველი კვადრატული ფრჩხილები მიუთითებს ორგანზომილებიანი მასივის რიგების რაოდენობაზე, ხოლო მეორე კვადრატულ ფრჩხილებში მითითებულია ორგანზომილებიანი მასივის სვეტების რაოდენობა. ორგანზომილებიანი მასივი ვიზუალურად გამოირჩევა ერთგანზომილებიანი მასივისაგან მეორე წყვილი კვადრატული ფრჩხილებით. მოდით შევხედოთ ორგანზომილებიანი მასივის გამოცხადების მაგალითს. ვთქვათ, ჩვენ უნდა გამოვაცხადოთ ორგანზომილებიანი მასივი, რომლის ელემენტების რაოდენობა უდრის 15-ს. ამ შემთხვევაში, ორგანზომილებიან მასივს შეიძლება ჰქონდეს სამი მწკრივი და ხუთი სვეტი ან ხუთი მწკრივი და სამი სვეტი.

// ორგანზომილებიანი მასივის დეკლარაციის მაგალითი: int a;

• a არის მთელი მასივის სახელი
• პირველ კვადრატულ ფრჩხილებში რიცხვი მიუთითებს ორგანზომილებიანი მასივის რიგების რაოდენობაზე, ამ შემთხვევაში არის 5;
• მეორე კვადრატულ ფრჩხილებში რიცხვი მიუთითებს ორგანზომილებიანი მასივის სვეტების რაოდენობაზე, ამ შემთხვევაში არის 3.

// ორგანზომილებიანი მასივის ინიციალიზაცია: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

ამ მასივს აქვს 5 მწკრივი, 3 სვეტი. მინიჭების ნიშნის შემდეგ მოთავსებულია ზოგადი ხვეული ფრჩხილები, რომელთა შიგნით მოთავსებულია იმდენი წყვილი ხვეული ფრჩხილები, რამდენიც უნდა იყოს ხაზები ორგანზომილებიან მასივში და ეს ფრჩხილები გამოყოფილია მძიმეებით. ხვეული ბრეკეტების თითოეულ წყვილში ჩაწერეთ ორგანზომილებიანი მასივის ელემენტები, რომლებიც გამოყოფილია მძიმეებით. ყველა ხვეულ ბრეკეტში ელემენტების რაოდენობა ერთნაირი უნდა იყოს. ვინაიდან მასივში ხუთი ხაზია, ასევე არის ხუთი შიდა წყვილი ფრჩხილები. შიდა ფრჩხილებში სამი ელემენტია ჩაწერილი, რადგან სვეტების რაოდენობა სამია. გრაფიკულად, ჩვენი მასივი ჰგავს ორგანზომილებიან ცხრილს (იხ. სურათი 5).

სურათი 5 - მასივები C++-ში

ორგანზომილებიანი მასივის თითოეულ უჯრედში ამნიშვნელობა ნაჩვენებია, ამ უჯრედის მისამართი ნაჩვენებია ქვედა მარჯვენა კუთხეში. ორგანზომილებიანი მასივის უჯრედის მისამართი არის მასივის სახელი, მწკრივის ნომერი და სვეტის ნომერი.

მოდით შევიმუშავოთ მარტივი პროგრამა ორგანზომილებიანი მასივის დასამუშავებლად, სახელწოდებით "ლაბირინთი". ლაბირინთი უნდა აშენდეს ორგანზომილებიანი მასივის საფუძველზე. ჩვენ ავირჩევთ ლაბირინთის ზომას ჩვენი შეხედულებისამებრ.

// array2.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); კოუტ<< static_cast(176); ) სხვა კოუტ<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// კოდი Code::Blocks

// Dev-C++ კოდი

// array2.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #შეიცავს სახელთა სივრცის გამოყენებით std; int main(int argc, char* argv) ( // 1-პირობითად "ლაბირინთის კედლები" // 2-"სწორი გზა, გასვლა ლაბირინთიდან" // 0-"ცრუ გზა" int mas = (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // ორგანზომილებიანი მასივის ინიციალიზაცია ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1, (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // ორი მარყუჟი - შიდა და გარე, წვდომა მასივის თითოეულ ელემენტზე (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); კოუტ<< static_cast(176); ) სხვა კოუტ<< " "; // вывести два пробела cout << endl; } return 0; }

სწორი და მცდარი ბილიკები შეიძლება აღინიშნოს ერთი და იგივე რიცხვით, მაგალითად, ნულით, მაგრამ სიცხადისთვის, სწორი გზა აღინიშნება ნომრით 2. მასივის ინიციალიზაცია მოხდა ხელით, მხოლოდ პროგრამის გასამარტივებლად. ვინაიდან პროგრამა ამუშავებს ორგანზომილებიან მასივს, საჭიროა ორი მარყუჟი ორგანზომილებიანი მასივის ელემენტებს შორის გადასართავად. პირველი for loop გადართავს ორგანზომილებიანი მასივის რიგებს შორის. ვინაიდან ორგანზომილებიან მასივში არის 33 მწკრივი, მრიცხველის ცვლადი i იზრდება 0-დან 33-მდე, ხაზი 46. პირველი მარყუჟის შიგნით არის for loop, რომელიც მოძრაობს ორგანზომილებიანი მასივის მწკრივის ელემენტებში. მეორე for მარყუჟის სხეულში შესრულებულია მონაცემთა ტიპის უნიალური კონვერტაციის ოპერაცია შიგნით - static_cast<>() , რომელიც ბეჭდავს სიმბოლოს ნომერს 176. მონაცემთა ტიპის კონვერტაციის ოპერაცია დუბლირებულია ლაბირინთის სიგანის გასაზრდელად. პროგრამის შედეგი (იხ. სურათი 6).

სურათი 6 - მასივები C++-ში

ვთქვათ, ჩვენ გვჭირდება მუშაობა იმავე ტიპის დიდი რაოდენობით მონაცემებთან. მაგალითად, ჩვენ გვაქვს ქანქარის კოორდინატების ათასი გაზომვა გარკვეული დროის საფეხურით. 1000 ცვლადის შექმნა ყველა მნიშვნელობის შესანახად ძალიან... რთულია. ამის ნაცვლად, ბევრი ერთი და იგივე ტიპის მონაცემი შეიძლება გაერთიანდეს ერთი სახელით და თითოეულ კონკრეტულ ელემენტზე წვდომა შესაძლებელია მისი სერიული ნომრით.
მასივი C-ში განისაზღვრება შემდეგნაირად
<тип> <имя массива>[<размер>];
Მაგალითად,
int a;
ჩვენ მივიღებთ მასივს სახელად ა, რომელიც შეიცავს ტიპის ას ელემენტს ინტ. როგორც ცვლადების შემთხვევაში, მასივი შეიცავს ნაგავს.
პირველ ელემენტზე წვდომის მისაღებად ჩაწერეთ მისი ნომერი (ინდექსი) კვადრატულ ფრჩხილებში. Მაგალითად

#შეიცავს #შეიცავს void main() ( int a; a = 10; a = 333; a = 234; printf ("%d %d %d", a, a, a); getch(); )

პირველ ელემენტს აქვს ინდექსის ნომერი 0. მნიშვნელოვანია იმის გაგება, თუ რატომ. შემდეგში ჩვენ წარმოვადგენთ კომპიუტერის მეხსიერებას ფირის სახით. მასივის სახელი არის მეხსიერების მისამართის მაჩვენებელი, სადაც მასივის ელემენტები მდებარეობს.

ბრინჯი. 1 მასივი ინახავს პირველი ელემენტის მისამართს. i ელემენტის ინდექსი არის i*sizeof(type) ბაიტების ცვლა თავიდანვე

მასივის ინდექსი მიუთითებს რამდენი ბაიტი უნდა გადაიტანოს მასივის დასაწყისიდან სასურველ ელემენტზე წვდომისთვის. მაგალითად, თუ მასივი ააქვს ტიპი ინტ, მაშინ A ნიშნავს, რომ ჩვენ გადავიტანეთ 10*sizeof(int) ბაიტი საწყისთან შედარებით. პირველი ელემენტი არის დასაწყისში და აქვს ოფსეტი 0*sizeof(int) .
C-ში მასივი არ ინახავს მის ზომას და არ ამოწმებს მასივის ინდექსს სისწორისთვის. ეს ნიშნავს, რომ თქვენ შეგიძლიათ გახვიდეთ მასივის გარეთ და შეხვიდეთ მეხსიერებაზე, რომელიც უფრო შორს არის მასივის ბოლო ელემენტზე (ან უფრო ახლოს).

მასივის საწყისი ინიციალიზაცია.

მოდით დავწეროთ მარტივი პროგრამა. შევქმნათ მასივი და შემდეგ ვიპოვოთ მისი მაქსიმალური ელემენტი.

#შეიცავს #შეიცავს void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); ხელმოუწერელი i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

მოდით შევხედოთ მაგალითს. ჩვენ ჯერ ვქმნით მასივს და ინიციალიზაციას ვაკეთებთ შექმნისთანავე. ამის შემდეგ მაქსიმალურ ნაპოვნი ელემენტს ვანიჭებთ მასივის პირველი ელემენტის მნიშვნელობას.

მაქს = a;

შემდეგ ჩვენ გავდივართ მასივში. ვინაიდან ჩვენ უკვე გადავხედეთ პირველ ელემენტს (მას აქვს ინდექსი 1), აზრი არ აქვს მის ხელახლა ყურებას.
იგივე მაგალითი, მხოლოდ ახლა მომხმარებელი შეაქვს მნიშვნელობებს

#შეიცავს #შეიცავს void main() ( int a; ხელმოუწერელი i; int max; printf ("შეიყვანეთ 10 ნომერი\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("max ელემენტია %d", max); getch(); )

თუ ინიციალიზაციის დროს მითითებულია მასივის ზომაზე ნაკლები მნიშვნელობა, დარჩენილი ელემენტები ივსება ნულებით.

#შეიცავს #შეიცავს void main() ( int a = (1,2,3); ხელმოუწერელი i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

თუ მთელი მასივი ნულებით უნდა შეავსოთ, მაშინ დაწერეთ

Int a = (0);

თქვენ არ გჭირდებათ ცალსახად მიუთითოთ მასივის ზომა, მაგალითად

Int a = (1, 2, 3);

მასივს ექნება 3 ზომა

მასივის ზომა

მასივს C-ში უნდა ჰქონდეს მუდმივი ზომა. ეს ნიშნავს, რომ შეუძლებელია, მაგალითად, მომხმარებელს სთხოვო ზომა და შემდეგ დააყენო ეს ზომა მასივზე.

Printf("შეიყვანეთ მასივის სიგრძე"); scanf("%d", &სიგრძე); (float x;)

დინამიური მასივების შექმნა შემდგომში იქნება განხილული პოინტერებთან და მეხსიერებასთან მუშაობისას.
ზოგიერთ შემთხვევაში, შეგიძლიათ გაიგოთ მასივის ზომა ფუნქციის გამოყენებით ზომა.

#შეიცავს #შეიცავს void main() ( int A; //sizeof აბრუნებს მთელი მასივის ზომას ბაიტებში // ელემენტების რაოდენობის დასადგენად, //გაყოფა მასივის ზომა მისი ელემენტის ზომაზე int size = sizeof(A) / sizeof(intf("მასივის ზომა უდრის %d", ზომა);

მაგრამ ეს ნაკლებად სავარაუდოა, რომ სასარგებლო იყოს. მასივის, როგორც არგუმენტის ფუნქციაზე გადაცემისას, გადაეცემა მაჩვენებელი, ამიტომ მასივის ზომა ცნობილი არ იქნება.
სტატიკური მასივები სასარგებლოა, როდესაც ელემენტების რაოდენობა წინასწარ არის ცნობილი. ისინი უზრუნველყოფენ ელემენტებზე სწრაფ, მაგრამ არასაიმედო წვდომას.

მასივის გადინება

ვიმედოვნებთ, რომ თქვენ გაქვთ ეს კოდი

Int A; int i; ამისთვის (i=0; i<=10; i++) { A[i] = 1; }

აქ არის მარყუჟი ამისთვისმითითებულია შეცდომით. შემდგენელების ზოგიერთ ძველ ვერსიაში, ეს კოდი ჩქეფდა. საქმე იმაშია, რომ ცვლადი მემდებარეობდა კომპილაციის დროს მასივის შემდეგ ა. როდესაც მასივი გასცდა საზღვრებს, მრიცხველი დაყენდა 1-ზე.
მასივები სახიფათოა, ვინაიდან ინდექსთან არასწორმა მუშაობამ შეიძლება გამოიწვიოს მეხსიერების თვითნებურ ნაწილზე წვდომა (თეორიულად. თანამედროვე შემდგენელები თავად ზრუნავენ, რომ თქვენ არ ჩაუღრმავდეთ სხვის მეხსიერებას).
თუ თქვენ მუშაობთ მასივებთან, უნდა უზრუნველყოთ, რომ მრიცხველი არ აღემატებოდეს მასივის ზომას და არ იყოს უარყოფითი. ამისათვის, მინიმუმ,

• 1. გამოიყენეთ size_t ტიპი ინდექსაციისთვის. ის დაგიცავთ უარყოფითი მნიშვნელობებისგან და ყოველთვის საკმარისი იქნება ნებისმიერი ზომის მასივისთვის.
• 2. გახსოვდეთ, რომ მასივი იწყება ნულიდან.
• 3. მასივის ბოლო ელემენტს აქვს ინდექსი (მასივის ზომა არის 1)

არ არსებობს სრულფასოვანი გზები იმის შესამოწმებლად, გადავედით თუ არა მასივის საზღვრებს. ამიტომ, ან ზუსტად ვიცით მისი ზომა, ან ვინახავთ ცვლადში და ვკითხულობთ საჭიროების შემთხვევაში.

მაგალითები

ახლა აქ მოცემულია მასივებით მუშაობის რამდენიმე ტიპიური მაგალითი
1. შეაბრუნეთ მასივი.

#შეიცავს #შეიცავს //ეს არის მაკრო. SIZE კოდში შეიცვლება 10u-ით #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); ხელმოუწერელი i, j; // მრიცხველის დაუწერელი ნახევარი //მრიცხველის შუალედური მნიშვნელობების გაცვლისთვის ნახევარი = SIZE //ერთი მრიცხველი მიდის მარცხნიდან მარჯვნივ, მეორე - მარცხნივ; 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(); }

აქ არის თქვენთვის უცნობი დიზაინი

#define SIZE 10u

მაკრო. მთელი კოდის განმავლობაში, წინასწარი პროცესორი ავტომატურად ჩაანაცვლებს SIZE-ის ყველა შემთხვევას 10u-ით.
2. მომხმარებლის მიერ არჩეული ელემენტის წაშლა.

#შეიცავს #შეიცავს #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); ხელმოუწერელი i; //counter int index; //ინდექსი შეყვანილია მომხმარებლის მიერ / /გამომავალი მასივი (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 && ინდექსი< 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(); }

ამ შემთხვევაში, რა თქმა უნდა, ელემენტი არ წაიშლება. მასივი იგივე ზომის რჩება, როგორც ადრე. ჩვენ უბრალოდ გადავაწერთ წაშლილ ელემენტს და გამოვაქვთ SIZE-1 ელემენტი.
3. მომხმარებელი შეაქვს მნიშვნელობებს მასივში. ამის შემდეგ, ამობეჭდეთ მის მიერ შეყვანილი ყველა განსხვავებული მნიშვნელობა.
ნება მიეცით მომხმარებელს შეიყვანოს ელემენტების სასრული რაოდენობა, ვთქვათ 10. მაშინ წინასწარ ცნობილია, რომ სულ არ იქნება 10-ზე მეტი სხვადასხვა მნიშვნელობა ყოველ ჯერზე, როცა მომხმარებელი შეიყვანს რიცხვს, ჩვენ გადავხედავთ მასივს იყო თუ არა ასეთი ნომერი შეყვანილი.

#შეიცავს #შეიცავს #define SIZE 10u void main() ( int A = (0); ხელმოუწერელი i, j; int მრიცხველი = 1; //რამდენი განსხვავებული რიცხვია შეყვანილი. მინიმუმ ერთი. int შეყვანა; int wasntFound; //მონიშნეთ, რომ შეყვანილი ნომერი ვერ მოიძებნა //შეიყვანეთ პირველი ნომერი. ჯერ არ არის ნაპოვნი 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. მომხმარებელი შეაქვს რიცხვს - გაზომვების რაოდენობას (2-დან 10-მდე). ამის შემდეგ, შედის ყველა გაზომვა. პროგრამა აჩვენებს საშუალო მნიშვნელობას, განსხვავებას და შეცდომას.

#შეიცავს #შეიცავს #შეიცავს #define SIZE 20u void main() ( //სტუდენტის კოეფიციენტები იწყება ორი განზომილებიდან 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; float sum = .0f float relError do (printf("შეიყვანეთ გაზომვების რაოდენობა");< 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. მასივის ბუშტების დალაგება

#შეიცავს #შეიცავს #define SIZE 10 #define false 0 #define true !false void main() ( float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0 f float tmp unsigned i, j char flag for (i = 0; i.);< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >ა) ( tmp = a[i]; a[i] = a; a = tmp; flag = true; ) ) ) while(flag == true); //დახარისხებული მასივის გამოტანა (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. შეურიეთ მასივი. ამისათვის გამოვიყენოთ ალგორითმი

რა არის მასივები C-ში?

როგორ გამოვაცხადოთ მასივები C-ში?

როგორ მოვახდინოთ მასივების ინიციალიზაცია C-ში?

მასივები C-ში დუმებისთვის.

მასივები C-ში

მასივი C-ში არის იმავე ტიპის ელემენტების კრებული, რომელთა წვდომა შესაძლებელია ინდექსით. C-ში მასივების ელემენტები ერთმანეთის მიყოლებით განლაგებულია კომპიუტერის მეხსიერებაში.

C-ში მასივის შექმნისა და შევსების მარტივი მაგალითი:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); დაბრუნება 0 ;)

ჩვენ ვიღებთ:

მაგალითში ჩვენ ვაცხადებთ მასივს, რომელიც შეიცავს int ტიპის ელემენტებს:

აქ მასივის სახელია nArr, მასივის ელემენტების რაოდენობა სამია, მასივის ელემენტის ტიპი არის int.

მასივი არის ელემენტების კოლექცია. მასივის თითოეული ელემენტი შეიძლება მოიხსენიებოდეს მისი ნომრით. რიცხვს ჩვეულებრივ ინდექსს უწოდებენ. მასივის ელემენტები დანომრილია ნულიდან. მოდით მივცეთ მნიშვნელობა მასივის პირველ ელემენტს და პირველ ელემენტს აქვს ინდექსი ნული:

მოდით მივცეთ მნიშვნელობა მასივის მეორე ელემენტს, ხოლო მეორე ელემენტს აქვს ინდექსი ერთი:

მოდით მივცეთ მნიშვნელობა მასივის მესამე ელემენტს, ხოლო მესამე ელემენტს აქვს ინდექსი ორი:

როდესაც ეკრანზე გამოვხატავთ მასივის ელემენტებს, ვიღებთ მათ მნიშვნელობებს. Ამგვარად:

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

მასივის ელემენტის მისაღებად, თქვენ უნდა მიუთითოთ მასივის სახელი და ელემენტის ინდექსი:

ეს არის მასივის პირველი ელემენტი, რადგან პირველ ელემენტს აქვს ინდექსი ნული.

ცვლადს int a მივანიჭებთ მასივის მესამე ელემენტის მნიშვნელობას:

მასივის მესამე ელემენტის ინდექსი უდრის ორს, ვინაიდან ინდექსები ითვლება ნულიდან.

ახლა C-ში მასივების გამოცხადების ზოგადი წესი: მასივის გამოცხადებისას უნდა მიუთითოთ მისი სახელი, ელემენტების ტიპი და ელემენტების რაოდენობა. ელემენტების რაოდენობა ნატურალური რიცხვია, ე.ი. მთლიანობაში დადებითია. ნული არ შეიძლება იყოს ელემენტების რაოდენობა. თქვენ არ შეგიძლიათ მიუთითოთ მასივის ელემენტების ცვლადი რაოდენობა. აქ არის მასივის დეკლარაციების მაგალითები C-ში:

int nArr; // მასივი გამოცხადდა ასი მთელი რიცხვის შესანახად;
float fArr; // დეკლარირებულია მასივი, რომელიც შექმნილია 5 float ნომრის შესანახად;
char cArr; // მასივი გამოცხადდა ორი სიმბოლოს შესანახად;

შეცდომა იქნებოდა მასივის გამოცხადება ელემენტების ცვლადი რაოდენობით:

Int varElem;
int nArr; // შეცდომა! ელემენტების რაოდენობა არ შეიძლება დაყენდეს ცვლადზე;

მაგრამ თქვენ შეგიძლიათ დააყენოთ ელემენტების რაოდენობა მუდმივი მნიშვნელობით: ან პირდაპირი დადებითი მთელი რიცხვი 1, 2, 3... ან მუდმივი:

Const int arrayLength = 3;
int nArr;

მასივის C-ში გამოცხადებისას, შეგიძლიათ დაუყოვნებლივ მოაწყოთ იგი:

int nMassiv = (1, 2, 3);

თქვენ შეგიძლიათ გამოტოვოთ მასივის ელემენტების რაოდენობა კვადრატულ ფრჩხილებში, თუ მასივის ყველა ელემენტი ინიციალიზებულია:

int nMassiv = (1, 2, 3);

ელემენტების რაოდენობა ამ შემთხვევაში ავტომატურად განისაზღვრება.

თქვენ შეგიძლიათ განსაზღვროთ მასივის ელემენტების მხოლოდ ნაწილი მისი გამოცხადებისას:

int nMassiv = (1, 2);

ამ მაგალითში მასივის პირველი ორი ელემენტი ინიციალიზებულია, მაგრამ მესამე განუსაზღვრელია.

სიმბოლოთა მასივის მაგალითი:

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

მასივის გამოცხადებისას, თქვენ არ შეგიძლიათ მიუთითოთ ცვლადის ელემენტების რაოდენობა. მაგრამ თქვენ შეგიძლიათ გამოიყენოთ ცვლადები მასივის ელემენტებზე წვდომისას:

Int ind = 0;
char cr = cArr;

იგი გამოიყენება მარყუჟებთან მუშაობისას. მაგალითი:

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

მაგალითში პირველ ციკლში მასივს ვავსებთ int ტიპის ელემენტებით, ხოლო მეორე ციკლში ამ ელემენტებს ეკრანზე ვაჩვენებთ.

ბოლო განახლება: 17.09.2017

მასივი წარმოადგენს იმავე ტიპის მონაცემთა ერთობლიობას. მასივის ოფიციალური განმარტება შემდეგია:

Variable_type array_name [მასივის_სიგრძე]

ცვლადის ტიპის შემდეგ მოდის მასივის სახელი, შემდეგ კი მისი ზომა კვადრატულ ფრჩხილებში. მაგალითად, განვსაზღვროთ 4 რიცხვის მასივი:

Int ნომრები;

ამ მასივს აქვს ოთხი რიცხვი, მაგრამ ყველა ამ რიცხვს აქვს განუსაზღვრელი მნიშვნელობა. თუმცა, ჩვენ შეგვიძლია შევასრულოთ ინიციალიზაცია და ამ რიცხვებს მივაკუთვნოთ საწყისი მნიშვნელობები ხვეული ბრეკეტების საშუალებით:

Int რიცხვები = (1,2,3,4);

ხვეული ბრეკეტების მნიშვნელობებს ასევე უწოდებენ ინიციალიზაციას. თუ მასივში ელემენტების რაოდენობაზე ნაკლები ინიციალიზატორია, მაშინ პირველი ელემენტებისთვის გამოიყენება ინიციალიზატორები. თუ მასივში უფრო მეტი ინიციალიზატორია, ვიდრე ელემენტი, მაშინ შედგენა მოხდება შეცდომა:

Int რიცხვები = (1, 2, 3, 4, 5, 6);

აქ მასივს აქვს 4 ზომა, მაგრამ მას გადაეცემა 6 მნიშვნელობა.

თუ მასივის ზომა ცალსახად არ არის მითითებული, ის გამოითვლება ინიციალატორების რაოდენობის მიხედვით:

Int რიცხვები = (1, 2, 3, 4, 5, 6);

ამ შემთხვევაში მასივს აქვს 6 ელემენტი.

სიმბოლოთა მასივების ინიციალიზაციას აქვს თავისი თავისებურებები. ჩვენ შეგვიძლია გადავიტანოთ როგორც ინიციალატორის ნაკრები, ასევე სტრიქონი სიმბოლოთა მასივში:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "სამყარო";

უფრო მეტიც, მეორე შემთხვევაში, s2 მასივს ექნება არა 5 ელემენტი, არამედ 6, ვინაიდან სტრიქონით ინიციალიზაციისას სიმბოლოთა მასივს ავტომატურად ემატება ნულოვანი სიმბოლო „\0“.

ამ შემთხვევაში, ერთი მასივის მეორე მასივის მინიჭება დაუშვებელია:

Int nums1 = (1,2,3,4,5); int nums2 = nums1; // შეცდომა nums2 = nums1; // შეცდომა

მასივის განსაზღვრის შემდეგ, ჩვენ შეგვიძლია მივიღოთ მისი ცალკეული ელემენტები ინდექსით. ინდექსები იწყება ნულიდან, ამიტომ პირველ ელემენტზე წვდომისთვის უნდა გამოვიყენოთ ინდექსი 0. ელემენტის ინდექსის მიხედვით წვდომით შეგვიძლია მივიღოთ მისი მნიშვნელობა ან შევცვალოთ:

#შეიცავს int main() ( int ნომრები = (1,2,3,4); int first_number = ნომრები; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

მასივის ელემენტების რაოდენობა ასევე შეიძლება განისაზღვროს მუდმივის საშუალებით:

Const int n = 4; int რიცხვები[n] = (1,2,3,4);

გამეორება მასივებზე

მარყუჟების გამოყენებით, შეგიძლიათ გაიმეოროთ მთელი მასივი და შეხვიდეთ მის ელემენტებზე ინდექსების საშუალებით:

#შეიცავს int main() ( int ნომრები = (1,2,3,4); int ზომა = sizeof(რიცხვები)/sizeof(რიცხვები); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

მასივის გადასატანად, ჯერ უნდა იპოვოთ მასივის სიგრძე. სიგრძის საპოვნელად გამოიყენება ოპერატორი sizeof. არსებითად, მასივის სიგრძე უდრის მისი ელემენტების მთლიან სიგრძეს. ყველა ელემენტი წარმოადგენს ერთნაირ ტიპს და იკავებს იგივე ზომას მეხსიერებაში. ამიტომ, გამოსახულების sizeof(numbers) გამოყენებით ვპოულობთ მთელი მასივის სიგრძეს ბაიტებში, ხოლო გამოსახულების sizeof(numbers) გამოყენებით ვპოულობთ ერთი ელემენტის სიგრძეს ბაიტებში. ორი მნიშვნელობის გაყოფით, შეგიძლიათ მიიღოთ ელემენტების რაოდენობა მასივში. და შემდეგ, for loop-ის გამოყენებით, ჩვენ ვიმეორებთ ყველა ელემენტს, სანამ მრიცხველი i არ გახდება მასივის სიგრძის ტოლი. შედეგად, მასივის ყველა ელემენტი გამოჩნდება კონსოლზე:

მაგრამ ასევე არსებობს for loop-ის სხვა ფორმაც, რომელიც შექმნილია სპეციალურად კოლექციებთან მუშაობისთვის, მასივების ჩათვლით. ამ ფორმას აქვს შემდეგი ოფიციალური განმარტება:

For(ცვლადი ტიპი: კოლექცია) (ინსტრუქციები; )

ჩვენ ვიყენებთ ამ ფორმას მასივის მეშვეობით გამეორებისთვის:

#შეიცავს int main() ( int ნომრები = (1,2,3,4); for(int ნომერი: ნომრები) std::cout<< number << std::endl; return 0; }

მასივის მეშვეობით გამეორებისას, ყოველი გამეორებული ელემენტი განთავსდება რიცხვის ცვლადში, რომლის მნიშვნელობა იბეჭდება კონსოლზე მარყუჟის სახით.

თუ ჩვენ არ ვიცით მასივის ობიექტების ტიპი, შეგვიძლია გამოვიყენოთ ავტომატური სპეციფიკატორი ტიპის დასადგენად:

For(ავტო ნომერი: ნომრები) std::cout<< number << std::endl;

მრავალგანზომილებიანი მასივები

C++-ში ერთგანზომილებიანი მასივების გარდა, არის მრავალგანზომილებიანი. ასეთი მასივების ელემენტები თავად არიან მასივები, რომლებშიც ელემენტები ასევე შეიძლება იყოს მასივები. მაგალითად, განვსაზღვროთ რიცხვების ორგანზომილებიანი მასივი:

Int ნომრები;

ასეთი მასივი შედგება სამი ელემენტისგან, თითოეული ელემენტი წარმოადგენს ორი ელემენტის მასივს. მოდით დავაწყოთ მასივი ასე:

Int რიცხვები = ( (1, 2), (4, 5), (7, 8) );

ჩადგმული ხვეული ბრეკეტები ხაზს უსვამს ელემენტებს თითოეული ქვეჯგუფისთვის. ასეთი მასივი ასევე შეიძლება წარმოდგენილი იყოს ცხრილის სახით:

1	2
4	5
7	8

თქვენ ასევე შეგიძლიათ გამოტოვოთ ხვეული ბრეკეტები ინიციალიზაციის დროს:

Int რიცხვები = ( 1, 2, 4, 5, 7, 8);

ასევე შესაძლებელია არა ყველა ელემენტის, არამედ მხოლოდ ზოგიერთი ელემენტის ინიციალიზაცია:

Int რიცხვები = ( (1, 2), (), (7) );

და ჩადგმული მასივის ელემენტებზე წვდომისთვის საჭიროა ორი ინდექსი:

Int რიცხვები = ( (1, 2), (3, 4), (5, 6) ); std::cout<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

მოდით გავიმეოროთ ორგანზომილებიან მასივზე:

#შეიცავს int main() ( const int რიგები = 3, სვეტები = 2; int რიცხვები = ( (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; }

თქვენ ასევე შეგიძლიათ გამოიყენოთ for loop-ის სხვა ფორმა მრავალგანზომილებიანი მასივის ელემენტების გამეორებისთვის:

#შეიცავს int main() ( const int რიგები = 3, სვეტები = 2; int რიცხვები = ( (1, 2), (3, 4), (5, 6)); for(ავტო &ქვენომრები: ნომრები) ( for(int ნომერი : ქვენომრები) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

მასივში შემავალი მასივების გამეორებისთვის გამოიყენება ცნობები. ანუ, გარე ციკლში for(auto &subnumbers: numbers) &subnumbers წარმოადგენს ქვემასივის მითითებას მასივში. შიდა მარყუჟში for(int number: subnumbers), ქვენომრების თითოეული ქვემასივიდან ჩვენ ვიღებთ მის ცალკეულ ელემენტებს რიცხვის ცვლადში და გამოვაქვთ მისი მნიშვნელობა კონსოლში.

მასივები შექმნილია იმავე ტიპის მრავალი მნიშვნელობის შესანახად. მაგალითად, ფარენჰეიტიდან ცელსიუსამდე პროგრამაში, ჩვენ გამოვთვალეთ საშუალო ტემპერატურის მნიშვნელობა სამიდან. თუ არ არის სამი მნიშვნელობა, მაგრამ ბევრად მეტი, მაშინ აქ თქვენ უნდა გამოიყენოთ მასივები.

სანამ მასივის გამოყენებას შეძლებთ, თქვენ უნდა განსაზღვროთ იგი. მასივის განმარტება მოიცავს: მასივში შენახული მონაცემების ტიპს, მასივის სახელს და მასივის ელემენტების რაოდენობას კვადრატულ ფრჩხილებში:

int მასივი;

ამ კოდში განვსაზღვრეთ მასივი int ტიპის ათი ელემენტის იდენტიფიკატორის (სახელის) მასივით.
ამ ფორმით, მასივის ყველა ელემენტი ჯერ კიდევ არ არის ინიცირებული. გამოცხადებისას მათი ინიციალიზაციისთვის, თქვენ უნდა გამოიყენოთ შემდეგი სინტაქსი:

int მასივი = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

ამ შემთხვევაში, მასივის პირველ ელემენტს ენიჭება მნიშვნელობა 0, ხოლო ბოლო - მნიშვნელობა 9.
თქვენ შეგიძლიათ გამოიყენოთ მარყუჟები მასივის ელემენტებზე მნიშვნელობების მინიჭებისთვის. ამისთვის ყველაზე შესაფერისი იქნება for loop.

კოდი c++ ენაზე int მასივი; // მასივის განმარტება (int i = 0; i< 10; i++) { array[i] = i; }

აქ მასივის თითოეულ ელემენტს ვწვდებით ინდექსის მეშვეობით - რიცხვი კვადრატულ ფრჩხილებში. მარყუჟის ყოველი გამეორებისას ის იღებს მნიშვნელობებს ნულიდან 9-მდე.

გაითვალისწინეთ, რომ ინდექსის ნუმერაცია იწყება ნულიდან. ამიტომ, ინდექსების რაოდენობა ყოველთვის ერთით ნაკლებია მასივის ელემენტების რაოდენობაზე.

კვადრატული ფრჩხილებისა და ხელმოწერების გარდა, მასივის ელემენტი გამოიყენება ისევე, როგორც ნებისმიერი ცვლადი.

სიმები

აქამდე სტრიქონების შენახვა მხოლოდ მუდმივებში შეგვეძლო: „მუდმივი სტრიქონის მაგალითი“. ჩვენ შეგვეძლო მხოლოდ ერთი სიმბოლოს შენახვა ცვლადებში - char ტიპის. C++ იყენებს ორი ტიპის სტრიქონებს: char და ტიპის str ელემენტების მასივს. ჯერჯერობით პირველ ვარიანტზე გავამახვილებთ ყურადღებას.

სტრიქონის შესანახად ჩვენ გვჭირდება მასივი. ეს დაახლოებით ასე გამოიყურება:

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

საბედნიეროდ არის უფრო მარტივი გზა :)

char string = "სტრიქონი";

ამ შემთხვევაში ავტომატურად შეიქმნება შვიდი ელემენტისგან შემდგარი მასივი. რატომ შვიდიდან? საქმე იმაშია, რომ თითოეული ხაზი უნდა დასრულდეს სიმბოლოს მუდმივი "\0", რომელიც წარმოადგენს ცარიელ ბაიტს.

წინა მაგალითებში, თუ შევეცდებით ექვს სიმბოლოზე მეტი სტრიქონის შეყვანას სიმებიანი მასივში, მასივი გადაიჭრება, რადგან თქვენ არ შეგიძლიათ შეცვალოთ მასივის ზომა პროგრამის გაშვებისას (თუმცა არა ყოველთვის):

char string; // სტრიქონს შეუძლია შეინახოს ექვსი სიმბოლო და "\0"

string = "სტრიქონი!"; // სტრიქონი შეიცავს შვიდ სიმბოლოს
ამის გაკეთება არ არის რეკომენდებული :)

არის კიდევ ერთი მომენტი, რომელზეც მინდა თქვენი ყურადღება გავამახვილო. როდესაც მომხმარებელი შეაქვს სტრიქონს, ინტერვალი ითვლება "\0". ჩვენ ჯერ არ შევიტანთ სტრიქონებს ჩვენს პროგრამებში, ამიტომ დეტალურად არ ავხსნი ამ შემთხვევას.

მასივების მასივები (ორგანზომილებიანი მასივები)

ბოლოს და ბოლოს მივედით ამ საკითხში ყველაზე მნიშვნელოვანზე.

რუკა სტრატეგიულ (და არა მხოლოდ) თამაშებში (RTS) იყოფა უჯრედებად (ინგლისურად - ფილა). მოსახერხებელია ამ უჯრედების წარმოდგენა ორგანზომილებიანი მასივის გამოყენებით.

ამ მაგალითში ჩვენ გავაგრძელებთ მუშაობას pseudo_game პროგრამასთან და ორგანზომილებიანი მასივის გამოყენებით მოვახდენთ რუკას, რომელზეც მოთამაშეს შეუძლია გადაადგილება. აქამდე „მოძრაობა“ წარმოდგენილი იყო x, y კოორდინატების გამოყენებით.

ჩვენ წარმოვადგენთ უჯრედებს სიმბოლოებით. "ბარათის" ზომაა 15x20. თხუთმეტი სიმაღლე, ოცი სიგანე. ჩვენ წარმოვადგენთ მოთამაშეს სიმბოლოთი T.

ჯერ დაამატეთ სათაურის ფაილი stdlib.h.

გაუმჯობესებული ფსევდო_თამაში

მე მივცემ მხოლოდ კოდის ნაწილებს. მიზანშეწონილია სრული პროგრამა გქონდეთ თვალწინ. თქვენ შეგიძლიათ იპოვოთ ის განყოფილებაში "პროგრამების ჩამონათვალი" - pseudo_game_0_2. ის აწყობს და მუშაობს. უბრალოდ დააკოპირეთ იგი თქვენს IDE-ის რედაქტორში და მიჰყევით ტექსტს.

მონაცემთა ინიციალიზაცია:

კოდი c++ ენაზე char აქტი; // ცვლადი მომხმარებლის შეყვანის წასაკითხად int ch; // ცვლადი act int x = 0 ცვლადის შემცირებული მნიშვნელობის შესანახად; // ორი ცვლადი მოთამაშის კოორდინატების შესანახად int y = 0; char რუკა; // მასივი სათამაშო ბარათის შესანახად // მასივის ინიციალიზაცია (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

აქ, ჩვენთვის ახალი ოპერატორი არის ორგანზომილებიანი მასივის განმარტება. მაგრამ ის თითქმის არაფრით განსხვავდება ერთგანზომილებიანისაგან, უბრალოდ დაამატეთ კიდევ ერთი წყვილი კვადრატული ფრჩხილები. პირველ ფრჩხილებში ჩვენ მივუთითეთ რიგების რაოდენობა, მეორეში - სვეტების რაოდენობა.

ამის შემდეგ, ორ მარყუჟში, მასივის თითოეული ელემენტის ინიციალიზაციას ვაკეთებთ მნიშვნელობით " " - რომელიც არის მხოლოდ ცარიელი სივრცის სიმბოლო. პირველი, გარე მარყუჟში, ჩვენ გავდივართ ყველა რიგს. შიდა მარყუჟის თითოეული მწკრივისთვის ჩვენ "გადავლით" სვეტები.

მოვიყვან დეტალურ მაგალითს: გარე მარყუჟის რამდენიმე გამეორების შემდეგ მრიცხველი i ხდება 9-ის ტოლი. გარე მარყუჟის სხეული იწყებს შესრულებას: ცვლადი j (შიდა მარყუჟის მრიცხველი) ინიციალიზებულია ნულამდე. მოწმდება მდგომარეობა და შესრულებულია შიდა მარყუჟის სხეული: map = " ";, ანუ მეათე სტრიქონის პირველ სიმბოლოს (ინდექსი ნული) (არ დაგავიწყდეთ, რომ ათვლა ნულიდან არის) ენიჭება სივრცე. შემდეგ მრიცხველ j-ს ენიჭება 1, შესრულებულია მარყუჟის სხეული... და ასე გრძელდება მანამ, სანამ მრიცხველი j არ გახდება 20-ის ტოლი - პირობა არ არის დაკმაყოფილებული და შიდა მარყუჟი გადის. შემდეგ გარე მრიცხველი იზრდება. ახლა ის უდრის 10-ს და გარე მარყუჟის სხეული კვლავ შესრულებულია...

ინტერვალით ინიციალიზაციის შემდეგ, ჩვენ ვათავსებთ ჩვენი თამაშის პერსონაჟს პირველი რიგის პირველ სვეტში.

მთავარი მარყუჟის დასაწყისში ჩვენ ვუწოდებთ system() ფუნქციას წინა გამომავალი ეკრანის გასასუფთავებლად.

შემდეგ არის ინიციალიზაციის ციკლების მსგავსი ორი ციკლი. ისინი გამოიყენება მასივის ელემენტების ეკრანზე საჩვენებლად. ერთადერთი მნიშვნელოვანი განსხვავება არის ახალი ხაზის სიმბოლოს გამომავალი პირველი მარყუჟის სხეულის ბოლოს.

კარგი, მაშინ არის განშტოება, რომელშიც დგინდება, რომელი ღილაკია დაჭერილი. განშტოება თავისთავად ცოტა შეიცვალა ბოლო პერიოდის შემდეგ, მაგრამ არის განსხვავებები ბლოკების შიგთავსში: პირველ რიგში, ჩვენ ვაძლევთ სივრცეს იმ კოორდინატებს, სადაც მდებარეობს ობიექტი. ანუ ვასუფთავებთ წინა ადგილს. შემდეგ ჩვენ ვცვლით ერთ-ერთ კოორდინატს. და შემდეგ, მასივის ელემენტს ახალი ინდექსებით, ჩვენ ვანიჭებთ სიმბოლოს "T".

მაგალითი კოდისთვის "75" - მოძრაობა მარცხნივ:

კოდი c++ ენაზესხვა შემთხვევაში (ch == 75) (რუკა[x][y] = " "; y--; რუკა[x][y] = "T"; )

ისე, ძირითადად ეს ასეა. ამ დროისთვის გვაქვს 15x20 რუკა, რომელზედაც შეგიძლიათ გამოიყენოთ ისრები პერსონაჟის გადასატანად - ასო "T". ცუდი არ არის მეექვსე გაკვეთილისთვის! ეს აპლიკაცია გახდება ჩვენი კონსოლის ყველა პროგრამის საფუძველი. გრაფიკული გაუმჯობესება არ იქნება. თქვენ უბრალოდ ვერ მიიღებთ მეტს DOS კონსოლიდან და ჩვენ არ განვიხილავთ Windows კონსოლს. ეს მნიშვნელოვნად დაზოგავს დროსა და ძალისხმევას.

მე დეტალურად გავაკეთე კომენტარი pseudo_game პროგრამაზე და დიდი ალბათობით უპრობლემოდ გაიგებთ. თუ არა, მაშინ ხელახლა წაიკითხეთ პროგრამის ჩამონათვალი და სანამ არ გაიგებთ ამ საკითხს ვერ გაიგებთ :). სავარჯიშოები დაგეხმარებათ მასალის კონსოლიდაციაში. სავარჯიშოების შესრულება სავალდებულოა. თუ რამე გაუგებარია, მომწერეთ ჩემს მეილზე - ვეცდები დაგეხმაროთ.

Სავარჯიშოები:

1. პროგრამის სრულ ჩამონათვალში გამოვიყენე გადართვის განშტოება. კოდი one if ფილიალის ბლოკისთვის ასევე ნაჩვენებია აქ. დაამატეთ დარჩენილი if ბლოკები.

2. ახლა პროგრამას შეუძლია ჩაწეროს მასივის არარსებულ ელემენტებზე. შეამოწმეთ რუკის ლიმიტების დატოვება.

3. პრაქტიკისთვის შექმენით პროგრამა, რომელიც ეკრანზე ხაზავს ორ ველს საზღვაო ბრძოლისთვის. პირველი არის მოთამაშისთვის, მეორე - მტრისთვის. მეორე ველი უნდა განთავსდეს პირველის მარჯვნივ.
შეავსეთ შიდა უჯრედები სივრცეებით. საზღვრის დასახაზად გამოიყენეთ მინუს და სწორი გამყოფი ხაზი: -, | და კუთხეებისთვის გამოიყენეთ ჰეში #. თითოეული ველის მარცხნივ არის რიცხვების დასტა; თავზე არის ასოები.
შეიძლება დაგჭირდეთ რამდენიმე მარყუჟი მთელი ველის ინიციალიზაციისთვის. აი, როგორ შეიძლება გამოიყურებოდეს კოდი მეორე ველში რიცხვების სვეტის შესავსებად:

კოდი c++ ენაზე int სტრიქონი; // ცვლადი, რომელიც წარმოადგენს რიგებს int სვეტში; // ცვლადი, რომელიც წარმოადგენს სვეტების char რუკას; სვეტი = 15; for (სტრიქონი = 2; სტრიქონი< 12; string++) { map = string - 1; }