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

არის მეხსიერების მიმდებარე ნაწილი, რომელიც შეიცავს იმავე ტიპის ობიექტების თანმიმდევრობას, რომელიც აღინიშნება ერთი სახელით.

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

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

• ელემენტის მისამართი - საწყისი მეხსიერების უჯრედის მისამართი, რომელშიც მდებარეობს ეს ელემენტი;
• ელემენტის ინდექსი (ელემენტის რიგითი ნომერი მასივში);
• ელემენტის ღირებულება.

მასივის მისამართი – მასივის საწყისი ელემენტის მისამართი.

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

მასივის ზომა – მასივის ელემენტების რაოდენობა

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

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

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

მასივის i-ე ელემენტის მისამართებია

მასივის მისამართი არის მასივის საწყისი (ნულოვანი) ელემენტის მისამართი. მასივის ელემენტებზე წვდომისათვის გამოიყენება ელემენტის სერიული ნომერი (ინდექსი), რომლის საწყისი მნიშვნელობა არის 0. ასე რომ, თუ მასივი შეიცავს q ელემენტებს, მაშინ მასივის ელემენტების ინდექსები იცვლება 0-დან q-1-მდე.

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

მასივის სიგრძე = ელემენტის ზომა * ელემენტების რაოდენობა

ფუნქცია შეიძლება გამოყენებულ იქნას მასივის ელემენტის ზომის დასადგენად

int sizeof(type);

მაგალითად,

ზომა (char) = 1;
sizeof(int) = 4;
sizeof(float) = 4;
ზომა (ორმაგი) = 8;

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

C-ში მასივის გამოსაცხადებლად გამოიყენება შემდეგი სინტაქსი:

აკრიფეთ სახელი[dimension]=(init);

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

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // მასივი a 10 მთელი რიცხვი

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

int b = (0); // მასივი b 10 ელემენტისგან, ინიციალირებულია 0-ზე

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

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

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

მაგალითი C-ში

1
2
3
4
5
6
7
8

#შეიცავს
int main()
{
int a = (5, 4, 3, 2, 1); // მასივი a შეიცავს 5 ელემენტს
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
დაბრუნება 0;
}

პროგრამის შესრულების შედეგი:

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

int a;

პარამეტრული მარყუჟი ხშირად გამოიყენება მასივის ელემენტების საწყისი მნიშვნელობების დასაყენებლად:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#შეიცავს
int main()
{
int a;
int i;
// მასივის ელემენტების შეყვანა
ამისთვის (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// გამომავალი მასივის ელემენტები
ამისთვის (i = 0; i<5; i++)
printf("%d " , a[i]); // სივრცე ბეჭდვის ფორმატშია საჭირო
getchar(); getchar();
დაბრუნება 0;
}

პროგრამის შესრულების შედეგი

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

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

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

აკრიფეთ სახელი[dimension1][dimension2]...[dimensionm];

მრავალგანზომილებიანი მასივის ელემენტები განლაგებულია RAM-ის თანმიმდევრულ უჯრედებში მისამართების აღმავალი თანმიმდევრობით. კომპიუტერის მეხსიერებაში მრავალგანზომილებიანი მასივის ელემენტები განლაგებულია მწკრივად, მაგალითად, მასივი 2 მწკრივით და 3 სვეტით,

int a;

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

სტრიქონების რაოდენობა * სვეტების რაოდენობა = 2 * 3 = 6.

მეხსიერების ბაიტების რაოდენობა, რომელიც საჭიროა მასივის დასაყენებლად, მოცემულია

პუნქტების რაოდენობა * ელემენტის ზომა = 6 * 4 = 24 ბაიტი.

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

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

მაგალითი C-ში

1
2
3
4
5
6
7
8
9

#შეიცავს
int main()
{
int a = (1, 2, 3, 4, 5, 6);
printf("%d %d %d\n" , a, a, a);
getchar();
დაბრუნება 0;
}

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

მაგალითი C-ში

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#შეიცავს
int main()
{
int a; // 2 მწკრივის და 3 სვეტის მასივი
int i, j;
// მასივის ელემენტების შეყვანა
ამისთვის (i = 0; i<2; i++) // ხაზების გადატანა
{
ამისთვის (j = 0; j<3; j++) // ციკლი სვეტების მეშვეობით
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// გამომავალი მასივის ელემენტები
ამისთვის (i = 0; i<2; i++) // ხაზების გადატანა
{
ამისთვის (j = 0; j<3; j++) // ციკლი სვეტების მეშვეობით
{
printf("%d " , a[i][j]);
}
printf("\n"); // ახალი ხაზი
}
getchar(); getchar();
დაბრუნება 0;
}

მასივის გადაცემა ფუნქციაზე

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

• მასივის მისამართი,
• მასივის ზომა.

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

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

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

მაგალითი C Dan მასივში 10 ელემენტისგან. შეცვალეთ მასივის უდიდესი და საწყისი ელემენტები. ელემენტების ძებნისა და გაცვლის მაქსიმალური ოპერაციებისთვის გამოიყენეთ ფუნქცია.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#შეიცავს
// გაცვლის ფუნქცია
ბათილად ცვლილება (int *x, int n)
{
// x - მაჩვენებელი მასივზე (მასივის მისამართი)
// n - მასივის ზომა
int i;
int max, ინდექსი;
max = x;
ინდექსი = 0;
// მაქსიმალური ელემენტის პოვნა
ამისთვის (i = 1; i {
თუ (x[i]> max)
{
max = x[i];
ინდექსი = i;
}
}
// გაცვლა
x = x;
x = მაქს;
}
// მთავარი ფუნქცია
int main()
{
int a;
int i;
ამისთვის (i = 0; i<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
ცვლილება (a, 10); // გაცვლის ფუნქციის გამოძახება
// გამომავალი მასივის ელემენტები
ამისთვის (i = 0; i<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
დაბრუნება
p = p * x[i];
}
დაბრუნება p;
}
// მთავარი ფუნქცია
int main()
{
int a; // გამოცხადებული მასივი a 5 ელემენტისგან
int i;
int pr;
// მასივის ელემენტების შეყვანა
ამისთვის (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - მასივის i-ე ელემენტის მისამართი
}
pr = func(a, 5); // გამოთვალეთ პროდუქტი
printf("\n pr = %d" , pr); // ლუწი ელემენტების ნამრავლის გამოტანა
getchar(); getchar();
დაბრუნება 0;
}

მასივი არის მონაცემთა სტრუქტურა, რომელიც წარმოდგენილია იმავე ტიპის უჯრედების ჯგუფად, გაერთიანებული ერთი სახელის ქვეშ. მასივები გამოიყენება იმავე ტიპის დიდი რაოდენობით მონაცემების დასამუშავებლად. მასივის სახელი არის მაჩვენებლები, ცოტა მოგვიანებით გეტყვით. მასივის ცალკეულ მონაცემთა უჯრედს მასივის ელემენტი ეწოდება. მასივის ელემენტები შეიძლება იყოს ნებისმიერი ტიპის მონაცემები. მასივებს შეიძლება ჰქონდეს ერთი ან რამდენიმე განზომილება. განზომილებების რაოდენობის მიხედვით, მასივები იყოფა ერთგანზომილებიან მასივებად, ორგანზომილებიან მასივებად, სამგანზომილებიან მასივებად და ასე შემდეგ 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: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #შეიცავს 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; }

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: განსაზღვრავს შესვლის წერტილს კონსოლის აპლიკაციისთვის. #შეიცავს 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 >> მასივი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კოუტ<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// კოდი Code::Blocks

// Dev-C++ კოდი

(176); namespace 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კოუტ<< " "; // вывести два пробела cout << endl; } return 0; }

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

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

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

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

სადაც M არის მწკრივების რაოდენობა, N არის სვეტების რაოდენობა (ბუნებრივი რიცხვები).

კვადრატული მატრიცა- მატრიცა რიგებისა და სვეტების თანაბარი რაოდენობით.

მატრიცის თანმიმდევრობა -კვადრატული მატრიცის რიგების (სვეტების) რაოდენობა.

1. ორგანზომილებიანი მასივის აღწერა

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

პასკალში ინდექსები ჩასმულია კვადრატულ ფრჩხილებში:

A, A,..A.

2-განზომილებიანი მასივის აღწერის 2 გზა არსებობს:

1 მასივის აღწერა ცვლადების განყოფილებაშიVAR:

istart..icon, jstart..jcon- ინდექსის დიაპაზონები (სტრიქონები, სვეტები);

t - ელემენტის ტიპი.

მაგალითად:

VAR y: მთელი რიცხვი;

VAR F: რეალობის მასივის მასივი;

VAR mb: უძრავის მასივი;

VAR C: სტრიქონის მასივი;

CONST M= 4; N=2;

VAR A: მთელი რიცხვის მასივი;

2 მასივის აღწერა ტიპის აღწერილობის განყოფილებაშიტიპი:

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

შევსება სვეტების მიხედვით:

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

სავარჯიშო მასა 1:შეავსეთ A(5, 10) მატრიცა სტრიქონი-სტრიქონით შემთხვევითი რიცხვების გენერირების მეთოდით.

პროგრამა mas_1; (მატრიცის შევსება მწკრივით)

A: მასივი INTEGER;

writeLn('მატრიცა A:');

FOR i:= 1-დან 5-მდე DO(გარე მარყუჟი რიგების მიხედვით)

j:=1-დან 10-მდე DO(შიდა მარყუჟი სვეტების მეშვეობით)

A:= შემთხვევითი (10);

ჩაწერა (A:3); (დაბეჭდეთ მთელი ხაზი ზედიზედ)

ჩაწერაLn; (გადადით ახალ ხაზზე)

სავარჯიშო მასა 2:შეავსეთ A(3, 4) მატრიცა სვეტად კლავიატურიდან რიცხვების შეყვანით.

პროგრამა mas_2; (მატრიცის შევსება სვეტებით)

Const N =4; M =3;

Var A: მასივი INTEGER;

FOR j:= 1-დან M DO(გარე მარყუჟი სვეტებზე)

FOR i:=1 დან N DO(შიდა მარყუჟი რიგებში)

write('შეიყვანეთ ელემენტი A[",i",",","j,"]=');

readLn(A);

writeLn('შედეგის მატრიცა A:');

i:=1-დან N-მდე (მატრიცის გამომავალი)

j:=1-დან M-ისთვის

დაწერე (A,' ');

სავარჯიშო მასა 3:მოცემულია მატრიცა A(N? M), რომელიც შედგება ნატურალური რიცხვებისგან. განსაზღვრეთ მისი მაქსიმალური ელემენტი და მისი ინდექსები.

პროგრამა mas_3; (მატრიცის მაქსიმალური ელემენტი)

CONST t= 10; r=10;

A: მასივი INTEGER;

n, m, Max, iMax, jMax, k: მთელი რიცხვი;

write('შეიყვანეთ ხაზების რაოდენობა N='); readLn(N);

write('შეიყვანეთ სვეტების რაოდენობა M='); readLn(M);

writeLn('მატრიცა:');

FOR i:= 1-დან N DO-მდე (მაივის შევსება შემთხვევითი რიცხვების გენერირებით)

FOR J:=1 TO M DO

A:= შემთხვევითი (10);

ჩაწერა (A:3);

მაქს:= A; iMax:=1; jMax:=1; k:=0;(ვიღებთ საწყის მნიშვნელობას Max = 1 ელემენტის მნიშვნელობა)

იყიდება i:=1-დან N-მდე

იყიდება j:=1-დან M-მდე

IF A > მაქს მაშინ

მაქს:= A; iMax:=i; jMax:=j; k:=1

WriteLn(‘Max=’ ,Max,’ მწკრივში: ‘,imax, ‘ column:’, jmax);

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

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

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

ორგანზომილებიანი პასკალური მასივის აღწერა.

ორგანზომილებიანი პასკალის მასივის გამოცხადების რამდენიმე გზა არსებობს.

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

ტიპი
ვექტორი = მასივი<тип_элементов>;
მატრიცა= ვექტორის მასივი;
Var m: მატრიცა;

ჩვენ გამოვაცხადეთ ორგანზომილებიანი პასკალური მასივი m, რომელიც შედგება 10 მწკრივისაგან, რომელთაგან თითოეულს აქვს 5 სვეტი. ამ შემთხვევაში, თითოეულ i-ე მწკრივზე წვდომა შესაძლებელია m[i]-ით, ხოლო i-ე მწკრივში შემავალ თითოეულ j-ე ელემენტზე წვდომა შესაძლებელია m[i,j]-ით.

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

ტიპი
Matrix= მასივის მასივი< тип элементов >;
ან კიდევ უფრო მარტივი:
ტიპი
მატრიცა = მასივი<тип элементов>;

ორგანზომილებიანი მასივის ელემენტებზე წვდომას აქვს ფორმა: M [i, j]. ეს ნიშნავს, რომ ჩვენ გვინდა მივიღოთ ელემენტი, რომელიც მდებარეობს i -ე მწკრივში და j -th სვეტში. აქ მთავარია არ აგვერიოს სტრიქონები სვეტებთან, წინააღმდეგ შემთხვევაში შესაძლოა ისევ არარსებულ ელემენტზე მივიღოთ წვდომა. მაგალითად, M ელემენტზე წვდომას აქვს სწორი აღნიშვნა, მაგრამ შეიძლება გამოიწვიოს პროგრამაში შეცდომა.

ძირითადი ოპერაციები ორგანზომილებიანი პასკალური მასივებით

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

ტიპი
matrix= მთელი რიცხვის მასივი;
ვარ
a, b: მატრიცა;

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

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

ორგანზომილებიანი პასკალური მასივის შეყვანა.

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

ტიპი
მაგალითი პროგრამა კლავიატურიდან ორგანზომილებიანი პასკალის მასივის შესვლისთვის
ვარ
matrix= მთელი რიცხვის მასივი;
a, : მატრიცა;
i, j: მთელი რიცხვი; (მასივის ინდექსები)
დაიწყება
i:=1-დან 5-მდე do (გამეორება ყველა მწკრივში)

readln(a[i,j]); (ელემენტის კლავიატურის შეყვანა i-ე მწკრივში და j-ე სვეტში)

ეკრანზე ორგანზომილებიანი პასკალური მასივის დაბეჭდვა.

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

i:=1-დან 5-მდე do (გამეორება ყველა მწკრივში)
i, j: მთელი რიცხვი; (მასივის ინდექსები)
j:=1-დან 10-მდე do (გამეორება მწკრივის ყველა ელემენტის სვეტის მიხედვით)
ჩაწერა (a[i,j]:4); (მატრიცის i-ე მწკრივში განთავსებული ელემენტების დაბეჭდვა ეკრანის ერთ ხაზზე, თითოეული ელემენტის ჩვენებისთვის გამოყოფილი 4 პოზიციით)
წერენ ; (მატრიცაში მწკრივის ნომრის შეცვლამდე, თქვენ უნდა გადაიტანოთ კურსორი ეკრანის ახალი ხაზის დასაწყისში)
დასასრული ;

შენიშვნა ( ეს მნიშვნელოვანია!): ძალიან ხშირად სტუდენტურ პროგრამებში არის შეცდომა, როდესაც ისინი ცდილობენ შევიდნენ კლავიატურიდან ან აჩვენონ მასივი შემდეგნაირად: readln (a), writeln (a), სადაც აარის მასივის ცვლადი. ამავდროულად, ისინი გაკვირვებულნი არიან შემდგენელი მესიჯით, რომ ამ ტიპის ცვლადის წაკითხვა ან დაბეჭდვა შეუძლებელია. იქნებ მიხვდეთ, რატომ არ შეიძლება ამის გაკეთება, თუ წარმოგიდგენიათ N ჭიქები ზედიზედ მდგარი და თქვენს ხელში, მაგალითად, წყლის ქვაბი. შეგიძლიათ გამოიყენოთ ბრძანება "დაასხით წყალი" ყველა კათხის ერთდროულად შესავსებად? რაც არ უნდა ეცადოთ, თითოეულ ფინჯანში ცალ-ცალკე უნდა ჩაასხით. მასივის ელემენტების შევსება და ჩვენება ასევე უნდა მოხდეს თანმიმდევრულად და ელემენტ-ელემენტზე, რადგან კომპიუტერის მეხსიერებაში მასივის ელემენტები განლაგებულია თანმიმდევრულ უჯრედებში.

ორგანზომილებიანი პასკალური მასივის წარმოდგენა მეხსიერებაში

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

და რამდენ ადგილს დაიკავებს მასივისაგან შემდგარი მასივი, ე.ი. მატრიცა? ცხადია: S i^S j, სადაც S i არის ხაზების რაოდენობა და S j არის ელემენტების რაოდენობა თითოეულ სტრიქონში. მაგალითად, მასივის მსგავსი

მატრიცა = მთელი რიცხვების მასივი;

საჭირო იქნება 12 ბაიტი მეხსიერება.

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

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

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

Adr + SizeElem * Cols *(I -1)+ SizeElem *(J -1),

სადაც Adr არის რეალური საწყისი მისამართი, რომელზეც მასივი მდებარეობს მეხსიერებაში; I, J – ელემენტის ინდექსები ორგანზომილებიან მასივში; SizeElem – მასივის ელემენტის ზომა (მაგალითად, ორი ბაიტი მთელი რიცხვის ტიპის ელემენტებისთვის); Cols - ელემენტების რაოდენობა ხაზში.

გამოთქმას SizeElem * Cols *(I -1)+ SizeElem *(J -1) ეწოდება ოფსეტი მასივის დასაწყისთან მიმართებაში.

რამდენი მეხსიერებაა გამოყოფილი მასივისთვის?

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

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

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

აკრიფეთ myArray= მთელი რიცხვის მასივი;

თქვენ უკვე იცით, რომ მთელი რიცხვების ორ ბაიტიანი წარმოდგენის გათვალისწინებით, რეალურად შესაძლებელია გამოვაცხადოთ მასივი, რომლის ელემენტების რაოდენობა ტოლია 65536/2 –1=32767. და მხოლოდ მაშინ, თუ სხვა ცვლადები არ არის. ორგანზომილებიან მასივებს უნდა ჰქონდეს კიდევ უფრო მცირე ინდექსის საზღვრები.

პასკალის ორგანზომილებიანი მასივებით ამოცანების ამოხსნის მაგალითები

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

გამოსავალი:

• ამ პრობლემის გადასაჭრელად გვჭირდება ცვლადები: მატრიცა, რომელიც შედგება, მაგალითად, მთელი ელემენტებისაგან; P – 0-სგან განსხვავებული ელემენტების ნამრავლი; I, J – მასივის ინდექსები; N, M - რიგების და სვეტების რაოდენობა მატრიცაში.
• შეყვანის მონაცემები არის N, M - ჩვენ შევიყვანთ მათ მნიშვნელობებს კლავიატურიდან; მატრიცა – მატრიცას შევსებთ პროცედურის სახით, ე.ი. random() ფუნქციის გამოყენებით.
• გამომავალი მონაცემები იქნება P ცვლადის მნიშვნელობა (პროდუქტი).
• პროგრამის სწორად შესრულების შესამოწმებლად აუცილებელია მატრიცის ჩვენება ეკრანზე, ამისთვის დავაფორმებთ მატრიცის ჩვენების პროცედურას.
• პრობლემის მოგვარების პროგრესი:

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

• შევიყვანოთ მნიშვნელობები N და M;
• შემოვიღოთ ორგანზომილებიანი პასკალური მასივი, ამისთვის მივმართავთ პროცედურას vvod (a), სადაც a არის მატრიცა;
• ამისთვის დაბეჭდეთ მიღებული მატრიცა, გამოვიყენოთ ბეჭდვის (a) პროცედურა;
• ცვლადს მივანიჭოთ საწყისი მნიშვნელობა P =1;
• ჩვენ თანმიმდევრულად ვიმეორებთ I ყველა სტრიქონს 1-დან N-მდე, თითოეულ მწკრივში ვიმეორებთ J ყველა სვეტს 1-დან Mth-მდე, მატრიცის თითოეული ელემენტისთვის შევამოწმებთ პირობას: თუ a ij ? 0, მაშინ P ნამრავლი გამრავლდება a ij ელემენტზე (P = P * a ij);
• გამოვავლინოთ არანულოვანი მატრიცის ელემენტების ნამრავლის მნიშვნელობა – P;

ახლა მოდით ვისაუბროთ პროცედურებზე.

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

ტიპი
მატრიცა=მთლიანი რიცხვების მასივი;
პროცედურის პრაიმერი (ა: მატრიცა);
..............................

ახლა დავუბრუნდეთ ჩვენს პროცედურებს.

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

პროცედურა vvod (var m: matrix);

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

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

პროცედურის ბეჭდვა (მ: მატრიცა);

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

პროგრამის წარმოება;
ტიპი
მატრიცა=მთლიანი რიცხვების მასივი;
ვარ
A: მატრიცა;
N, m, i, j: ბაიტი;
P: მთელი რიცხვი;
პროცედურა vvod (var m: matrix);
Var k, h: ბაიტი;
დაწყება
i:=1-დან n-მდე (პროცედურისთვის ცვლადი n არის გლობალური და, შესაბამისად, „ცნობილი“)
j:=1-დან m do (ცვლადი m პროცედურისთვის არის გლობალური და, შესაბამისად, "ცნობილი")
M:= შემთხვევითი (10);
დასასრული;
პროცედურის ბეჭდვა (მ: მატრიცა);
Var k, h: ბაიტი;
დაწყება
იყიდება i:=1-დან n-მდე
დაიწყება
იყიდება j:=1-დან m-მდე
ჩაწერა (M:4);
დაწერა;
დასასრული ;
დასასრული ;
დასაწყისი (მთავარი პროგრამის დასაწყისი)
Writeln ("შეიყვანეთ მატრიცის განზომილება:");
Readln(N, M);
ვვოდ(ა);
ბეჭდვა(ა);
P:=1;
იყიდება i:=1-დან N-მდე
იყიდება j:=1-დან M-მდე
თუ ა<>0 შემდეგ p:=p*a;
Writeln(p);
დასასრული.