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

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

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

ერთი განზომილებიანი მასივი არის მასივი, ერთი პარამეტრი, რომელიც ახასიათებს ერთი განზომილებიანი მასივის ელემენტების რაოდენობას. სინამდვილეში, ერთი განზომილებიანი მასივი არის მასივი, რომელსაც შეუძლია მხოლოდ ერთი ხაზი და სვეტების N-E- ის რიცხვი. სვეტების ერთ-სამგანზომილებიანი მასივი არის მასივის ელემენტები. ფიგურა 1 გვიჩვენებს სტრუქტურას მთელი განზომილებიანი მასივის სტრუქტურა ა.. ამ მასივის ზომა არის 16 საკანი.

ფიგურა 1 - მასივები C ++

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

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

სადაც, int-alert;

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

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

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

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

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

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

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

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

// array.cpp: განსაზღვრავს Console განაცხადის შესვლის წერტილს. # * Stdafx.h "#: << "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; }

/ / კოდი კოდი :: ბლოკები

// dev-c ++ კოდი

// array.cpp: განსაზღვრავს Console განაცხადის შესვლის წერტილს. #Include. Namespace 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; }

-ში რიგები 10 - 11რიცხვი ერთი განზომილებიანი მასივი სახელწოდებით ARRAY1 არის გამოცხადებული და ინიციალიზებულია, რომლის ზომა არის 16 საკანი, ანუ, ასეთი მასივი შეუძლია 16 ნომრის შესანახად. მასივის ნებისმიერი დამუშავება მხოლოდ ციკებთან ერთად ხორციელდება. რომელი ციკლი აირჩიოს გაუმკლავდეს მასივი არის გადაწყვიტოს. მაგრამ საუკეთესო ამ ამოცანის შესაფერისი. Counter CCTM გამოიყენებს ერთ-სამგანზომილებიანი მასივის array1- ის ელემენტებს. ციკლის გაგრძელების პირობებში, არსებობს უთანასწორობის მკაცრი ნიშანი, მას შემდეგ, რაც მეთექვსმეტე ინდექსი Array1 ერთი განზომილებიანი მასივი. მას შემდეგ, რაც ნუმერაციის საკნები იწყება ნულიდან, მაშინ ელემენტების მასივი 16. სხეულის ციკლი, COUT ოპერატორი ბეჭდავს ელემენტები ერთი განზომილებიანი მასივი (იხ დიაგრამა 2).

Obrabotka Massiva Indeks Element 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 39 Array1 -15 გასაგრძელებლად დააჭირეთ ნებისმიერ ღილაკს. . .

ფიგურა 2 - მასივები C ++

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

// array_sum.cpp: განსაზღვრავს Console განაცხადის შესვლის წერტილს. # * Stdafx.h "#: << "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; }

/ / კოდი კოდი :: ბლოკები

// dev-c ++ კოდი

// array_sum.cpp: განსაზღვრავს Console განაცხადის შესვლის წერტილს. #Include. Namespace 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 >\u003e Array1; / / წაიკითხეთ კლავიშების ნომერი კლავიატურაზე<< "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, რადგან ეს შეთანხმებულია ამოცანის მდგომარეობით. თანხა ცვლადში ჩვენ დაგროვებთ ერთი განზომილებიანი მასივის ელემენტების ოდენობას. პირველი ციკლისთვის გამოცხადებული ერთი განზომილებიანი მასივიდან, რომელიც შედის კლავიატურის ნომრებით, რიგები 12 - 13. Counter RAM გამოიყენება სერიული წვდომის Array1 ერთი განზომილებიანი მასივი ელემენტები დაწყებული ინდექსი 0 და მე -9 ინკლუზიური. მეორე ციკლისთვის აჩვენებს მასივის ელემენტებს, რიგები 15 - 16. მესამე ციკლი თანმიმდევრულად კითხულობს ერთ-ერთ განზომილებიანი მასივის ელემენტებს და შეაჯამებს მათ, თანხის ცვლადი, თანხა, რიგები 17 - 18. პროგრამის შედეგი ფიგურაში 3-ში განიხილება.

Elementi Massiva: 0 1 2 3 4 5 6 7 8 9 array1 \u003d (0 1 2 2 3 4 5 6 7 8 9) გააგრძელეთ ნებისმიერი გასაღები. . .

ფიგურა 3 - მასივები C ++

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

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

მდე ამ ეტაპზე, ჩვენ განვიხილეთ ერთი განზომილებიანი მასივები, რომელიც ყოველთვის ვერ შემოიფარგლება. დავუშვათ, რომ საჭიროა მაგიდის მონაცემების დამუშავება. მაგიდაზე ორი მახასიათებელია: რიგების რაოდენობა და სვეტების რაოდენობა. ასევე ორ განზომილებიანი მასივის გარდა, მასივის ელემენტების გარდა, არსებობს მახასიათებლები, როგორიცაა რიგების რაოდენობა და ორი განზომილებიანი მასივის სვეტების რაოდენობა. ეს არის, ვიზუალურად, ორ განზომილებიანი მასივი რეგულარული მაგიდაა, რიგები და სვეტები. სინამდვილეში, ორ განზომილებიანი მასივი არის ერთი განზომილებიანი მასივის ერთი განზომილებიანი მასივი. სტრუქტურა ორ განზომილებიანი მასივი, სახელით A, ზომა M to N ნაჩვენებია ქვემოთ (იხ. სურათი 4).

ფიგურა 4 - მასივები C ++

სად, M არის ორ განზომილებიანი მასივის რიგების რაოდენობა;
n არის ორ განზომილებიანი მასივის სვეტების რაოდენობა;
M * N - მასივის ელემენტების რაოდენობა.

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

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

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

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

/ / მაგალითად, ორ განზომილებიანი მასივის განცხადება: Int A;

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

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

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

ფიგურა 5 - მასივები C ++

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

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

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

/ / კოდი კოდი :: ბლოკები

// dev-c ++ კოდი

/ / array2.cpp: განსაზღვრავს Console განაცხადის შესვლის წერტილს. #Include. Namespace STD- ის გამოყენებით; Int ძირითადი (int argc, char * argv) (// 1-პირობითად "კედლები ლაბირინთი" // 2- "სწორ გზას ადგას, გამომავალი ლაბირინთი" // 0- "ცრუ გზა" int miss \u003d ((1 , 2,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,1,1,1,0,0,0,1,1), (1,2,1,1,0,1,0, 1,2 , 2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 , 2,2,2,2,2,1,1, 1,1,1,1,0,1,0,1), (1,1,1,1,1,1,1,1, 1,1,1,1,2, 1,1,0,1,0,1), (1,0,0,1,0,2,2,2,1,1,0,2,2 , 2,1,1,0,0,0,0,1,1 0.1), (1,0,1,1,1,1,1,1,0,1,1,1,1,1 , 0,1,1,1,1,0,1,), (1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1, 0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,1,0,1,1,1), ( 1,1,0,0,0,1,0 0.1,1,1,1,1,0,0,0,9,1), (1,0,0,1,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 , 2, 1,0,0,0,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 , 2,2,2,2,2,2,2,2,2,2,2,1,0,0,0 1,1,1), (1,2,1,1,1,1 , 1,1,1,1,1,1,1,1,1,1,1,1,0,0,1), (1,2,1,0,0,1,2,2, 2,1,0,0,0,2,2,1,0,0,0,0,1,1,0,1), (1,2,1 1,1,1,1,1, 1,1,1,1,0,0,0,0,1,), (1,2,2,2,2,2, 1,2,1,2,2,2,1,1,1 , 1,1,1,1,), (1,2,1,1,1,2,1,2,1,0, 1,2,2,2,2,2,2,2,2, 1,), (1,2,1,2,1,2,1,1 , 2,1,0,1,1,1,1,1,1,1,1,1), (1,2,1,2,1,2,1,2,1,0, 0, 0,0,0,0,0,0,2,1), (1,2,1,1,2,2,2,1,1,1,1,1,1,1,1,1 , 1,1, 1,1,0,1,2,1), (1,2,1,1,1,1,1,1,0,0,1,0,1,0,0, 1,2,1), (1,2,1,2,2,1,0,1,1,1,0,0,1,1,1,2,1,0,1,1,2 1,), (1,2,1,1,1,1,0,0,0,0,1,1,0,0,0,0,1,0,0,1,2,1, ), (1,2,1, 1,2,1,0,1,1,1,1,1,1,1,1,1,2,1), (1,2,1,1, 2,1, 1,0,2,2,2,2,2,2,2,2,2,2,2,1), (1,2,1,1,2,1,0,2 , 1,2,2, 1,1,1,1,1,1,1,1,1,), (1,2,1,1,1,1,1,1,1,1,1, 1, 1,1,1,1,2,2), (1,2,1,1,1,0,2,1,1,1,1,2,2,2,2,2,2 , 2,2, 2,2,1,), (1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1), (1,2,1,1,1,0,0,1,1,1,1,1,0,0,1,1,1,1,0 , 0,1,0,1,), (1,2 2,2,2,1,0,2,1,2,2,2,2,0,0,0,0,2,2, 0,0,0,0,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1, 1,) // ორი ციკლი - შიდა და გარე, ფორმის თითოეული ელემენტის გასაჩივრება (IN \u003d 0; მე< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); Cout<< static_cast(176); ) სხვა cout.<< " "; // вывести два пробела cout << endl; } return 0; }

სწორი და ცრუ გზა იქნება აღნიშნა იმავე რაოდენობის, მაგალითად, ნულოვანი, მაგრამ სიწმინდე, სწორი გზა არის აღნიშნული ნომერი 2. მასივი ინიციალიზაცია ხელით შესრულებული, მხოლოდ გამარტივება პროგრამა. მას შემდეგ, რაც ორი განზომილებიანი მასივი დამუშავებულია პროგრამაში, ორი ციკლი საჭიროა, ორი განზომილებიანი მასივის ელემენტებს შორის. პირველი ციკლის გადამრთველები ორ განზომილებიანი მასივის რიგებს შორის. მას შემდეგ, რაც რიგები ორ განზომილებიანი მასივი 33, მაშინ ცვლადი- counter მე გაზრდილი 0 დან 33, row 46.. პირველი ციკლის შიგნით არის ციკლისთვის, რომელიც ორი განზომილებიანი მასივის სტრიქონის ელემენტებს შორისაა. მეორე ციკლის სხეულში შიგნით ასრულებს მონაცემთა ტიპის კონვერტაციის Unary ოპერაციებს - Static_Cast<>(), რომელიც ასახავს ხასიათს, ნომერზე 176. მონაცემთა კონვერტაციის ოპერაცია დუბლირებულია ლაბირინთის სიგანეზე. პროგრამის შედეგი (იხ. სურათი 6).

ფიგურა 6 - მასივები C ++

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

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

int array;

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

int array \u003d (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

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

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

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

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

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

სიმჩრები

ჯერჯერობით, ჩვენ შეგვიძლია შევინახოთ რიგები მხოლოდ მუდმივებში: "მუდმივი სიმებიანი მაგალითი". ცვლადებში, ჩვენ შეგვიძლია მხოლოდ ერთი პერსონაჟის შენახვა - char. C ++ -ში გამოიყენება ორი ტიპის სიმები: ქარის ელემენტების და ქუჩის ტიპის მასივი. ახლა ჩვენ ფოკუსირება პირველი ვერსია.

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

char string \u003d ("C", "T", "R", "ო". "კ", "ა");

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

char string \u003d "row";

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

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

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

სიმებიანი \u003d "row!"; / / ხაზი შეიცავს შვიდი სიმბოლო
ეს არ არის რეკომენდირებული :)

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

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

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

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

ამ მაგალითში ჩვენ გავაგრძელებთ მუშაობას Pseudo_Game- ის პროგრამასთან და ორ განზომილებიანი მასივის გამოყენებით, ჩვენ ვიმყოფებით ბარათს, რომელზეც მოთამაშეს შეუძლია გადაადგილება. აქამდე, "შერევა", როგორც ჩანს, კოორდინატები X, y.

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

პირველი დამატება header ფაილი stdlib.h.

გაფართოებული pseudo_game.

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

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

c + + Char აქტი; // ცვლადი წაკითხვის შეყვანის მომხმარებლის int ch; // ცვლადი აქტი INT X \u003d 0-ის განსაზღვრული ღირებულების შენახვის ცვლადი; // ორი ცვლადების შენახვის კოორდინაციის მოთამაშე Int y \u003d 0; Char რუკა; // მასივი თამაშის ბარათის შენახვისთვის // მასივის ინიციალიზაცია (IN \u003d 0; I< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

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

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

მე დეტალურ მაგალითს მივცემ: გარე ციკლის რამდენიმე iteration შემდეგ, Counter მე ხდება 9. გარე ციკლის სხეული იწყება: ცვლადი J (შიდა ციკლის Counter) ინიციალიზებულია ნულოვანი, მდგომარეობა შემოწმდება და შიდა შიდა ციკლი შესრულებულია: რუკა \u003d "";, ეს არის პირველი ხასიათი (ნულოვანი ინდექსი) მეათე სიმები (არ უნდა დაგვავიწყდეს, რომ დათვლა ხორციელდება Scratch) ენიჭება სივრცეში. შემდეგ, მეტრი j ენიჭება 1, ციკლის სხეული შესრულებულია ... და ასე რომ, სანამ Counter J არ არის 20-ის ტოლი, მდგომარეობა არ არის შესრულებული და შიდა ციკლისგან გასვლა. შემდეგ გაიზარდა გარე counter. ახლა კი 10-ის ტოლია და გარე ციკლის სხეული კვლავ შესრულდება ...

თავდაპირველად, პირველი ხაზის პირველ სვეტში დააყენა ჩვენი თამაშის ხასიათი.

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

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

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

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

c + + თუ სხვა (ch \u003d\u003d 75) (რუკა [x] [y] \u003d ""; y - map [x] [y] \u003d "t";)

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

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

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

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

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

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

c + + Int string; // ცვლადი წარმოადგენს ხაზების int სვეტს; // ცვლადი წარმოადგენს Char Map Columns; სვეტი \u003d 15; (სიმებიანი \u003d 2; სიმებიანი< 12; string++) { map = string - 1; }

გთხოვთ, პაუზა ამ საიტზე.

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

Fig.1 ცვლადები და მასივები. ანალოგია ყუთებით.

სურათზე ზემოთ, სამი მასივი გამოსახულია:

• arr_int- ის 8 ელემენტის რიცხვის მასივი
• 11 ელემენტის ნამდვილი მასივი დაასახელა arr_float
• სიმბოლური მასივი 6 ელემენტის სახელწოდებით Arm_char

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

Შენიშვნა!

მასივის ელემენტების ნუმერაცია ნულოვანით იწყება და არა ერთი.

მასივის განცხადება და ინიციალიზაცია

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

ჩამონათვალი 1.

Int arr_int; ორმაგი ar_float; Float ნომერი;

მასივის სახელით, შეზღუდვები superimposed, მსგავსი იმ superimposed სახელით ცვლადი.

წესის დასახელება

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

აქ არის კიდევ რამდენიმე მაგალითი მასივები:

ჩამონათვალი 2.

Int კლასების, შეკვეთა; ორმაგი ფასები;

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

ჩამონათვალი 3.

Int arr_int \u003d (2, 5, 5, 3, 4); ორმაგი Arr_Float \u003d (1.2 -2.3, 4.5, 3.83, 0.01, -0.12, 44.2, 123.7, 23,44, -3.7, 7);

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

ჩამონათვალი 4.

ორმაგი arr \u003d (0);

მასივის ცალკე ელემენტებთან მუშაობა

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

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

ჩამონათვალი 5.

#Include. Int ძირითადი (void) (int arr \u003d (2, 4, 3, 5, 5); printf ( "% d% d% d% d% d \\ n", arr, arr, arr, arr, arr); დაბრუნება (0);

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

ჩამონათვალი 6.

#Include. Int main (ბათილად) (int arr \u003d (0); ამისთვის (int i \u003d 0; მე< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

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

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

ჩამონათვალი 7.

#Include. #Include. #Include. int main (boid) (Srand (დრო (null); int count \u003d (0); int rand_number; for (int i \u003d 0; მე< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

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

რა არის მასივები?

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

როგორ უნდა დაიწყოს მასივები SI?

მასივები si for dummies.

მასივები C.

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

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

// @author subbotin bp.h\u003e ბათილად ძირითადი (void) (int narr; narr \u003d 1; narr \u003d 2; narr \u003d 3; printf ( "\\ n \\ tarray \\ n \\ n"); printf ( "narr \\ T \u003d \\ t% d \\ n ", narrr); printf (" narr \\ t \u003d \\ t% d \\ n ", narrr); printf (" narr / t \u003d \\ t% d \\ n ", narr); დაბრუნება 0 ;

ჩვენ მივიღებთ:

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

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

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

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

ჩვენ ვატარებთ მასივის მესამე ელემენტს და მესამე ელემენტს აქვს ორი ინდექსი:

მასივის ელემენტების ჩვენება, ჩვენ მივიღებთ მათ ღირებულებებს. Ამგვარად:

printf ("ამბავი \\ t \u003d \\ t% d \\ n", ნარერილი);

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

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

ჩვენ ვატარებთ INT ცვლადის მესამე მასივის ელემენტის ღირებულებას:

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

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

int nar; // მასივი გამოცხადდება ასი რიცხვების შენახვისთვის;
Float farr; / / მასივი გამოცხადდა 5 ნომრის ტიპების შენახვისთვის;
char carr; / / მასივი გამოცხადდა ორი სიმბოლოების შენახვისთვის;

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

Int varelem;
Int nar; // შეცდომა! ელემენტების რაოდენობა არ შეიძლება განისაზღვროს ცვლადით;

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

Const Int Arraylength \u003d 3;
Int nar;

SI- ში მასივის გამოცხადებისას დაუყოვნებლივ შეიძლება ინიციალიზაცია:

int nmassiv \u003d (1, 2, 3);

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

int nmassiv \u003d (1, 2, 3);

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

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

int nmassiv \u003d (1, 2);

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

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

char Carr \u003d ("S", "B", "P");

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

Int ind \u003d 0;
Char cr \u003d carr;

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

// @Author subbotin b.p..h.h\u003e გაუმოდა ძირითადი (ბათილად) (Const Int Arraylength \u003d 3; int nar; for (int inn \u003d 0;< 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- ის მასივი და მეორე ციკლში, ჩვენ ეკრანზე ეს ელემენტები გამოვხატავთ.

ბოლო განახლება: 09/17/2017

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

Type_name_massiva სათაური [length_massiva]

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

Int ნომრები;

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

Int ციფრები \u003d (1,2,3,4);

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

Int ნომრები \u003d (1, 2, 3, 4, 5, 6);

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

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

Int ნომრები \u003d (1, 2, 3, 4, 5, 6);

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

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

Char s1 \u003d ("H", "ე", "ლ", "ლ", "ო"); char s2 \u003d "მსოფლიო";

უფრო მეტიც, მეორე შემთხვევაში, S2 Array ექნება 5 ელემენტები, და 6, რადგან როდესაც ინიცირება სიმებიანი ხასიათი მასივი, ნულოვანი სიმბოლო "\\ 0" ავტომატურად დასძინა.

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

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

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

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

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

Const Int n \u003d 4; Int ნომრები [n] \u003d (1,2,3,4);

ტალღის მასივები

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

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

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

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

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

ჩვენ ვიყენებთ ამ ფორმას მასივის გამაჯანსაღებლად:

#Include. int main () (int numbers \u003d (1,2,3,4); ამისთვის (int ნომერი: ნომრები) STD :: cout<< number << std::endl; return 0; }

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

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

იყიდება (ავტო ნომერი: ნომრები) STD :: COUT<< number << std::endl;

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

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

Int ნომრები;

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

Int ციფრები \u003d ((1, 2), (4, 5), (7, 8));

Nested Curly ფრჩხილებში delineated მიერ ელემენტები თითოეული submassium. ასეთი მასივი კვლავ შეიძლება წარმოდგენილი იყოს ცხრილში:

1	2
4	5
7	8

ასევე ინიციალიზაციის დროს, შეგიძლიათ ქვედა braces:

Int ციფრები \u003d (1, 2, 4, 5, 7, 8);

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

Int ნომრები \u003d ((1, 2), (), (7));

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

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

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

#Include. Int main (const introws \u003d 3, სვეტები \u003d 2; int ციფრები \u003d ((1, 2), (3, 4), (5, 6)) (int i \u003d 0; მე< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

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

#Include. int main (const introws \u003d 3, სვეტები \u003d 2; int ციფრები \u003d ((1, 2), (3, 4), (5, 6)) for (ავტო და სუბნამბერები: ნომრები) (for int ნომერი: Subnumbers) (STD :: COUT<< number << "\t"; } std::cout << std::endl; } return 0; }

მასივიდან, რომლებიც შედის მასივში, ბმულები გამოიყენება. ეს არის გარე ციკლისთვის (ავტო და სუბნამბერები: ნომრები) და Subnumbers წარმოგიდგენთ მითითებას წყალქვეშა მასივში. სუბნომბდამშენებებში თითოეული submassive- ს შიდა ციკლისთვის (Int ნომერი: subnumbers), ჩვენ ინდივიდუალურ ნივთებს მივიღებთ ნომერზე ცვლადს და აჩვენებს კონსოლს.